Curso_de_programación_para_Civil_3D_y_AutoCAD_Spanish_Edition

Prévia do material em texto

Curso de programación para Civil 3D y
AutoCAD
Curitiba, 2020
Curso de programación para Civil 3D y AutoCAD
Autor:
Neyton Luiz Dalle Molle
Ingeniero Civil
Crea-PR 62.324/D
neyton@yahoo.com
WhatsApp: +55 41 98884 3044
https://tbn2net.com
https://tbn2.blogspot.com
Este material, en su totalidad o en partes, está protegido por la ley de derechos de autor
LEY N.º 9.610, DE FEBRERO 1998
(http://www.planalto.gov.br/ccivil_03/leis/l9610.htm).
La reproducción, total o parcial, está expresamente prohibida sin el consentimiento
expreso del autor.
Todo el material es de autoría propria, excepto cuando se indique lo contrario con un
enlace al material original.
mailto:neyton@yahoo.com
https://tbn2net.com
https://tbn2.blogspot.com
http://www.planalto.gov.br/ccivil_03/leis/l9610.htm
Sumario
Introducción
Estructuras de programación
Instrucción Sub
Instrucción Function
If
For
While
DO
Case/Switch
Try
Requisitos
Civil 3D
Visual Studio
Excel
HTML Help WorkShop
Referenciar DLLs
Comprensión de la orientación a objetos
Tipagen
Público/Privado/Distribuido
Clase/Módulos/Estructuras
Fields (campos)
Properties (Propriedades)
Métodos
Instancia
Herencia
Atributos
Enumeradores
Constantes
Hello World
Crear Comando
Acceda a AutoCAD
Acceda al documento actual
Poniendo todo junto...
Importaciones
Entrada de datos
Distancias
Número entero
Número real
Texto
Palabras clave (Keywords)
Coordenadas
Entidades (líneas, textos etc.)
Selecciones
Crear filtros para la selección.
Transacciones
Crear
Nido
Finalizar
Abortar
Acceder la base de datos de AutoCAD
Documentos
Crear
Documento Actual
Abrir
Salvar
Model Space
Objetos
ObjectID
DBObject
Entity
Leer propriedades
Escribir propriedades
Nociones de reflexión
Listar todas las propriedades
Listar todos los atributos
Creando objetos
Punto
Línea
Polilínea
Texto
Bloque
Nociones de ergonomía del software
a) Definición
b) Ventajas:
c) Desventajas:
d) Principios Básicos:
1 – Esfuerzo mínimo del Usuario:
2 - Menoria Mínima de Usuário:
3 - Frustración Mínima:
4 – maximice el uso de patrones y hábitos:
5 - Máxima tolerancia para diferencias humanas:
6 - Máxima tolerancia a los cambios ambientales:
7 - Notificación inmediata de los problemas:
8 – Máximo control de tareas por parte del usuario:
9 – Máximo suporte para tareas:
Nociones de Windows.Forms
Crear Form
Diagramación
Controles
Eventos
Ok / Cancel / Help
Poniendo todo junto: Comando CRIARPERFIS
PropertyGrid
TreeView
DataGridView
Manipular Form
Interactua con la línea de comando
Windows
Excel
Aplicación
Libro de trabajo, hoja de cálculo
Células
Civil 3D
Documento actual
Prospector
Cogo Points
Point Groups
Surfaces
Alignments
Sites
Pipenetworks
Corridors
Settings
Drawing Settings
CUIX
Toolbars
Menus
Ribbon
Html Help WorkShop
AutoLOAD
Compilación en otras versiones
Autodesk Exchange Apps / TBN2NET
Programas de ejemplos
Dudas
Cierre
Introducción
Figura 1 - NCC-1701-A
“El espacio, la frontera final.
Estos son los viajes de la nave espacial Enterprise,
en su misión de cinco años para la exploración
de nuevos mundos, para buscar nuevas vidas,
nuevas civilizaciones, valientemente yendo a donde
¡ningún hombre ha estado nunca!”
Claro, mentalmente, ¡también escuchaste la canción de apertura!!!
Ahora reflexiona:
Programación, automatización,
Estas son los viajes de un ingeniero,
En su misión de 20 años (en mi caso)
de ingeniaría, para buscar nuevas soluciones,
formas más eficientes de trabajar, valientemente yendo a donde
ningún ingeniero ha estado nunca.
Comienzo con esta cita da la serie Star Trek y la razón es simple, soy ingeniero civil,
programo porque me gusta y todo lo que sé me aventure al oráculo (Google). No tengo la
pretensión de ser un maestro en esta cuestión, entonces no tomé ningún curso enfocado
en esto; sin embargo, la ingeniaría tiene sentido común y hacer lo mismo durante horas o
incluso días.
Mi motivación para aprender a programar ocurrió en 1994, cuando estudiaba
electromecánica en CEFET. Recuerdo que un profesor tenía una de estas calculadoras,
HP48, modelo SX en ese momento.
Figura 2-Droid48, Emulador de la HP48 para Android
Para aquellos que no saben, el HP48, se lanzó 1993. Justo en el año que yo, a la edad de
14 años me uní a CEFET.
El profesor en cuestión había publicado un libro sobre matemáticas y quería difundirlo
entre sus alumnos. Yo fui uno de ellos. Con este fin, lanzó 5 desafíos matemáticos y el
premio para aquellos que lograron resolverlos fue esta calculadora. Nota: ¡era lo último
en tecnología!
El problema que decidí resolver fue algo como esto:
“Tengo una inversión bancaria, donde a intervalos predeterminantes hago un depósito de
una cantidad constante y a intervalos más grandes y constantes retiro una tasa constante.
Esta inversión tiene un rendimiento constante y compuesto. Cree una expresión
matemática que proporcione la cantidad disponible en cualquier momento.
Mira, este es un interés compuesto, de hecho, bastante simple. El fator que complica es
la tasa de retiro.
Bueno, gasté unas 20hojas de mi cuaderno para deducir la fórmula de interés compuesto.
Recuerda que tenía 14 años, no tenía idea de qué era eso. Otras 10 hojas y logre poner en
la fórmula la parte de “tarifa de retiro”
Pero había un problema. Mi fórmula solo funciono para divisiones enteras entre el
intervalo de retiro y el intervalo de ingresos. Por lo demás, está bien.
Unos cuantos viajes a la oficina del profesor, y él verificaba mis resultados en su
HP48SX y decía: estás en el camino correcto, pero queda por resolver que la división es
un numero entero y redondeado hacia abajo. Luego dio el consejo: busca mi libro en la
biblioteca. Hay una función matemática que hace lo que necesitas.
Entonces fui a la biblioteca. Tomé prestado el libro, que por cierto era enorme dos días
después encontré la llamada función de número entero más grande menor que el número
real dado.
¡Era lo que necesitaba! reescribí la fórmula y corrí a la sala de profesores con mi
solución, hasta” ¡pasé a limpio!” pero ya era demasiado tarde... otro estudiante de otra
unidad de CEFET había entregado la solución por la mañana.
¡Me enoje de verdad! Pero el profesor me advirtió: ¡hay CINCO desafíos! Este otro
estudiante solo tuvo la suerte y entregar la solución antes. Luego mire este otro problema
(señalándolo en el folleto). Es idéntico.
Realmente fue, la declaración fue:
“Tengo un tanque de agua que recibe un flujo constante. De vez en cuando, abro el
registro y dejo que el flujo fluya constantemente. Proporcione una expresión matemática
que devuelva el volumen de agua dentro de la cajá en cualquier momento.”
Tenga en cuenta, simple interés. Nada más
Corrí a un banco en el hall de entrada y reescribí mi expresión de interés compuesto para
una versión de interés simple, adaptando el nombre de las variables. MEDIA HOJA DE
CUADERNO y tuve la fórmula y su demostración... usando la bendita función de
Máximo Entero ...
Esta vez fui más rápido, rasgué esa mitad de la hoja, con el dorso aún garabateado de las
deducciones del otro problema, ¡y corrí hacia el profesor ¡Él sonrió y dijo: ¡Sí! ¡es eso
mismo! ¡ganaste una calculadora! ¡Felicidades!
Una lástima que no tenía una cámara en ese momento....
Al día siguiente, falté a la clase, mi padre me llevó hasta NUESTRA PARÍS (el
Paraguay) para comprar la bendita. Una HP48G, modelo más actual que la 48S. el
manual de ella:
Figura 3 - Manual de la HP48G
Mi manual estaba en español. Leí y releí tantas veces que no había más hojas limpias.
Le pedí al profesor que me diera el programa en el que él verificó mis soluciones. Esto
fue incomprensible. Pero eventualmente tuve la epifanía...
Mi primer programa, escrito por mí, hacía media aritmética.
¿Dijiste que el manual estaba en español? Solo descubrí lo que era la “estructura de
bucle” años después, jejejejejejeje.
Después de eso, había un gestor para hacer trampas (¿lo qué?, ¿nunca has hecho una
prueba en español con calculadora? ¡Lo hice!), agenda (no existían celulares), un juego
de PIFE...
En 1996, finalmente ingresé a UFPR y fui el únicoen la sala que sabía cómo programar
un HP48, a pesar de que este era un elemento que figuraba en la lista de materiales, justo
después de una baraja de cartas
En este momento, ya había juegos geniales para HP48. Y había un sitio web,
https://www.hpcalc.org/, que traía muchos programas para la HP, no solo la 48, sino
varios modelos. Pero había un problema. ¿Como descárgalos en la calculadora?
En esta época, no había cable de conexión en Brasil y la importación estaba fuera de
discusión, costaba más que la calculadora. Luego vinieron los cables hecho a mano
http://www.area48.com/makeacableport.html). Yo mismo hice el mío. ¡Un conector de
mouse en serie, un pequeño terminal de cable que sacaba de los teclados rotos y eso fue
todo, tenía un cable!
Un día finalmente encontré el “Joe Horn’s Goodies Disk”
(https://www.hpcalc.org/hp48/compilations/horn/) en este sitio. Ellos eran mencionados
en los manuales de la calculadora, pero en 94/95 internet era algo para los ricos...
https://www.hpcalc.org/
http://www.area48.com/makeacableport.html
https://www.hpcalc.org/hp48/compilations/horn/
Encontré un manual de programación avanzado, que enseñaba como crear la
“Biblioteca”, cómo hacer esos programas que no pudiéramos ver el código (External
External External” si tuviera un HP, lo entenderá)
3 horas dentro del laboratorio de computación de la UFPR
y había impreso el manual en una impresora matricial.... Me dieron una bronca ese día...
¿Impresión de 120 páginas? ¿estás
loco? ¡Ni tesis de disertación tiene todo eso! Recuerda: el año era 1996.
Bueno, HP48G. 32KB de memoria disponible. O usted programaba de forma eficiente o
no cabría en la memoria....
Un día finalmente creé un email (neyton@yahoo.com) en 1996. Pronto me sorprendió
recibir un mail de los EUA. De repente, estaba tomando una clase de dibujo técnico en
UFPR y me presentaron AutoCAD.
Ah, el AutoCAD...
Dibujé con coordenadas absolutas hasta 1998, cuando obtuve una pasantía en Caixa
económica. Nuestro profesor había hecho que los ejercicios y las clases de AutoCAD
estuvieran disponible en Internet y allí estaba yo dentro de Caixa Económica, con
internet por DISCADO a las dos de la tarde aprendiendo a dibujar en el R14. Algunas
broncas más del jefe, por gastar la cuota de internet y finalmente aprendí a usar la “@”
(coordenadas relativas)
En 1999, un compañero de clase me enseñó ORTO, ¡es cierto ORTO!
En el año 2000 estaba haciendo unas prácticas en una empresa en Curitiba que estaba
haciendo proyectos de parcelación y vuelta y media aparecían matrículas de inmuebles
para que se hicieran estudios para parcelación “En el año de la gracia de nuestro Señor
Jesucristo...” era así como algunas comenzaban... Y venía entonces aquellas colecciones
de rumbos y distancias, a veces con docenas de lados... Ya tenía algunas habilidades con
M$ Excel, por lo tanto, crear una expresión
que calcule las coordenadas para luego hacer un SCRIPT (archivo SRC, para ejecutar en
AutoCAD) era pan comido....
Pero ahí tenía que colocar POINT, TEXT en los vértices, cotizar con AZIMUT (o
RUMBO) a poligonal.... 10, 12 lados hasta se puede hacer “a mano”. Pero un día me
aparece un poligonal ya dibujada con 243 lados. Trabajo para todo el día, cotizar,
numerar, crear tabla....
De alguna manera me presentaron a Auto LISP. No me recuerdo cómo ni quién, pero sé
que después de mucho romperme la cabeza. Logré crear algunos códigos para numerar,
poner punto y citar los poligonales (están en mi blog:
https://tbn2.blogspot.com/2012/04/visual-lisp-tabela-de-distancias-e.html 
https://tbn2net.com/plh para crear la tabla de coordenadas, algunas en la página de mi
programa: https://tbn2net.com/pln , para numerar, https://tbn2net.com/ppt, para colocar
el punto, https://tbn2net.com/autocota, para cotizar con azimut y distancia)…
mailto:neyton@yahoo.com
https://tbn2.blogspot.com/2012/04/visual-lisp-tabela-de-distancias-e.html
https://tbn2net.com/plh
https://tbn2net.com/pln
https://tbn2net.com/ppt
https://tbn2net.com/autocota
Y así comencé a programar para AutoCAD.
La programación para el HP48 me hizo comprender las estructuras de programación
(if/then/else, while, for...) me enseñó a ser “racional” n el código, es decir, a ser
eficiente, porque la memoria era baja y la capacidad de procesamiento también 4MHz...
Aprender Auto LISP fue un desafío, primero porque la notación esta prefijada:
Figura 4 – Programación en AutoLISP, notación prefijada
En notación prefijada, la función viene ANTES de los argumentos. Y en el caso de
AutoLISP, debe poner los paréntesis infames:
Figura 5 - Hola Mundo en AutoLISP
Notación posfija de la HP48:
Figura 6 - HP48: Notación posfijada
En notación posfija, los argumentos (1 y 2 en este ejemplo van antes de la función (+)
El ejemplo de hola mundo:
Figura 7- Hola Mundo en HP48
Tenga en cuenta que ahora la función MSGBOX viene después del argumento, “Hello
World”
Si hacemos una fórmula M$ Excel:
Figura 8 - Excel, notación fija
En la notación fija, colocamos la función (+) entre los argumentos.
¿Dije que era complicado aprender a programar en AutoLISP (Visual Lisp se lo
prefiere)?
Si. Pero no porque fuera difícil, sino porque la ayuda de AutoCAD me pareció un poco
confusa y muchos “trucos” solo se pueden aprender cometiendo errores.
Entonces, un día, encontré el foro de AutoLISP en internet
(https://www.AutoLISP.com.br/).
El primer post en este foro es mío:
Figura 9 - Foro AutoLISP
No preguntes... no sé por qué lo estaba buscando en día de Navidad, en fin…
AutoLISP me ha dado otro concepto importante: ¿por qué programas?
La programación para HP 48 fue un pasatiempo, lo hice por diversión. Pero programar
en Visual Lisp era una necesidad. En cualquier momento había algún tipo de servicio en
la prisión y mi sustento salió de eso.
Al principio eran poligonales, pero pronto tuve que hacer otras cosas, como memoriales
descriptivos y una de las subdivisiones tenía cientos de lotes. Luego vino el programa
memoriales (https://tbn2net.com/menoriais). Soy ingeniero y pronto tuve la tarea de
hacer proyectos complementarios, drenaje y alcantarillado, por ejemplo. La primera
versión de C3DRENESG (https://tbn2net.com/C3DRENESG4) fue escrita en Visual
Lisp, créeme:
https://www.autolisp.com.br/
https://tbn2net.com/memoriais
https://tbn2net.com/C3DRENESG4
Figura 10 - Programa de Drenaje escrito y Visual Lisp
Y fui caprichoso, tenía hasta perfil:
Figura 11 - Preview del perfil
Cualquiera que programa en Visual Lisp sabe que dibujar en un DCL no es para todos,
es muy “oscuro” por decir lo menos.
Entonces comencé a aventurarme en DOTNET. Era muy malo para escribir DCL porque
no es nada visual. LISP es bueno para muchas cosas, pero después de este programa,
necesitaba algo más…
En ese momento, quería entender como funcionaban las diapositivas de AutoCAD y me
ayudó incluso a explicar el formato del archivo. eso fue mucho poco. Realmente quería
entender cómo usar Windows Forms y eventualmente alió:
Figura 12 - Primer programa de Windows Form que hice
Era un visor de diapositivas de AutoCAD. Puede leer y mostrar la vista previa de este
tipo de archivo, así como las bibliotecas de diapositivas (archivo de extensión SLB):
Figura 13 - SlideViewer, biblioteca de visualización de slides
En el ejemplo anterior, utilicé el complemento plugin SlideViewer para abrir una
biblioteca con las letras escritas verticalmente. Estas letras se usaron para crear los textos
dentro de la vista de perfil del plugin de drenaje, versión Lisp.
A partir de entonces, empecé a tomar gusto.
Empecé un blog (https://tbn2.blogspot.com/, ¡clic, clic, clic!).
Un buen día, descargué Civil 3D 2007. ¡Ah, Civil 3D!
Entre 2008 y 2010 escribí docenas de tutoriales sobre Civil 3D y empecé a dar
consultorías sobre él por todo Brasil...
Porté el programa de drenaje en Visual Lisp a DOTNET:
Figura 14 - C3DRENESG Versión 1
¡Ahí nació C3DRENESG versión 1, totalmente escrito en VB.NET, con M$ Visual
Studio 2008 el programa que vamos a abordar en este curso!
El 2010 fue un muy buen año para mí. Comencé aser reconocido en internet debido a
esos tutoriales de Civil 3d (https://tbn2net.com/TUTORIAIS) y ese pequeño programa
que a todos les gusta, EXPGE (https://tbn2.blogspot.com/2008/04/expge-exportar-para-
o-google-earth.html, versión actual: https://tbn2net.com/EXPGE):
https://tbn2.blogspot.com/
https://tbn2net.com/TUTORIAIS
https://tbn2.blogspot.com/2008/04/expge-exportar-para-o-google-earth.html
https://tbn2net.com/EXPGE
Figura 15 - EXPGE versión 2.50 en Visual Lisp
Aunque este programa existe desde 2008, fue solo en 2010 que ele comenzó a dar sus
frutos. Hasta entonces vendió algunas licencias al mes.
Hoy hace parte de TBN2CAD (https://tbn2net.com/TBN2CAD), junto con otros plugins:
Figura 16 - TBN2CAD, lista de plugins
Aún en 2010, fui contratado para dar una consultoría del Civil 3D en Campinas-SP,
donde me pidieron que hiciera un programa que tomara notas de servicio de Civil 3D y
fuera personalizable, ya que los reports de Civil 3D eran muy insuficientes. Entonces
https://tbn2net.com/TBN2CAD
nació NOTASERV (https://tbn2net.com/NOTASERV2):
Figura 17 – Notaserv, versión 1
Este programa resolvió la mayoría de los problemas con las notas de servicios de Civil
3D y se vendió muy bien, gracias, jejejeje.
Antes de que este programa me enseñara a leer API do Civil 3D, que, por cierto, se usa
ampliamente en ella, me permitió aprender más sobre Windows Forms. Gracias a
Notaserv aprendí a crear controles de usuario Controles de Usuario, para poder hacer
este TreeGridView (que es la unión de un TreeView con un DataGridView) para poder
tener, además del árbol de nodos, las columnas para llenar otra información.
Gradualmente, se agregaron otros comandos a Notaserv. Algunos fueron para o
AutoCAD puro (raíz mismo) y otros para Civil 3D.
Luego surgió la necesidad de separar los programas que se ejecutan en Civil 3D en un
paquete y los que se ejecutan en AutoCAD en otro paquete. Así surgió el TBN2C3D
(https://tbn2net.com/TBN2C3D):
https://tbn2net.com/NOTASERV2
https://tbn2net.com/TBN2C3D
Figura 18 - TBN2C3D, plugins para Civil 3D
Por supuesto, no todos aparecieron al mismo tiempo. Algunos se agregaron hace unos
meses
Siempre he recibido sugerencias de mis clientes sobre nuevos comandos para incluir en
estos paquetes.
Eventualmente, fui llamado para una Consultoría sobre Civil 3D en São Luis - MA, en
una empresa que participo en los proyectos de duplicación de la Estrada de ferro Carajás
(EFC) y el Terminal de Grãos do Maranhão (TEGRAM).
Cualquiera que haya tenido el placer de hacer un proyecto de movimiento de tierras en
Civil 3D para un proyecto ferroviario, sabe que el diagrama de Brückner no es tan
simple, especialmente cuando tiene varios tipos de materiales de corte y necesita
clasificarlos para diferentes tipos de relleno sanitarios que tendrán a lo largo del
proyecto:
Figura 19 - Material List de Civil 3D
En el ejemplo anterior, el Material List para un proyecto de movimiento de tierras
ferroviario. Vea, no es solo cortar y llenar y prestar / tirar (Borrow Pit y Dump Site).
Hacer esta distribución con el diagrama (Mass Haul) del Civil 3D estaba fuera de
discusión, no hay forma de combinar las características de los materiales y hacer la
distribución.
¡Necesitabas hacer un programa para eso, no!
Y lo hice, se llama DDM (https://tbn2net.com/DDM):
Figura 20 - Programa DDM, para distribución de movimiento de tierras
Este programa lee las áreas de las escotillas de corte y relleno de la Section Views del
Civil 3D, clasifica los materiales de origen por sus características (CBR, expansión y
permeabilidad) y los destina a los diferentes tipos de vertederos (cuerpo, capa final,
relleno) según sus características mínimas.
Este programa me “obligó” a revisar los conceptos que había aprendido en Ingeniería
Económica, cuando se aprende un básico de investigación operacional
(https://pt.wikipedia.org/wiki/Investiga%C3%A7%C3%A3o_operacional).
Para resolver la distribución de los volúmenes de movimiento de tierras, utilicé el
algoritmo Sleeping Stone, o Método de Transportes
(https://tbn2net.com/help/DDM/steppingstone.html), cuyo objetivo es minimizar el
momento del transporte.
Bueno, además de ejercitar mucho los conceptos matemáticos, este programa me obligó
a revisar mucho los conceptos de Orientación a objetos.
(https://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objetos).
Internamente necesita modelar un documento, con las funciones abrir, guardar, deshacer
y rehacer, por ejemplo. Necesita crear formas eficientes de manejar grandes cantidades
de información y estas deben estar vinculadas, porque si cambio el área de corte de una
estaca en particular, esto tiene que desencadenar una serie de eventos que me adviertan
que la distribución necesita ser rehecho.
No solo eso, necesito acceder a API del Civil 3D para obtener las áreas, acceder a
https://tbn2net.com/DDM
https://pt.wikipedia.org/wiki/Investiga%C3%A7%C3%A3o_operacional
https://tbn2net.com/help/DDM/steppingstone.html
https://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objetos
Windows para guardar el archivo y cosas simples como copiar y pegar deben
programarse dentro del código.
Extrañamente este programa casi no vende… ¿Sería él, demasiado complejo? ¿la ayuda
es confusa?
Otro concepto tuvo que ser muy bien ejercitado aquí, el arte de escribir una ayuda. Haga
así, visite la tienda de aplicaciones de Autodesk (https://apps.autodesk.com/). Haga clic
en un programa y lea su descripción. Descárguelo. Intente instalar, usar, leer ayuda, si
hay.
¡hay ayuda? Bueno, diría que la mayoría tiene al menos una descripción mejorada,
porque sin ella ni siquiera puedes publicar allí. Pero ayuda de verdad, ¿tiene? ¿tienes un
escenario de uso, un ejemplo? Si. Trabajo duro para que estos programas que desarrollo
tenga una ayuda decente incluso si el usuario (ahhhh, el usuario) no mira.
En 2014, ante la inasistencia de algunos clientes, decidí crear C3DMENO
(https://tbn2.blogspot.com/2014/10/c3dmeno-programa-para-criar-menoriais.html) para
generar memoriales descriptivos.
Figura 21 - C3DMENO, para la generación de memoriales descriptivos
O C3DMENO está disponible en (https://tbn2net.com/C3DMENO).
Inicialmente, este programa se ejecutó solo en Civil #D y pronto comenzaron las
solicitudes para que funcione también con la raíz de AutoCAD (AutoCAD puro, Vanilla,
aff).
Y un día recibí un pedido de un revendedor de Gstarsoft, desarrollador de GstarCAD.
Para aquellos que no saben, GstarCAD es otro sabor de Intellicad, así como ZWCAD,
BricsCAD, Cadian y otros.
Otra vez, no es solo el programa. No es solo publicidad. Para hacer este programa, tuve
https://apps.autodesk.com/
https://tbn2.blogspot.com/2014/10/c3dmemo-programa-para-criar-memoriais.html
https://tbn2net.com/C3DMEMO
que aprender a portar el código fuente a otros tipos de CAD. Luego, tuve que
implementar algunas de las funciones que no admiten. Finalmente, tuve que tratar con el
usuario.
Ah el usuario, esto no se entiende.
¿Por qué simplemente hacer clic en el mismo vértice una vez, si puede hacer clic dos
veces, o incluso tres veces? ¿Por qué dibujar siempre en sentido horario los lotes, si se
puede dejar que “AutoCaRd” lo haga solo? Ah, pero la prefectura de ese lugar se
describe desde el interior del lote, desde ese lugar, desde el exterior ....
Bueno, tuve que crear tantos “ajustes técnicos” dentro de ese programa para corregir
posibles “errores de lanzamiento” que la unidad de prueba tuvo que ser hecha fuera del
AutoCAD. Es por eso por lo que tiene un ¨preview” de la subdivisión.
El preview fue otro desafío. Necesitaba ser hermoso. “se puede hacer clic”, personalizar,
hacer zoom, y aun así ser lo suficientemente rápido para renderizar el proyecto.
Inicialmente hice una clase (ya veremos más adelante) que dibujaba un BITMAP. Tan
simple como eso, era solo una imagen.
Pero siempre está el usuario. Tan mal entendido jejejejeje. Aparece un proyecto con más
de 600 lotes. No es que BITMAP fuera lento, por el contrario, fue incluso rápido, pero
ZOOM era casi imposible y como la subdivisión segeorreferenciaba, las coordenadas
UTM tienen números grandes y eso terminó distorsionando las cosas. De todos modos,
reescribí esta clase para dibujar SVG (https://pt.wikipedia.org/wiki/SVG).
Con eso, ejercité mis nociones de Orientación de Objetos aún más, ya que creé clases
para dibujar líneas, textos, círculos, polilíneas…en SVG. Y para las polilíneas aún
ejercía mucho los conceptos de geometría, porque tenía que implantar cosas como
“IntersectWith”, “GetFirstDerivate” o “GetClosestPointTo” que están disponible en
AutoCAD.
https://pt.wikipedia.org/wiki/SVG
Figura 22 - Clases para dibujar SVG
Sé que he ido demasiado lejos aquí.
El propósito de esto es justificar por qué aprender a programar. Está aprendiendo que,
por mucho que sepa lo que hace el programa, el usuario no podrá usarlo si no tiene el
tiempo para brindar ayuda, una interface hermosa y agradable.
No tiene sentido que su programa haga lo que tiene que hacer. Si espera que alguien más
lo use, ponerse en su lugar es esencial.
Estructuras de programación
Bueno, ¡entonces comencemos el curso!
¿te he convencido para que aprendas más sobre programación?
¿Sí? ¿No? ¡Envíame un email (neyton@yahoo.com)¡, ¡Deja un comentario en mi página!
Primero, ¿Que es un programa? De Wikipedia:
(https://pt.wikipedia.org/wiki/Programa_de_computador)
Un programa de computadora o programa de computadora es un conjunto de
instrucciones que escriben una tarea que debe realizar una computadora. El término
puede ser una referencial al código fuente, escrito en algún lenguaje de programación, o
al archivo que contiene la forma ejecutable de este código fuente.
Es eso.
No quiero enseñar una licenciatura aquí. El objetivo es llevar este mundo a los
ingenieros, que en este caso usan AutoCAD y Civil 3D.
Diría que lo más importante para nosotros es no saber cómo escribir un C#, VB, Lisp,
C++... lo más importante es saber cómo crear una receta de pastel.
Si sabe cómo crear una receta de pastel, no importa en qué idioma estará su libro de
cocina. Inglés, portugués, realmente no importa.
Pero hay una pregunta. ¿Para AutoCAD, puedo / debo programar en qué idioma?
Depende. Primera respuesta:
1. ¿Qué quieres hacer?
2. ¿Puedes escribir una “receta de pastel” para esto?
3. Ahora, ¿puedes “traducir” esto a la computadora?
Correcto. Veamos un ejemplo muy común para quienes trabajan con Civil 3D. debe
hacer un MDT (modelo digital del terreno) utilizando los Cogo Points y las líneas
obligatorias. Su pasante (que se las arregla para ser más incomprendido que el usuario)
conectó los puntos con 3D Polilínea para que pueda hacer el MDT. Pero él falló en
algunos lugares polilínea obtuvo la Z incorrecta en algunos lugares:
mailto:neyton@yahoo.com
https://pt.wikipedia.org/wiki/Programa_de_computador
Figura 23 – Líneas obligatorias con un problema
Antes de agregar estas líneas obligatorias a su superficie, debe corregir estos puntos
colocando el valor de Z correcto, en función de los Cogo Points en el dibujo.
Mira la receta de este pastel:
1) Seleccione las polilíneas
2) Mira cada uno de sus vértices y
3) Si te equivocas, encuentra un punto y
4) Si encuentra el punto, corrija vértice
¿Simple, no es así? Vea la solución en Visual Lisp aquí:
https://tbn2.blogspot.com/2019/02/civil-3d-breaklines-standard-e-z-igual.html
Ahora vamos a complicarlo un poco más. Muchas veces ya henos recibido el
levantamiento topográfico con las líneas ya dibujadas. Eje de calle, por ejemplo. El eje
está allí, pero no podemos usarlo como una línea obligatoria, porque no hay Z, o incluso
sí, pero no pasa por los puntos elevados en el eje u tenemos una situación como esta:
Figura 24 – Eje sin puntos conectados
https://tbn2.blogspot.com/2019/02/civil-3d-breaklines-standard-e-z-igual.html
Para que podamos usarlo, queremos que los puntos estén conectados, así:
Figura 25 – polilíneas con puntos conectados
Practiquemos la creación de la receta del pastel.
1. Solicite la selección Cogo Points
2. Solicite selección de polilínea
3. Solicite una distancia de referencia para comprobar si el punto es válido
4. En cada punto, haga:
1. Obtenga la coordenada Cogo Points
2. Si la distancia desde el punto de la polilínea es mayor que la distancia
solicitada, salte al siguiente punto
3. Calcule la posición relativa del punto en la polilínea
4. Almacene esta posición y la coordenada de los Cogo Points
5. Ordene los puntos de la lista que se obtuvo en el looping anterior
6. Redefina los vértices de la polilínea, utilizando estos puntos.
¿Sencillo?
¿Te das cuenta de que saber cómo escribir esto en español ya es programación?
Vea la solución AutoLISP aquí: https://tbn2.blogspot.com/2015/04/civil-3d-ligar-cogo-
points.html
Date cuenta de que tienes un problema: mejora una polilínea, en base a los Cogo Points
cercanos.
Primero, dividimos este problema en partes más pequeñas:
1) Crear un “comando” para llamar
2) Solicite la selección de puntos
3) Solicite la selección de polilínea…
Ahora, pegue cada uno de estos subproblemas y divídalos en problemas aún más
pequeños
“Crear un comando para llamar”:
https://tbn2.blogspot.com/2015/04/civil-3d-ligar-cogo-points.html
Figura 26, Jean Luc, activar!!!
En Visual Lisp:
Figura 27 - Comando de usuario en lisp
En VB.NET:
Figura 28 - Comando del usuario en VB.NET
En C#:
Figura 29 - Comando del usuario en C#
Colorido ¿verdad? Sí, VLIDE (editor de Visual Lisp integrado en AutoCAD) y Visual
Studio son editores geniales. La coloración del código ayuda mucho en la lectura y
facilita la comprensión
Ahora mire bien los tres ejemplos.
En azul, funciones nativas
En verde (C# e VB) y gris (AutoLISP) son comentarios
En negro, símbolos o nombres de variables o funciones creadas por el usuario
Resuelto el primer problema, pasemos as siguiente:
¿Cómo se selecciona una polilínea?
Entonces, ¿cómo seleccionas múltiples Cogo Points?
¿Cómo se obtiene la coordenada del enésimo vértice de una polilínea?
Ver viernes, en
Figura 30, ver viernes, en el mundo periodista!!!
Ok, nos reímos un poco. Dijiste que el curso sería en C# e VB, no en Visual Lisp. Sí
dijo. Estos son los primeros DOS ejercicios que harás en C# o VB. Antes de comenzar,
necesitamos actualizar algunos conceptos para poder escribir estos programas.
Instrucción Sub
El primer elemento que veremos es precisamente lo que inicia los comandos que vamos
a crear. En VB s la Instrucción Sub. De Microsoft:
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/statenents/sub-
statenent
Sí, hay muchas cosas juntas. Para nosotros, ingenieros sin un curso de informática,
tomaremos la parte que hace que un SUB sea un comando. Para hacer un comando para
AutoCAD, declaramos mínimo:
Figura 31 - Declaración mínima de un comando
Explicando:
Debe estar dentro de un módulo (palabra Module n la imagen) o clase
(veremos más adelante)
El módulo debe ser declarado público (palabra Public en la imagen)
El módulo debe tener un nombre (palabra Civil3D, en el ejemplo)
El comando debe ser un Sub
El comando debe tener el atributo CommandMethod (le dice a AutoCAD
qué es ejecutar esta “macro” cuando se llama al comando ATIVAR)
No voy a decir que SUB es como “VOID” en C#, pero por ahora piense así. SUB y
VOID no devuelven valor. Entonces en C#, haríamos así:
Figura 32 - Declaración mínima de un comando en C#
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/statements/sub-statement
Solo para estas llaves “{“e”}” no me gusta C# de todos modos. De la misma manera
Debe estar dentro de una clase (palabra class)
La clase debe declararse pública (palabra public en la imagen)
La clase necesita un nombre (palabra Civil3D, en el ejemplo)
El comando debe ser declarado public void
El comando debe tener el CommandMethod (le dice a AutoCAD qué es
ejecutar esta “macro”, cuando se llama al comando ATIVAR)
Sí hay muchos otros argumentos que podemos y, a veces, debemos hacer. Por ejemplo,
es posible poner un parámetro en el atributo CommandMethod, que evita que el
comando se ejecutesi está en PaperSpace (muchos de los comandos de Civil 3D solo
funcionan en ModelSpace) o incluso si algo está preseleccionado, esta
selección se puede usar si el programa va a pedir esta selección.
Ah, antes de preguntar, el nombre del módulo puede ser cualquier cosa, no tiene que ser
Civil3D. por supuesto, hay algunas reglas: no puede comenzar con un número y no
puede tener un espacio y evitar caracteres especiales. Intenta hacer que la cosa sea
legible por humanos.
Averigüe sobre:
Instrucciones VB
Métodos C#
NameSpaces
Public, Private, Friend, Static
Recordando que el curso no entrará en estos detalles.
Instrucción Function
Una function devuelve un valor. Será útil crear subrutinas. Si alguna vez te vuelves loco
y quieres crear nuevas funciones para AutoLISP, usarás Function.
De ayuda M$:
(https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-
reference/statenents/function-statenent)
Sí, hay toneladas de cosas por ahí.
Aquí en el curso, acepto que entiendas esto
Figura 33 - Crear una function en VB
Sé que aún no sabemos cómo activar Visual Studio, así que solo echa un vistazo a la
función que acabo de definir. Suma
Ella espera dos argumentos y devuelve un valor numérico real.
¿Entiendes la diferencia para SUB?
¿Qué pasa si estaba en C#?
Figura 34 - Crear una Function en C#
Solo por diversión, ¿cómo lo haría la versión Visual Lisp de esta función?
Figura 35 - Crear una Función en Visual Lisp
Ahora NO venos algo en Visual Lisp que venos en VB y C#. El tipo. ¿Cómo sabemos
que los argumentos “a” y “b” son números reales? ¿y cómo sabemos que devuelve un
número real?
Respuesta. No lo sabemos
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/statements/function-statement
En programas pequeños, realmente no importa tanto. Pero en programas grandes, esto
puede traer muchas complicaciones.
Inadvertidamente puede escribir un valor no numérico en la variable “valorA” y al
agregar valorA con valorB, puede recibir un error o algo inesperado.
En C++ esto a menudo es fatal...
Primer consejo:
Establece el tipo de la variable.
Segundo concejo:
Usa nombres que puedas entender. “valorA” solo no dice mucho. Prefiere nombres más
“explicativos”, por ejemplo, si estamos hablando de un rectángulo, “valorA” puede
referirse al ancho y “valor” puede referirse al largo.
De esta manera, daría los nombres de las variables ancho y largo:
Figura 36- Dar nombres que se explican por sí mismo en VB
Figura 37 - Dé nombres autoexplicativos en C #
Figura 38 – Dé nombres autoexplicativos en Visual Lisp
Tercer concejo:
Poner comentarios en los códigos. Explica qué hace la función, cuáles son sus
parámetros y cuál es su salida. Créeme: mantendrás tu código y recordarás lo que hace
cada cosa no será una tarea fácil si le pones algunos comentarios
Si sigue estos consejos, le garantizo que más adelante estará agradecido por escribir un
código hermoso.
Una cosa muy importante: al pasar variables en una función, pueden pasar de dos
maneras:
1. ByVal (predeterminado si no está escrito de otra manera, es ByVal)
2. ByRef (pasa la variable hacia adelante, para ser modificada en el método
que la recibe)
ByVal
Especifica que un argumento se pasa por valor, de modo que el procedimiento llamado o
la propiedad no pueden cambiar el valor de una variable subyacente al argumento en el
código de llamada. Si no se especifica ningún modificador, ByVal es el valor
predeterminado.
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/modifiers/byval
ByRef
Especifica que un argumento se pasa de tal manera que el procedimiento llamado puede
cambiar el valor de una variable subyacente al argumento en el código de llamada
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/modifiers/byref
Figura 39 - Diferencias entre BYVAL y BYREF en VB
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/modifiers/byval
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/modifiers/byref
Figura 40 - Diferencias entre BYVAL y BYREF en C#
Figura 41 - Diferencias entre BYVAL y BYREF en AutoLISP
Ejercicios:
1. Abra los ejemplos en la clase 01 y vea como agregar comentarios en C# y
VB.
2. Explique SET y SETQ en el código en AutoLISP, BYREF y BYVAL en VB
y REF en C#
If
El IF evalúa una expresión y cambia el flujo a una ruta si la expresión resulta ser
verdadera, o a otra ruta si la expresión resulta hablar
Figura – 42 OR ELSE
Sé que esperabas esos UML (https://www.devmedia.com.br/o-que-e-uml-e-diagramas-
de-caso-de-uso-introducao-pratica-a-uml/23408) para la función IF y para los demás.
¡Tómalo!
Figura 43 – IF THEN ELSE
Realmente no tiene mucho que decir al respecto.
Entonces, haz un poco de ejercicio. En el ejemplo del área del rectángulo, coloque un IF
que evalúe si el área calculada es mayor que 1.5x la suma de los lados del mismo
https://www.devmedia.com.br/o-que-e-uml-e-diagramas-de-caso-de-uso-introducao-pratica-a-uml/23408
rectángulo y haga que el programa muestre diferentes mensajes para las dos situaciones.
For
El FOR es un looping. En general, predefine el número de veces que sucederá un
conjunto de acciones.
Ver, predeterminado no significa que se ejecutará exactamente ese número de veces, ya
que puede interrumpirse en el medio de la ejecución.
La ventaja del looping FOR es que normalmente ya tiene un índice autoincrementado,
pero es posible hacer iteraciones “Para Todos” (FOREACH).
Figura 44 - Looping FOR
En Visual Lisp:
Figura 45 - Factorial en Lisp
Mira, Lisp no tiene un FOR, pero sí tiene REPEAT que es esencialmente lo mismo.
Ejercicio: poner comentario en el código
Figura 46 - Factorial en VB
Ejercicio: explique qué es ULong. Sí, puedes mirar en el oráculo. (Google)
Figura 47 - Looping en C#
Ejercicio:
Explique i++
¿Y For each?
Mira, en VLISP, es así:
Figura 48 - Foreach en Visual Lisp
Ejercicio: explique los argumentos de FOREACH
En C# es así:
Figura 49 -Foreach en C#
Ejercicio:
Explicar los parámetros (var c in new [] {5, 66, 67, 68})
Finalmente, VB:
Figura 50 - For each en VB
Ejercicio:
Explica qué hace el carácter “&” hace en el código VB.
While
¿Y While? Es solo otro looping.
Figura 51 - Looping perder de vista
Correcto, UML...
Figura 52 - Looping While
El looping while evalúa primero una condición y luego, si la condición es verdadera,
realiza una acción. Hay una diferencia en relación con el looping DO:
DO
Figura 53 - Looping DO
El looping DO realiza la acción por primera vez y luego evalúa la condición de
detención.
Cuando no sabemos cuántas veces debes ocurrir un ciclo, es porque la acción en sí
misma influye en la evaluación de su condición de detención.
Ejemplo del uso de WHILE:
Lista = CreaUnaListaEnarticulos()
Mientras ListaContieneElementos()
TiraUltimoElementoListaHaceAlgunaCosaConEl()
FinMientras
En este ejemplo puede ser que la función CreaUnaListaEnArticulos() devuelva una
lista vacía. Por lo tanto, es recomendable poner ListaContieneElementos() antes de
TiraUltimoElementoListaHaceAlgunaCosaConEl()
Ejercicio: escriba esto en C#, VB o Lisp.
Piense que la lista contiene coordenadas y que dibujará POINTs en AutoCAD.
¿qué, todavía no sabes dibujar? No hay problema, hazlo un problema menor:
TiraUltimoElementoListaHaceAlgunaCosaConEl()
Coordenada = TomaUltimaCoordenada()
Lista = RenovaUltimoArticulo
DibujaUnPunto(Coordenada)
Fin
En VB o C#, suponiendo que la lista es una lista, para obtener el último elemento,
simplemente haga:
Coordenada = Lista.Last()
¿Te das cuenta de que el problema se ha vuelto tan pequeño que se reduce a UNA
PALABRA? (Last)
Es eso. El código amarillo en sí mismo es completamente comprensible, casi como una
lectura natural. Esta es la “receta del pastel”. Es natural que lo leas y lo entiendas.
Ejercicio:
Ahora traduzca eso para la computadora.
Case/Switch
Digamos que Case es una forma menos fea de hacer varios IF.
En ausencia de una imagen más interesante:
Figura 54 - Case Switch
Imagina la siguiente situación.Hiciste un buen comando di el MPEDIT:
Figura 55 - MPEDIT, utilizando el case switch
Se conoce la cantidad de opciones, pero no se limita a Verdadero o Falso. Luego debe
poder tomar las medidas apropiadas para la opción elegida.
Considere el siguiente código:
Figura 56 - Select Case
El código en un buen ejemplo de lo que quise decir con “romper en problemas menores”.
Cada pequeño “Sub” con ese Throw New NotImplenentedException() solo muestra un error por
ahora, porque todavía no sabemos cómo hacer lo que necesitamos.
Sin embargo, ya sabemos que son métodos que modifican una polilínea de alguna
manera. También henos implementado la estructura que elige qué hacer dada la opción.
Ver el mismo código en C#:
Figura 57 - Case Switch en C#
Figura 58 – “Cond” en Visual Lisp
Ejercicio: 
Incluya una comprobación con IF en caso de que la función ObterPolilinea() no
devuelva una polilínea. Vea que, si no hace esta verificación, cualquiera de las funciones
dentro del Switch fallará y puede pasar de un simple error, a un error fatal, de esos
“Object reference not set an instance of an object”
Figura 59 - Object reference not set an instance of an object
Este error es aburrido y, a veces, es muy difícil encontrar dónde ocurre.
Try
Figura 60 - Mestre Yoda
Afortunadamente, esto se aplica a la FUERZA.
En programación, podemos hacer un TRY.
¡Y ni siquiera duele nada!
Pero ¿por qué hacer un try?
Bueno, hay muchas situaciones en las que puede que tenga que hacer esto debido a la
incertidumbre de lo que está llegando al punto en el que lo colocamos.
Por ejemplo, creó ese Report increíble en Civil 3D, con una hermosa nota de servicio y
desea guardar el resultado en un archivo.
Inocentemente haces esa llamada inteligente en el “OpenSaveDialog” y hasta ahora todo
está bien, pero el usuario eligió guardar el archivo en una carpeta de solo lectura y no lo
probaste hasta que llegaste al punto de guardarlo.
¿Qué pasa? ¡ERROR! ¡No se puedes guardar, así de simple! Luego puede mostrar un
mensaje de error o tomar alguna otra acción.
Y si realizo una llamada en la línea de comando, por ejemplo, solicitando cualquier
número, y este mismo usuario ingresó el valor CERO.
¿Qué sucede si divides un número entre CERO?
Tiene un vector lleno de cosas y necesita obtener el elemento número 15, pero la lista
solo tiene 14 elementos. ¡Error!
Entonces, o agrega todas las pruebas que necesita para validar la entrada del usuario, o
agrega un poco de TRY para que al menos no se bloquee en AutoCAD.
Ah, y no es 100% seguro de que TRY lo resuelva todo. Vámonos.
Revise este código:
Figura 61 - sin TRY
¿Qué garantiza que el usuario realmente haya hecho clic en algo? Nada, por lo que la
primera posibilidad de error ya puede ocurrir en:
GetEntity("haga clic en la polilínea").ObjectId
Debido a que la función GetEntity puede proporcionar el ObjectId del objeto
seleccionado o un valor nulo.
Suponiendo que no hizo clic en nada, el programa intentará obtener un objeto que no
existe y puede dar un error aquí:
plId.GetObject(OpenMode.ForRead)
pero suponiendo que el usuario (¡ahh!) haya hecho clic en un círculo o un texto, dará un
error aquí.
Dim pl As Polyline = plId.GetObject(OpenMode.ForRead)
Porque un círculo no es una polilínea.
Santo Dios, ¡tres posibilidades de error en tres líneas de código y ni siquiera hice
demasiado ¡
Incluiremos el TRY:
Figura 62 - Try en VB
Bueno, ya henos logrado evitar algunos errores. Algunos inclusos fatales. Pero todavía
no es la situación ideal para lo siguiente.
El usuario no siempre comete errores por negligencia. A veces, la polilínea esta debajo
de una línea y el Draw Order puede interferir. Luego terminas haciendo clic en LINE en
lugar de POLYLINE. Podríamos agregar un filtro a la selección.
También puede hacer un clic deliberadamente en ESC e interrumpir al comando. En este
caso la función GetEntity tendría un Estatus de cancelación.
Si no agregamos el filtro, aún podríamos INTENTAR convertir la respuesta de
GetObject a Polyline. Esto se llama Cast.
Figura 63 - Try con mensaje de error
En esta solución tendrá que haber una M* con un a “m” mayúscula, en negrita y
parpadeante para que el código bloquee su AutoCAD, al menos en la función anterior. Y
vea, si ocurre un error imprevisto, mostrará un mensaje que dice cuál es el error. Para
todas las demás situaciones, se muestra un mensaje amigable y la función devuelve
“Nothing”.
Así que pedí que agregue una prueba IF si la polilínea existía. ¿lo hiciste? ¿no? ¡corre
que aún da tiempo!
Ejercicios:
1. Escribe TRY en C#. puedes ser la sintaxis básica por ahora.
2. ¿Hay cómo hacer TRY en Visual Lisp? (busque vl-catch-all-apply)
Requisitos
¡Vamos a empezar!
Primero asegúrese de tener los programas necesarios. Primero los links
Civil 3D - https://www.autodesk.com.br/products/civil-3d/overview
Sin duda, un excelente programa para proyectos de infraestructura. Actualmente está en
la versión 2020. Si no tiene una licencia, use la versión para estudiantes o incluso la
versión de TRIAL.
Visual Studio - https://visualstudio.microsoft.com/pt-br/
Programa que crea programas. Utilizaremos la versión Community, que es gratuita para
proyectos pequeños y medianos. La versión actual es 2019.
HTML Help Workshop - https://www.microsoft.com/en-us/download/details.aspx?
id=21138
Organiza y crea al archivo de Ayuda. Es gratis. Simplemente acceda al LINK y
descárguela. Solo tenga en cuenta que separa el archivo ejecutado de su ayuda, por lo
que debe descargar ambos por separado, comprenderá.
Tener en mente:
Los programas que vamos a crear para AutoCAD / Civil 3D en general deben tener
pantallas, ya sea para informar cosas o hacer preguntas. Así que ten en cuenta esta
palabra: Form.
Estos programas ejecutarán DENTRO de AutoCAD, por lo no son ejecutables sino
DLLs, que cargamos con el comando NETLOAD. DLL es una biblioteca de clases y
módulos, que contendrá los programas que usaremos DENTRO de AutoCAD.
¿Puedes hacer un ejecutable y descargarlo con NETLOAD? Si y no. Primero, no parece
y la lista NETLOAD. Pero puedes forzarlo. En segundo lugar, la API DOTNET de
AutoCAD esperará que se ejecute DENTRO de AutoCAD, por lo que, si realiza las
funciones de llamada ejecutables desde esta API, sin estar dentro de AutoCAD, dará un
error. A API COM puede crear un ejecutable y ejecutar AutoCAD EXTERIOR, pero no
funcionará si se combina con la API DOTNET.
https://www.autodesk.com.br/products/civil-3d/overview
https://visualstudio.microsoft.com/pt-br/
https://www.microsoft.com/en-us/download/details.aspx?id=21138
Civil 3D
Primero, necesitamos saber dónde buscar las cosas. Sí en el oráculo (¿qué, no dije quién
es el oráculo? Google, por supuesto.
AutoCAD API Reference
https://www.autodesk.com/developer-network/platform-technologies/autocad
http://docs.autodesk.com/ACD/2010/ENU/AutoCAD%20.NET%20Developer%27s%20Guide/index.html
Recomiendo ver el segundo link. Necesitas tener esta imagen en tu cabeza:
Figura 64 - AutoCAD Object Hierarchy
Esta imagen nos muestra cómo se relacionan las cosas dentro de AutoCAD. En él,
Application es el proprio AutoCAD.
Él maneja una serie de DWGs, ¿verdad? Es el DocumentManager, responsable de abrir,
guardar y crear otros DWGs (documentos o Document).
El Document es uno de los DWGs en la lista, si estamos hablando del documento actual,
en VBA sería como “ThisDrawing” (guarde este nombre)
Dentro del Document, hay una base de datos (base de datos en la figura), que contiene
tablas (Tables en la figura)
Las Tables pueden tener varios tipos:
BlockTable – Tabla de Bloques
LayerTable – Tabla de Layers
https://www.autodesk.com/developer-network/platform-technologies/autocad
http://docs.autodesk.com/ACD/2010/ENU/AutoCAD%20.NET%20Developer%27s%20Guide/index.html
DimStyleTable – Tabla de estilos de dimensión
El ModelSpace, por ejemplo, es solo un bloque. ¿qué es un bloque de todos modos? Es
una colección de objetos (líneas, textos, puntos, otros bloques…)
Civil 3D API Reference:
http://docs.autodesk.com/CIV3D/2012/ENU/API_Reference_Guide/http://docs.autodesk.com/CIV3D/2013/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2014/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2015/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2016/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2017/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2018/ENU/API_Reference_Guide/
http://help.autodesk.com/view/CIV3D/2018/ENU/
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/
http://help.autodesk.com/view/CIV3D/2019/ENU/
Tenga en cuenta que tiene hasta 2019. Sin embargo, esta lista cambia de vez en cuando,
como nuevas clases, funciones, métodos, etc. Se agregan, otros se modifican o incluso se
eliminan.
No me gusta particularmente usar la API COM (ActiveX, la que usa en VBA), porque
depende demasiado de la versión Civil 3D, además de requerir algunas líneas de código
más y obligarlo a mezclar la API COM y la API DOTNET.
Pero, por supuesto, a veces no hay forma, porque algunas cosas solo tienen una y otras
solo tiene la otra.
Ah, este curso utilizará exclusivamente la API DOTNET y API COM. No compilaremos
para ARX.
Incluso puede preguntar: ¿cómo elijo donde se escribirá mi programa? C#, VB,
AutoLISP, C++?
http://docs.autodesk.com/CIV3D/2012/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2013/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2014/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2015/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2016/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2017/ENU/API_Reference_Guide/
http://docs.autodesk.com/CIV3D/2018/ENU/API_Reference_Guide/
http://help.autodesk.com/view/CIV3D/2018/ENU/
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/
http://help.autodesk.com/view/CIV3D/2019/ENU/
Figura 65 -Ferrari para ir a la panadería
Visual Lisp es simple, resuelve mucho. Úselo cuando necesite automatizar pequeñas
acciones con aproximadamente 100 líneas de código, por ejemplo, o si su TI crea un
caso para instalar Visual Studio (tuve y pido bendición en Francia para instalar en la
última oficina en la que trabajé
Figura 66 - caso de creación de TI instalar o Visual Studio
¿VBA? ¿Puro así? Primero tendrá que instalar VBA en AutoCAD, que ya no viene en la
instalación de forma predeterminada y todavía tendrá que combinar algunas líneas de
Visual Lisp para poder crear los comandos, de lo contrario tendrá que estar ejecutando
macros. Puedes hacerlo con Visual Studio, es mejor y menos molesto, créeme, jejejeje
mucho “_”.
Figura 67 - VBA ya no está instalado en AutoCAD
VB o C#. Cuestión de gusto. Claro que cada lenguaje tiene sus particularidades, pero
para mí no cambia en nada entre uno y otro, por lo que prefiero VB, tiene menos “{“,
“}”, ”;”
C++? Una grande cantidad de “*”, “&”, “{“, “}”, “;”, no me gustó. Los programas que
he hecho hasta ahora se han resuelto muy bien con VB. Siempre le digo eso a cualquiera
que me pregunte: ARX es un Ferrari para ir a la panadería.
Visual Studio
El Visual Studio tiene varias versiones, para diferentes propósitos. En este curso
utilizaremos la versión comunitaria, que actualmente se encuentra en la versión 2019.
Figura 68 – Pantalla de inicio de Visual Studio
¿Puedes usar otras versiones? Sí, siempre que instale los paquetes de .NET Framework
para la versión de Civil 3D que va a utilizar.
Civil 3D / AutoCAD .NET Framework
2011 3.5
2012 3.5, 4.0 en la mayoría de las veces
2013 4.0
2014 4.0
2015 4.5
2016 4.5
2017 4.5.2
2018 4.6
2019 4.6, 4.7.2
2020 4.7.2
Figura 69 - Visiones do .NET Framework compatibles
Esta tabla no es exactamente rígida. También dependerá de si está compilando para
sistemas de 64 bits o 32 bits o ambos. Y si va a mantener las referencias DLL por más
tiempo.
La mayoría de los programas exclusivos de AutoCAD que se han compilado para
AutoCAD 2013 se ejecutan hasta 2020 sin cambios de códigos.
TBN2CAD (https://tbn2net.com/TBN2CAD) es un ejemplo.
En cuanto a los programas creados para Civil 3D, a veces necesitan hacer referencia a
versiones mínimas de la DLL y, como se compilan en versiones específicas de
Framework, debe seguir las mismas versiones. Ejemplo: TBN2C3D
(https://tbn2net.com/TBN2C3D).
En general, hay un gran cambio cada 3 versiones de AutoCAD.
Por ejemplo, para Civil 3D, solo era posible programar en la API COM hasta la versión
2010/2011. Luego, la API DOTNET comenzó a funcionar en la versión 2011, pero aún
un poco aburrida. en 2012 fue bueno. 2013 inventó que gran parte de la API debería
estar dentro de otra DLL, con los NameSpaces cambiados, una zona, en fin. 2014 como
que dejaron de f* y desde entonces casi no ha cambiado
En AutoCAD, se compila con referencias de AutoCAD 2007 “Any CPU” funcionará
bien hasta 2010compilado para 2010, se ejecutará solo hasta 2012. ¡compilado para
2013, se ejecutará hasta 2020, al menos!!!
Visual Studio incluso le advertirá sobre problemas de 32/64 bits, pero diría que la
mayoría de las veces puede ignorarlo.
Ahora, cambia la figura si tiene la intención de hacer ARX. Luego, primero ve a
aprender C++. Oh enserio. Luego, deberá instalar varias versiones de Visual studio,
desde OBJECT ARX.
(https://www.autodesk.com/developer-network/platform-technologies/autocad/objectarx)
Los programas realizados en C++ para AutoCAD / Civil 3D (compilación en la
extensión ARX, DBX) dependen de la versión del compilador en el que se escribió
originalmente la API. Para estos casos, consulte la ayuda del paquete de instalación de
OBJECT ARX que descargó. Este curso no hará programa ARX
Es difícil convencer a los clientes de que tiene que pagar por las actualizaciones de la
versión…
https://tbn2net.com/TBN2CAD
https://tbn2net.com/TBN2C3D
https://www.autodesk.com/developer-network/platform-technologies/autocad/objectarx
Figura 70 - Cliente insatisfecho con tener que PAGAR por las actualizaciones
Excel
Excel, en realidad todo el paquete office, tiene una API ACTIVEX y usted puede
escribir programas en él que acceden a AutoCAD, dibujan cosas etc.
Figura 71 - Excel trabajando en AutoCAD
Incluso publique un pequeño programa en mi blog en el que Excel maneja AutoCAD.
Ver aquí: https://tbn2.blogspot.com/2008/09/excel-escravizando-o-autocad.html
No hay ningún secreto, si ya ha creado un macro en Excel, le irá bien para trabajar con
AutoCAD. ¿haremos un ejercicio? Copie el código del enlace de arriba y péguelo en el
editor de Excel de Visual Basic:
https://tbn2.blogspot.com/2008/09/excel-escravizando-o-autocad.html
Figura 72 - VBA de Excel
El truco es agregar la referencia correcta de AutoCAD.
Figura 73 - referencia a AutoCAD Type Library
Nuestro objetivo aquí en este curso es lo contrario. AutoCAD accederá a Excel y hará
cosas con él (eso sonó mal, jejeje).
Veremos cómo hacer referencia a Excel en Visual Studio más adelante.
HTML Help WorkShop
Vamos a hacer un programa de verdad, ¿verdad? Esto supone que tendrá ayuda. Hay
varias formas de hacer esto: un PDF (¡muere PDF!), un documento WORD (no me gusta
la idea), archivos HTML.
Me gusta la idea de HTML, porque puedes insertar links, insertar un “poquito” de Java
script, estilos, links. No es que no puedas poner eso en Word, pero si piensas en hacer
que esta ayuda esté disponible en línea (ejemplo: https://tbn2net.com/help/TBN2NET/),
HTML es bueno.
Particularmente, prefiero que la ayuda se concentre en un solo archivo y que crear
docenas de HTML para que el usuario las busques no es legal. Más adelante, verá que
para “Linkar” un tema específico a un comando será aún más simple con el archivo
generado por este programa
La interfaz del programa es muy simple. Básicamente creará el esquema e incluso puede
poner una lista de palabras clave en el “Índex”.
Hay otras soluciones, sí, puedes elegir más tarde.
https://tbn2net.com/help/TBN2NET/
Referenciar DLLs
Ahora que sabemos qué programa vamos a utilizar, abramos Visual Studio y hagamos
referencia a / Civil 3D / Excel.
Primero, abra Visual Studio:
Figura 74 - Abra Visual Studio
Crea un proyecto haciendo clic:
Figura 75 - VS,crie un proyecto
Ahora, tomate un momento y piensa qué tipo de programa quieres hacer y en qué
lenguaje
¿Lo pensaste? DLL, ¿verdad?
Así es, elija DLL. Ah, observe qué versión de AutoCAD / Civil 3D tiene. Tendremos
que elegir la versión de .NET Framework más adelante.
Verifique las opciones en la pantalla:
Figura 76 - Criar DLL
C# o VB, Elige como prefieras. Enseñe la carpeta donde guardará y configure la versión
de .NET Framework de acuerdo con la versión en AutoCAD:
Figura 77 - .NET Framework y versión de AutoCAD
Vea la tabla completa en la tena anterior de Visual Studio si es necesario,
Ahora, agreguemos referencias.
Figura 78 - Adicionar referencias
Para trabajar solo con AutoCAD utilizando la API DOTNET, debe elegir las siguientes
DLLs:
accorengd.dll (solo AutoCAD 2013 en delante)
acdbmgd.dll
acmgd.dll
Estas DLLs están en la carpeta de instalación de AutoCAD:
C:\Program Files\Autodesk\AutoCAD 2020
En mi caso.
Vea que marqué accorengd.dll. Esta DLL aparece solo en la versión 2013 en delante y
contiene una serie de NameSpaces que estaban previamente en las otras dos DLLs. Hay
toda una historia detrás de esto. Buscar en Google.
Algunos programas pueden usar otras DLLs que terminan en “*mgd.dll” que están en la
carpeta de AutoCAD. Un ejemplo es AdWindows.dll, que le permite crear PalletSet
(esas pantallas que pueden caber, como Properties) entre otras cosas.
Para trabajar con Civil 3D, necesitará, además de los ya mencionados para AutoCAD,
los siguientes:
AecBasengd.dll
AeccDbMgd.dll
También están en la carpeta de instalación de AutoCAD.
Para trabajar con la API COM en AutoCAD, consulte:
Autodesk.AutoCAD.Interop.Common.dll
Autodesk.AutoCAD.Interop.dll
En AutoCAD 2020 está en la carpeta de instalación, pero recuerdo que estaban ocultos
en versiones como 2012. Nada que una búsqueda en Explorer no resuelva.
Para trabajar con la API COM no Civil 3D, consulte:
Autodesk.AEC.Interop.Base.dll
Autodesk.AECC.Interop.Land.dll
Autodesk.AECC.Interop.Pipe.dll
Autodesk.AEC.Interop.UIBase.dll
Autodesk.AECC.Interop.UiLand.dll
Autodesk.AECC.Interop.UiPipe.dll
Autodesk.AECC.Interop.Roadway.dll
Autodesk.AECC.Interop.UiRoadway.dll
Los nombres son muy sugerentes, ¿no? Bueno, en la versión 2020, estas DLL están en:
C:\Program Files\Autodesk\AutoCAD 2020\C3D
Particularmente prefiero evitar el uso API COM, porque está obligado a compilar para
cada versión de AutoCAD de forma independiente. Con la API DOTNET, puede
“omitir” algunas versiones
Y ¿Excel? El Excel lo encuentra aquí:
Figura 79 - Excel Type Library
Curiosamente, Excel no me aparece en esta lista. Puede ser que para usted aparezca. Si
está instalado y no aparece, haga clic en Procurar:
Figura 80 – EXCEL no GAC
Lo encontrará en el GAC (Global Assenby Cache). Luego, elija la versión más pequeña
si tiene más de una. Aquí encontré la versión 15.
¿Un descanso?
Figura 81 - Hora del almuerzo
Comprensión de la orientación a objetos
Ya sabemos cómo activar Visual Studio y sabemos qué archivos DLL usar para crear
nuestros programas. Tratemos de entender un poco de Orientación de objetos, esto lo
ayudará a leer la ayuda que se encuentra en esos links que pasé de la API de Civil 3D.
Da Wikipedia:
La Programación Orientada a Objetos (también conocida por sus siglas POO) es un
modelo de análisis, diseño y programación de software basado en la composición e
interacción entre varias unidades llamadas “objetos”.
Ver más en https://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objetos
Del texto completo de este enlace, la frase que más me llama la atención es “Empaque
los datos con sus operaciones naturales / intrínsecas”.”.
Particularmente me gusta esta idea porque sé lo que hace una clase. Pero no necesito
saber cómo lo hace.
También me gusta el hecho de que ella organiza las ideas como objetos. Y estos tienen
sus propriedades, funciones.
Programación Estructurada versus Programación Orientada a Objetos
A continuación, venos una comparación entre la programación estructurada y la
programación orientada a objetos con respecto a los datos. Tenga en cuenta que en la
programación estructurada tenemos procedimientos (o funciones) que se aplican
globalmente en nuestra aplicación. En el caso de la orientación a objetos, tenemos
métodos que se aplican a los datos de cada objeto.
https://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objetos
Figura 82 - Programación Estructurada versus Programación Orientada a Objetos
La programación estructurada, cuando se hace bien, funciona mejor que la programación
orientada a objetos. Sin embargo, la programación orientada a objetos trae otros puntos
que terminan siendo más interesantes en el contexto de las aplicaciones modernas. Dado
que el rendimiento de las aplicaciones no es una preocupación importante, la
programación orientada a objetos se ha generalizado. Esta difusión se debe en gran
medida al problema de la reutilización del código y la capacidad de representar el
sistema mucho más acerca de lo que veríamos en el mundo real.
Para comprender exactamente de qué se trata la orientación a objetos:
1) Abstracción
Vamos a tratar con una representación de un objeto real, así que tenemos que
imaginar qué va a hacer ese objeto. Hay tres puntos que deben tenerse en cuenta en
esta abstracción.
Este objeto debe tener:
a) Identidad: para ser único, es decir, su tipo solo se puede definir una vez
b) Características: son las propriedades
c) Acciones: son las funciones o métodos
Si creáramos el tipo “Auto” podría tener:
a) Identidad: automóvil
b) Características: color, potencia, puertas, modelo
c) Acciones: Estacionar(), autopiloto (), encender luces()
2) Encapsulación
Agrega seguridad a la aplicación orientada a objetos porque oculta propriedades o
acciones, creando una especie de recuadro negro. ¿Cómo conduce el auto solo?
Ver: Public, Private, Shared
3) Herencia
Esta característica optimiza la producción de la aplicación en tiempo y líneas de
código. Tiene un prototipo de automóvil y tiene el sistema Autopiloto (). Ahora crea
modelos derivados de él y comienzan a tener el mismo sistema, por haber heredado
esta característica.
4) Polimorfismo
Imagine que creó un nuevo modelo de automóvil, derivado de su prototipo original,
pero por alguna razón, necesita hacer adaptaciones en el sistema Autopiloto (). Para
todos los afectos, el automóvil tiene esta función, pero internamente es diferente del
original
Tipagen
Imagine este escenario: creó un programa para administrar un estacionamiento. Accede
al sistema Autopiloto () de los automóviles y los estaciona. ¿Hermoso no?
Entonces llega un cliente con una MOTOCICLETA. Motocicleta es un vehículo, al igual
que el automóvil, pero no tiene el sistema Autopiloto () y eso es todo, su estacionamiento
autónomo ya no funciona.
Tipagen es declarar el tipo de cosas. Una variable declarada como un entero, por
ejemplo, no deben aceptar nada más que un número. Al igual que una variable que es un
texto, no se le debe dar un número.
Visual Lisp no tiene Tipagen alguna.
Entonces puedes hacer esto:
Figura 83 - Visual Lisp no tiene Tipagen
En el ejemplo de Visual Lisp, definí el valor de la variable “a” inicialmente como texto y
luego con un valor numérico.
Por supuesto, habrá situaciones que no importan, o incluso deseables, pero en general es
una mala idea.
Tomar el examen:
Abra AutoCAD y escriba en la línea de comando:
(setq a "este é un teste")
Ahora, escribe:
(alert a)
Figura 84 - Alerta de AutoCAD
Ahora escriba en la línea de comando:
(setq a 12)
Ahora, escribe:
(alert a)
Figura 85 - Error en la línea de comando
¿Se da cuenta? La función (ALERT “mensaje”) espera que “mensaje” sea texto. Pero
proporcionamos un número y causó un error
No C# y VB esto también sucede y también puede indicarle al compilador que verifique
el código antes de compilar estos errores:
Figura 86 - Option Strict On
Público/Privado/Distribuido
Allá atrás, dijo que una de las características de la Orientación de Objetos es el
Encapsulación.
Figura87 – Encapsulamiento
Creemos un juego llamado Estacionamiento. El juego debe recibir autos y estacionarlos.
También debe recoger el automóvil cuando el propietario lo solicite. Implementa este
juego.
Simple ¿No? ¿Qué, ni siquiera sabes por dónde empezar? ¿recuerdas el ejemplo del
auto? Mira este pequeño código:
Figura 88 - Clase coche
¿te das cuenta de que acabo de crear algunos nombres de funciones para el automóvil?
Mira que el Autopiloto () está allí e incluso describí un código que dice cómo lo hace.
¿Y dónde está el resto del código? Bueno, ¿Recuerdas que hablé acerca de dividir un
gran problema en pequeños problemas?
Figura 89 - Como diría Jack, el Destripador: Vamos por partes
Ahora, veamos cómo sería la clase de estacionamiento, suponiendo que solo tengas
autos.
Figura 90 – BusqueCarroCliente
Mira, desde el punto de vista de Mac Donald’s, sé que el estacionamiento recoge el
automóvil del cliente y le da un mensaje de si el automóvil está allí o no.
Pero de ninguna manera Mac Donald’s sabe cuántos automóviles hay, o incluso quién
los posee.
¿Cómo sé que no lo hace? Porque declare que la mesa del coche es Private. Solo eso.
¿Cómo sé que Mac Donald’s sabe que el estacionamiento solo busca al automóvil?
Porque declaro que el método “BusqueCarroCliente()” es Public.
Aumenta ligeramente la dificultad:
Asumamos que el poder se ha vuelto relevante en nuestro negocio, por lo que
necesitamos diferenciar los automóviles por poder.
Cada automóvil del mismo modelo en principio tiene el mismo poder. Los autos de otros
modelos tienen poderes diferentes, sin embargo, siguen siendo autos. Incluiremos esta
propiedad en el auto.
Figura 91 - Agregue la Propiedad Potencia
Decir “Carro (coche)” es genérico. Decir Golf, Maverick no. Estoy especificando el
modelo y con eso los estoy diferenciando por el poder. Sin embargo, como estos dos se
derivan del mismo prototipo, ¡tanto el piloto como el estacionamiento solo! Y vea
cuántas líneas necesitaba para crear diferentes modelos.
Ejercicios: ahora suponga que solo Golf tendrá un techo solar. Incluya un botón en su
panel con la acción “AbrirOCerrarTechoSolar()” dependiendo del estado del techo.
Clase/Módulos/Estructuras
En los ejemplos anteriores, solo vimos clases: automóvil, estacionamiento.
¿Cuándo debo usar el módulo? Para comenzar, el módulo es solo para VB:
Public Module Genericos
Sub MetodoQualquer()
End Sub
End Module
En C# declaramos static class:
public static class Genericos
{
public static void MetodoQualquer()
{
}
}
De la ayuda de Microsoft:
Una clase static es básicamente lo mismo que una clase no estática, pero hay una
diferencia: una clase estática no puede ser instanciada. En otras palabras, no puede usar
el operador new para crear una variable de tipo de clase. Como no hay una variable de
instancia, puede acceder a los miembros de una clase estática utilizando el nombre de la
clase en sí. Esto significa que:
instancia = new Genericos();
no se puede usar y dará error.
Para acceder al método “MetodoQualquer()” simplemente haga:
Genericos.MetodoQualquer();
¿y en Visual Lisp?
Olvídalo, no hay nada de eso allí.
Hum... ¿cómo cambia eso la programación de AutoCAD que has estado
promocionando?
Bueno, para que el comando sea visible, tendrá que estar en:
“Public module” o “Public Class” no VB
“Public static”, “puplic class” en C#
Y hay una pequeña diferencia allí: “Per Document”. Al cargar el archivo DLL en
AutoCAD, los comandos que están en CLASE y no están en SHARED, cada documento
do AutoCAD tendrá su propia instancia de la clase. Esto puede ser útil si no desea
mezclar valores de variables globales entre documentos.
¿Qué hay de las estructuras?
Las estructuras son una forma de organizar los datos. Las estructuras son útiles cuando
desea que una solo variable contenga múltiples piezas de información relacionada. Por
ejemplo, es posible que desee conservar el nombre, el número de teléfono y el salario del
empleado. Puede usar varias variables para obtener esta información, o puede definir una
estructura y usarla para una sola variable de empleados. La ventaja de la estructura se
hace evidente cuando tiene muchos empleados y, por lo tanto, muchas instancias de la
variable.
En VB:
Public Structure Funcionario
Dim Nome As String
Dim Telefone As Integer
Dim Salario As Double
End Structure
En C#
public struct Funcionario
{
public String Nome;
public int Telefone;
public double Salario;
}
Cuando tiene una serie de propiedades, comienza a ponerse feo pasar por las funciones
una por una.
Diría que una estructura es casi como una clase, pero suceden cosas interesantes cuando
estos dos conceptos se mezclan.
Considere el ejemplo “Executavel.sln” en el material:
Figura 92 - Diferencia entre Clase y Estructura
Hay dos botones. Uno de la clase FuncionarioClase y el otro usa la estructura
FuncionarioStruct.
Ambos modifican los datos después de instanciar.
Figura 93 - ¿Dónde está Wally?
¿Puedes ver la sutileza de la diferencia?
Ejercicio: explique por qué sucede esto
Fields (campos)
Los campos se utilizan para almacenar información dentro de la clase (Strings, número)
o tipos complejos como otras clases. Sin embargo, la asignación o lectura de valores en
ellos no causa ninguna acción en la clase.
¿Recuerdas qué es la acción? Son las funciones o métodos. Imagina la situación. Desea
que la clase “carro” almacene algún valor. Este valor no necesita ser validado y puede
que ni si quiera necesite guardarse externamente (en una base de datos o archivos XML),
por ejemplo.
Imagina la situación. Desea que la clase CARRO almacene algún valor. No es necesario
validar este valor y es posible que ni siquiera sea necesario guardarlo externamente (en
una base de datos o archivo XML, por ejemplo)
Figura 94 - Fields Versus Property
¿Ves cómo usar la Property te permite verificar los datos internamente antes de
guardarlos?
¿Viste que he declarado los campos que realmente reciben valores como Private?
Properties (Propriedades)
¿Entendió la explicación de los Fields (Campos) anteriores?
Para reforzar: Property funciona como la unión de los métodos SET y GET. Como son
métodos, se le puede asignar más acciones que simplemente guardar o leer valores.
En el ejemplo, utilicé los Métodos GET y SET para validar los valores ANTES de
guardar:
Figura 95 - Fields versus Property
Métodos
¿Todavía recuerdas las clases de autos?
¿Puedes identificar un método? Ver, Auto piloto()
Figura 96- Método AutoPilotar
Tenga en cuenta que todos los automóviles deben proporcionar un MÉTODO
AutoPilotar() para que el automóvil sea “piloto automático”.
“Proporcionar” en este contexto, es hacer el método Public.
Figura 97 – “Proporcionar” en este contexto, es hacer el método Public
Ejercicio:
Implementa un método que verifique si es hora de la revisión
Este método debe responder con una oración, identificando por el kilometraje recorrido
si necesita revisar los 10, 20, 30, 40 o 50 mil km.
Tenga en cuenta que, si el propietario no realizo una revisión, el automóvil debe avisarle.
Ah, no permita que nadie, ni siquiera el propietario, “cambie” el kilometraje. Esto solo
se puede leer en la pantalla. Solo el método “SegueEnFrente()” puede actualizar el
odómetro.
Instancia
Instancia. Me llevó años entender de qué se trataba. Enserio. Lo usaba y ni siquiera sabía
de qué se trataba.
Cuando creamos la clase coche, en realidad no creamos UM auto, sino la definición de
qué es un auto.
Tenga en cuenta que para Auto Pilot() CUALQUIER automóvil, este automóvil debe
existir primero. Este se llama creación de instancias, creación de una instancia.
Para instanciar, usamos NEW:
En VB:
Figura 98 – Uso de New en VB
En C#:
Figura 99 – Uso de New en C#
En Visual Lisp:
Figura 100 - usando New en Visual Lisp: ni siquiera lo intentes
Herencia
Ya lo había definido allí, pero reforcémoslo: una característica que optimiza la
producción de la aplicación en tiempo y líneas de código AutoPilotar(). Ahora crea
modelos derivados de él y comienzan a tener el mismo sistema,por haber heredado esta
característica.
Cuando creamos la clase de auto, inmediatamente agregué otras dos clases de niños:
Golf y Maverick.
Bueno, también son autos, pero tienen sus propias características. Incluso uno de los
ejercicios le pide que implemente el método “AbrirOCerrarTechoSolar()”.
¿Hiciste eso?
Bien, ahora imagina que Maverick tiene varias versiones: V4, V6 e V8
Figura 101 - Figura aleatoria de Maverick LDO
Cada uno de ellos viene con su conjunto de opciones diferentes, además del motor
(potencia), por supuesto. Ejemplo: V4 tiene asiento de tela, V6 tiene asiento de cuero y
V8 tiene asiento de cuero y aire acondicionado. Tenga en cuenta que ahora la propriedad
TipoDeBanco aparece en los Maverick y se puede cambiar, pero en Golf el modelo
simple no se fabrica y el banco climatizado es estándar de serie.
Todos tienen AutoPilotar(), pero solo el V8 tendrá StartStop, para ahorrar combustible,
por supuesto.
StartStop debe activarse durante.
¿Puedes implementar estas características?
Primero, ¿Cómo heredas?:
Figura 102 - Herencia en VB
Figura 103 - Herencia en C#
Bueno, la mitad del ejercicio está ahí. Implemente el MaverickV8 e incluya el asiento
climatizado
También implementa Golf y verifica el tipo de banco que el amigo puede instalar.
Atributos
Los Atributos son cosas que podemos colgar en propriedades, métodos, clases, módulos
y se usan para muchas cosas. Un ejemplo:
Hiciste un FORM (¿recuerdas esta palabra?), que muestra la característica del automóvil.
Este FORM probablemente tiene un Controle (guarde esta palabra) del tipo
PropertyGrid (¡guarde esta palabra!)
Cuando el usuario del estacionamiento acede a su sistema, aparece este FORM.
¿Cómo crees que lee las propriedades del auto?
“Potencia” OK, es fácil de leer. ¿pero en qué unidad está?
“Bancos” y en el lado dice simple. Eso es todo.
“Modelo” escribe sólo “MaverickV8”
No sería más amigable si el Campo Potencia apareciera:
Potencia (HP): 100
O entonces:
Potencia: 100 HP
Y en cuanto al modelo, se vería mejor así:
Modelo: “Maverick V8 ¡hermano!”
¿Y debajo de eso vino una de esas descripciones que te hacen querer tener el auto?
Si. Estas características están todas hechas en los atributos.
Figura 104 - Atributos en VB
Figura 105 - Atributos en C#
Por supuesto, hay muchos otros usos para los atributos: definir el editor de un tipo
determinado (guardas esta palabra: TypeEditor), definir cómo convertir cualquier valor
en String y cómo recuperar el valor de un String (Guardar esta palabra:
TypeConverter).
Enumeradores
De la ayuda de Microsoft:
(https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-
reference/statenents/enum-statenent)
Si tiene un conjunto de valores sin cambios que están relacionados lógicamente entre sí,
puede definirlos juntos en una enumeración. Esto proporciona nombres significativos
para enumeración y sus miembros, que son más fáciles de recordar que sus valores.
Luego puede usar los miembros de enumeración en muchos lugares de su código.
Los beneficios de usar enumeraciones incluyen lo siguiente:
Reduce los errores causados por errores de transposición o tipeo.
Facilita el cambio de valores en el futuro.
Hace que el código sea más fácil de leer, lo que significa que es menos
probable que se introduzcan errores.
Garantiza la compatibilidad con versiones posteriores. Si usa
enumeraciones, es menos probable que su código falle si alguien cambia
valores correspondientes a los nombres de los miembros en el futuro.
Una enumeración tiene un nombre, un tipo de datos subyacente y un conjunto de
miembros. Cada miembro representa una constante.
En el ejemplo de los automóviles, definí una enumeración para el tipo de banco ¿viste?
Figura 106 - Enumeración en VB
Figura 107 - Enumeración en C#
En Visual Lisp, podría implementar enumeradores con variables globales:
https://docs.microsoft.com/pt-br/dotnet/visual-basic/language-reference/statements/enum-statement
Figura 108 – Uso de variables globales para enumeradores
Constantes
De la ayuda de Microsoft:
(https://docs.microsoft.com/pt-br/dotnet/visual-basic/programming-guide/language-
features/constants-enums/how-to-declare-a-constant)
Utiliza Const para declarar una constante y establecer su significativo su valor. Al
declarar una constante, puede asignar un nombre significativo a un valor. Una vez que se
declara una constante, no se puede modificar ni darle un nuevo valor.
A la constante debe tener un nombre simbólico válido (las reglas son las mismas para
crear nombres de variables) y una expresión compuesta de caracteres numéricos o de
cadena y operadores (pero no llamadas a funciones).
Un ejemplo: suponga que desea declarar el valor PI:
Figura 109 – uso de constantes en VB
Figura 110 - Uso de constantes en C#
Tenga en cuenta que hay mucho más en la ayuda de Microsoft, le sugiero que lea.
https://docs.microsoft.com/pt-br/dotnet/visual-basic/programming-guide/language-features/constants-enums/how-to-declare-a-constant
Hello World
Ahora, finalmente, ¡digamos hola mundo en AutoCAD!
Concepto que debes recordar:
a) Clase
b) Método
c) Atributo
d) Crear un proyecto Dll en Visual Studio
e) Agregue referencias compatibles con AutoCAD / Civil3D
f) Elija la versión de .NET Framework
Solo estos.
Ah, por supuesto, haber entendido mínimamente cómo programar....
Crear Comando
Comencemos con Visual LISP, solo para variar.
Escriba VLIDE en la línea de comando y haga clic en un nuevo documento y escriba
esto:
Figura 111 - Hola Mundo en Visual Lisp
Seleccione TODO el texto y haga clic CTRL + SHIT + E
Esto cargará el código sin necesidad de APPLOAD.
Ahora, en la línea de comando, escriba HELLOWORLD e haga clic ENTER:
Figura 112 - Hello world funciona en Visual Lisp
Perfecto. Ahora la versión VB
1. Abra Visual Studio
2. Crear un proyecto de tipo DLL
3. Agregue referencias a las DLLs
a) acdbmgd.dll
b) acmgd.dll
c) accorengd.dll
4. Crear un módulo público
5. Ingrese el código
6. Asegúrese de que .NET Framework es correcto
Figura 113 - Crear Proyecto DLL en VB
Figura 114 - Hello World en VB (archivo 01)
Tenga en cuenta los colores:
El verde es un comentario. No influirá en la ejecución e incluso puede eliminarse.
En azul, son instrucciones nativas del lenguaje
En marrón, funciones o métodos
Rojo, Strings
Vea, este es el mínimo que un programa necesita para ejecutar AutoCAD como un
comando.
Note la cantidad de conceptos involucrados.
a) Imports, importa NameSpace para simplificar el uso de sus métodos.
b) Public Module, define un módulo como público
c) Public Sub, define un método como público
d) MsgBox, método interno de VB que muestra un mensaje en pantalla
e) CommandMethod, atributo que está en NameSpace
Autodesk.AutoCAD.Runtime, que por su vez está en DLL accorengd.dll
f) VBNewLine, constante de tipo String, que está en NameSpace
Microsoft.VisualBasic, que por su vez está en DLL
Microsoft.VisualBasic.dll
Figura 115 – ¡la cantidad de conceptos puede ser aterradora!
Bueno, ahora solo compila, pero primero, mira las propriedades de la solución:
Figura 116 - Propiedades de la solución (DLL)
Lo que necesita 20ver en esta pantalla:
Nombre del assenbly (es el nombre que llevará DLL)
NameSpace Raíz, así como cualquier biblioteca de clases, tenemos un
NameSpace, para no mezclar nuestro comando con métodos del mismo
nombre en otros DLL, métodos, etc. etc.
Tipo de Aplicación: Biblioteca de Clases (DLL)
Estructura de destino: .NET Framework 4.7.2, para AutoCAD 2020
Ahora mira esta pantalla:
Figura 117 - Propriedades de compilación
Aquí, elegirás
El destino (donde guardar el dll)
La Plataforma (prefiere Any CPU, para .NET Framework)
El resto se va como en la pantalla (ejercicio: averigüe qué es “Opção Strict”)
¿Viste los dos? ¡Así que compila! Para hacer esto, haga clic en el menú compilación /
solución de compilación
Figura 118 – Compilar
Ahora, abra AutoCAD y haga NETLOAD:
Figura 119 – NETLOAD
Sí no se producen errores, funcionó. Llame al comando HELLOWORLD:Figura 120 - Hello World funcionando en VB!!!
Es eso. ¡El comando funciona!
¿Qué errores pueden pasar? Ejercicios:
a) Busque en internet “SECURELOAD”
b) También busque “Could not load file or assenbly”
Perfecto. Ahora la versión C#
1) Abra Visual Studio
2) Crear un proyecto de tipo DLL
3) Agregar las referencias a DLLs
a) acdbmgd.dll
b) acmgd.dll
c) accorengd.dll
4) Crear un módulo público
5) Ingrese el código
6) Asegúrese de que .NET Framework sea correcto
Figura 121 – Creación de un Proyecto DLL en C#
Figura 122 - Hello World en C#
Tenga en cuenta los colores
El verde es un comentario. No influirá en la ejecución e incluso puede eliminarse.
En azul, son instrucciones nativas del lenguaje
En marrón, funciones o métodos
Rojo, Strings
Vea, este es el mínimo que un programa necesita para ejecutar AutoCAD como un
comando.
Observe la cantidad de conceptos involucrados:
a) using, importa el NameSpace para simplificar el uso de sus métodos
b) public static class, define un módulo como público
c) public static void, define un método como público
d) MsgBox, método interno de VB que muestra un mensaje en pantalla
e) CommandMethod, atributo que está en NameSpace
Autodesk.AutoCAD.Runtime, que por su vez está en DLL accorengd.dll
f) VBNewLine, constante de tipo String, que está en NameSpace
Microsoft.VisualBasic, que a su vez está en DLL Microsoft.VisualBasic.dll
Bueno, ahora solo compila, pero primero, mira las propriedades de la solución:
Figura 123 - Propriedades de la Solución (DLL)
Lo que necesita ver en la pantalla anterior:
Nombre del assenbly (es el nombre que llevará DLL)
NameSpace predeterminado, de modo que tenemos un NameSpace, para no
mezclar nuestro comando con métodos del mismo nombre en otras DLL,
métodos, etc.
Tipo de Salida: Biblioteca de Clases (DLL)
Estructura de destino: .NET Framework 4.7.2, para AutoCAD 2020
Ahora, mira esta pantalla:
Figura 124 - Propriedades de compilación
Aquí, elegirás:
La ruta de salida (donde guardar el dll)
La Plataforma (prefiere Any CPU, para .NET Framework)
¿Viste los dos? ¡Entonces compila! Para hacer esto, haga clic en el menú Compilación/
Compilar Solución
Figura 125 – Compilar
Ahora, abra AutoCAD y haga NETLOAD:
Figura 126 – NETLOAD en C#
Si no se producen errores, funcionó HELLOWORLD:
Figura 127 - Hello World funcionando en C#!!!
Es eso. ¡el comando funciona!
¿Qué errores pueden pasar? Ejercicios:
c) Busque en internet “SECURELOAD”
d) También busque “Could not load file or assenbly”
Acceda a AutoCAD
¿Es genial el código?
¡Pero aún no henos hecho nada!
Para hacer algo efectivo con AutoCAD, necesitamos “obtener” el proprio AutoCAD.
Después de eso, podemos hacer “cosas” con él
Figura 128 - "Obtengamos" AutoCAD y hagamos "cosas" con él
A partir de aquí, los códigos que mostraré estarán solo en VB.
Si quieres escribir en C#, no hay problema. Incluso puedo darte un consejo, visita
https://converter.telerik.com/
Adivina lo que hace...
Figura 129 - Convertidor de código VB a C# y viceversa
No hay misterio:
a) En el botón superior, elige el origen / destino.
b) Pegue el código en el marco izquierdo.
https://converter.telerik.com/
c) Haga clic en Convert Code
d) Copie el código convertido en el marco derecho.
Bueno, ahora AutoCAD. ¿recuerda que para usar el CommandMethod , debemos importar el
NameSpace Autodesk.AutoCAD.Runtime ?
Entonces, para “obtener” AutoCAD, haga:
Figura 130 - "Obter" AutoCAD (archivo 02)
En la API .NET, “obtener” AutoCAD, es usar la palabra Application.
Vea que inserté un nuevo módulo, simplemente para no confundirlo con Hello World.
En este programa, estoy interesado en ver la versión de AutoCAD. Compile el código y
ejecute el comando VersaoAutoCAD:
Figura 131 - Versión AutoCAD
Aquí, 23.1 es le reléase de AutoCAD. Recuerde cuando hablamos la versión de
AutoCAD así: “R14”, “R13”... entonces, AutoCAD 2020 es R23.1.
Acceda al documento actual
Bueno, accedemos a AutoCAD. Ahorra, accedamos al documento actual (el archivo
DWG abierto actualmente, si lo prefiere) y veamos su nombre actual y el archivo del que
se originó:
Figura 132 – Acceso al administrador de documentos (archivo 3)
Tenga en cuenta que, para acceder al documento actual, primero accedí al administrador
de documentos (DocumentManager) de AutoCAD (Application).
Compile, cargue y use el comando DOCUMENTOATUAL:
Figura 133 - Documento Actual
Bueno, espero que ya te hayas dado cuenta de que usé un truco para no tener que cerrar
AutoCAD. Si no lo notaste, presta mucha atención a la pantalla…
Poniendo todo junto...
Hasta ahora (hasta ahora... @Dilma) henos accedido a AutoCAD, el administrador de
documentos y el documento actual.
Con eso ya podemos hacer algo.
Ejercicios:
1. Agrega comentarios donde creas que es importante
2. ¿Recuerda la idea de clase? ¿Instancia? ¿Método? Identifícalos en el código.
3. Identificar atributo
4. Explique la declaración de “Imports”
5. Explica por qué usé un punto en la línea 12 del código
Importaciones
¿Fue agotador el capítulo anterior? ¿Si o seguro?
Recuerde qué “Imports” hicimos:
'para pegartomar el AutoCAD importe el namespace:
Imports Autodesk.AutoCAD.ApplicationServices
'CommandMethod, importe el namespace:
Imports Autodesk.AutoCAD.Runtime
Por supuesto, no son solo por lo que mencione anteriormente. Hay mucho más allí. Un
consejo para saber qué “tiene” en este NameSpace o incluso en las DLLs a las que no
referimos, es utilizar el menú Exibir / Pesquisador de Objetos
Figura 134 - investigador de Objetos
¿Te gusta el Investigador de Objetos?
Ahora podemos saber qué NameSpaces, métodos, clases etc., están en un DLL.
Puedo decir que definitivamente usaremos lo siguiente:
Figura 135 - Otros NameSpaces que usaremos
Mira esta pantalla. ¿Qué ves diferente de ella? Mire la línea 19. Estoy creando una
directiva para que el compilador importe la Section desde un NameSpace u otro,
dependiendo de la versión de Civil 3D.
Mire la línea 10. ¿te das cuenta de que creé un “apodo” para AutoCAD? A veces,
algunos métodos tienen nombres idénticos en diferentes espacios de nombres y los
necesitamos todos. Entonces podemos llamar a uno de ellos y referirnos a los métodos
por el apodo NameSpaces e precisamos de todos. Entonces podemos llamar a uno de
ellos y referirnos a los métodos por el apodo.
Un ejemplo:
Dim onlineuser As String
Try
onlineuser = AutoCADApp.GetSystenVariable("ONLINEUSERID")
Catch
onlineuser = ""
End Try
Este código será útil para averiguar si el usuario actual de AutoCAD ha iniciado sesión
en su cuenta de Autodesk. ¿Para qué eso? ¡Usa la imaginación!
De golpe mostré un Try .
Entrada de datos
Ya henos creado una solución, ya henos agregado un comando. Ahora hagamos algunas
preguntas en línea de comando de AutoCAD.
Las preguntas de la línea de comandos en la API de DOTNET se hacen utilizando
métodos que se encuentran en el siguiente NameSpace:
Imports Autodesk.AutoCAD.EditorInput
Para usar, llamemos al editor del documento actual. Entonces, podemos hacer preguntas
al usuario.
Figura 136 – el usuario - TRON
En las siguientes tenas, le mostraré cómo chatear con el usuario desde la línea de
comandos. Pero presta atención. Parecerá un poco repetitivo, pero incluiré un nuevo
concepto par a cada tipo de datos que muestre.
Distancias
Comencemos despacito. AutoCAD trabaja con distancias, medidas. Comencemos con
esto:
Figura 137 – GetDistance (archivo 04)
No incluye ninguna verificación, por lo que el usuario proporciona un valor o no.
Bono Visual Lisp:
Figura 138 - GetInt en Visual Lisp
Número entero
Decoremos ahora. Queremos un número entero positivo entre 0 y 100:
Figura 139 – GetInteger (archivo 04)
Compilar, cargar y llamar. Vea la interacción con el usuario que intenta ingresar un valor
no válido:
Figura 140 - GetInteger en acción
Tenga en cuenta que no necesitaba verificar el valor informado porque la función
GetInteger hace esto.
Figura 141 - Verificando númeroen Visual Lisp
Tenga en cuenta que Lisp no tiene las opciones. Así que simule usando el looping
“WHILE”
Número real
Un número real. Mira que ahora cambié un poco el código. Piense en una ejecución más
“lineal” por así decirlo.
Utilizo mucho este modelo cuando tiene muchos datos que pedir y si el usuario hace clic
en ESC durante cualquier pregunta, el programa finaliza, sin hacer las preguntas
posteriores.
Figura 142 – GetDouble (archivo 04)
La función equivalente de Visual Lisp es GetReal.
Ejercicio: escriba un código que use esta función, validando el número. Digamos que
necesita estar en el intervalo 10.0 <= valor <= 20.0
Texto
¿Es fácil ahora? Tenga en cuenta que cada función “Get*******del Editor puede aceptar
directamente la pregunta, o el “Prompt*******Options”
Figura 143 – GetString (archivo 04)
Vea. Incluye algunas opciones para obligar al usuario a proporcionar una URL válida,
pero aún no confío mucho en él. Así que traté la URL en la línea 105
Ah, “Help” en la línea 114, está en NameSpace Systen.Windows.Forms
¿Y en Visual Lisp?? GetString:
Figura 144 - Visual Lisp y GetString
Ejercicio: descubra StartApp, en Google (busque Functions Reference (AutoLISP)).
Palabras clave (Keywords)
Las palabras clave que usamos cuando queremos darle al usuario una serie de opciones,
donde elige una en la línea de comando. Un ejemplo es el comando PEDIT. Proporciona
algunas opciones:
Figura 145 - Opciones PEDIT
Y VB.NET haríamos:
Figura 146 - ¡Ensalada Mixta!!! (archivo 04)
Figura 147 - opciones en AutoCAD: Ensalada mixta
Coordenadas
Me voy a encoger tanto como sea posible para encajar, ok
Figura 148 – GetPoint (archivo 04)
Mira, he agregado algunas ideas muy útiles:
1. El usuario puede querer interrumpir el comando en medio de la ejecución
2. Puede dejar de guardar el archivo de coordenadas
3. Si hace clic en más de un punto, se dibuja una polilínea temporal (agregue
Regen)
4. Guarde las coordenadas con 4 decimales en el archivo TXT
Por supuesto, tuve que agregar algunos Imports:
'Point3D, POint3DCollection
Imports Autodesk.AutoCAD.Geometry
'Process.Start:
Imports Systen.Diagnostics
Compilar, cargar, rotar PedirCoordenada:
Figura 149 - PedirCoordenada en acción
Ver el resultado:
Figura 150 - Resultado del comando PEDIRCOORDENADA
Funcionará bien, si NOTEPAD es el editor de archivo TXT predeterminado.
¿Te das cuenta de que el separador de miles es la coma y el separador decimal es el
punto?
Ejercicio:
Intente cambiar esto invirtiendo una coma con un punto.
Consejo: CultureInfo (google it!!!)
Ejercicio:
a) copie solo los COMENTARIO al bloc de notas. Intenta organizar y entender el flujo.
La receta del pastel.
b) Averigüe qué función solicita puntos en Visual Lisp e intente transcribir al código
anterior en Auto LISP (para dibujar la línea temporal, use (grdraw from to color true)
Figura 151 – Solución para el último ejercicio
Entidades (líneas, textos etc.)
Ahora preguntemos por la selección de objetos. En Visual Lisp, hacemos clic en los
objetos usando EntSel:
Figura 152 - EntSel no Visual Lisp
Vea que no hay forma de filtrar si es línea, texto o punto.
Antes de continuar, estudiemos un poco más sobre AutoLISP. En el código anterior,
utilicé las funciones ENTGET, CDR e ASSOC (búsqueda de Google: “AutoLISP
functions reference”) para encontrar el tipo de objeto en el que se hizo clic. Siga cómo
se ve un círculo en AutoLISP:
Figura 153 - Circle DXF Group Codes
Tenga en cuenta que TODO en Auto LISP es una lista y, por lo tanto, la información
debe identificarse en la lista. Para eso, Auto LIPS usa duplas (odio esta palabra, prefiero
pares). Tenga en cuenta que cada información se ve así
( número . valor )
Busque en el oráculo los “circle dxf group codes”. Autodesk tiene enlaces muy
largos....
¿Buscó?
Ahora tenga en cuenta lo siguiente: el número DXF es un ENUMERADOR, ¿Recuerda
qué es eso?
El valor suele estar separado del número DXF por un PUNTO.
El ENUMERADOR de valor 8, SIENPRE almacena el nombre LAYER de la identidad.
410 dice en qué “Layout” u objeto se encuentra: Model, Layout1, Layout2....
Correcto. Pronto comprenderá por qué decidí incluir AutoLISP (Visual Lisp, AutoLISP,
Lisp, descubra las diferencias en Google) para este curso.
Ejercicio: realice un looping para verificar el tipo de objeto seleccionado que le pide al
usuario que haga clic hasta que él desista o haga clic en una línea.
Ahora vamos aDOTNET:
Figura 154 – GetEntity (archivo 05)
Tenga en cuenta que para usar la clase “Line” (consulte la línea 32), necesitaba importar
otro NameSpace, el Autodesk.AutoCAD.DatabaseServices.
Y usé otro concepto nuevo para nosotros: ObjectId (mira la página anterior, hablando
DXF)
Cada objeto, dibujable o no, en AutoCAD tiene un ObjectId. Esta propiedad funciona
como su “NIF”, siendo una identificación única de cada objeto. por lo tanto, al
seleccionar cualquier objeto usando GetENTITY, la respuesta de esta función devuelve
el ObjectId. Cualquiera que haya trabajado con C++ está familiarizado con el concepto
de puntero. Si no tienes idea de lo que estoy hablando, quédate con la idea de NIF.
En el código, utilicé el método GetEntity dos veces, una sin especificar ninguna opción y
otra que reStringe la entrada del usuario. Si no realizo esta restricción, podría haber un
error en la línea 36.
Ejercicio: en la línea 33, cambie el argumento GetEntity de “opcoesComFiltro” a
“opcoes” y ejecute el código. Vea:
Figura 155 - Error de ejecución
Este es uno de los errores de ejecución más comunes que verá en AutoCAD.
En el ejemplo, cuando pregunta por la segunda entidad, que debería ser una línea, hice
clic en un círculo. Entonces, cuando llegó a la línea 36, el programa intentó convertir la
respuesta del método OPEN (que es del tipo DBObject) en una LINE, pero el objeto
selecciona es un CIRCLE.
Ahora, corrija la línea33 y vuelva a ejecutar:
Figura 156 – Haga clic en entidades de trabajo
Inserté otro concepto muy sutil en este código: la declaración USING.
Imagina esto: eres la computadora.
El usuario coloco una LÍNEA en su memoria.
El programa ha terminado.
La línea todavía está en su memoria, pero el usuario no ha eliminado la línea de su
cabeza.
Figura 157 – La línea aún está en la memoria use USING! o Dispose....
Los objetos que van a la memoria deben descartarse cuando ya no son útiles. Cuando
esto es un problema, estos objetos implementan un método para ser descartado:
DISPOSE. PERO este DISPOSE (disposición) sólo se llama si el método es llamado y
para eso, debe incluir una línea de código para eso.
¿Qué sucede si usa el método OPEN de ObjectId y no DISPOSE? Cambiar el código:
Figura 158 - cambio
código, intercambio USING por DIM
Nada puede suceder de inmediato, pero eventualmente fallará y algunas veces puede ser
fatal.
Figura 159 – EwasOpenForWrite
Para corregir, necesitamos incluir DISPOSE:
Figura 160 - Incluir DISPOSE (archivo 05)
Mira la línea 45. Haz tus cambios. Es probable que deba reiniciar AutoCAD ahora para
poder probar en la MISMA LÍNEA QUE ERRÓ.
Entonces, ¿Qué hace USING? Respuesta: hace el DISPOSE. Ahora tiene dos opciones
cada vez que un objeto es DISPOSABLE (implementa el método DISPOSE): Use
USING o haga DISPOSE manualmente o se producirán errores.
Selecciones
Ya sabemos cómo seleccionar un objeto. Ahora, selecciónenos VARIOS objetos. Y para
ser gracioso, ya que este curso iba a ser de programación para el Civil 3D también,
agregue las referencias para las DLLs:
AecBasengd.dll
AeccDbMgd.dll
Están en la carpeta de instalación de dicho cuyo.
Crear filtros para la selección.
Bueno, estaremos interesados en los COGO Points. Vea el código, analicemos:
Figura 161 - Selección de Cogo Points (archivo 06)
Conceptos para aprender con este código:
NameSpace de la base de datos Civil 3D: Autodesk.Civil.DatabaseServices
Opciones ubicadas en el atributo CommandMethod: UsePickSet,
NoPaperSpace
Clase SelectionFilter, mira los argumentos de inicialización.
Autodesk.Civil.DatabaseServices
Figura 162- Autodesk.Civil.DatabaseServices
Civil 3D API tiene mucho, pero tanto que no hay forma de poner todo aquí. Ni si quiera
tendría sentido. Entonces, aprendamos a LEER la ayuda de la API. Arriba estamos
viendo la versión 2019, acceda aquí:
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
CommandMethod: UsePickSet, NoPaperSpace
Búscalo en Google: AutoCAD API CommandMethod
https://knowledge.autodesk.com/search-
result/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-NET/files/GUID-F77E8FE0-
8034-4704-93BD-F717608F8223-htm.html
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
https://knowledge.autodesk.com/search-result/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-NET/files/GUID-F77E8FE0-8034-4704-93BD-F717608F8223-htm.html
Figura 163 - Argumentos de CommandMethod
Las selecciones de objetivos múltiples, así como la entrada de datos, también permiten
variaciones:
Seleccione DOTNET Visual Lisp (ssget
[opción]
Normal GetSelection
Todas SelectAll “X”
Polígono anterior y
cruzado
SelectCrossingPolygon “CP”
Ventana interior y
cruzada
SelectCrossingWindow “CW”
cruce SelectFence “F”
Lo que ya está
seleccionado
SelectImplied “I”
Ultimo seleccionado SelectPrevious “P”
Dentro da la ventana SelectWindow “W”
Dentro del polígono SelectWindowPolygon “WP”
Selección única GetEntity “:S”
Figura 164 - Comparación de las funciones de selección de DOTNET y AutoLISP
Todos aceptan algún tipo de filtro. Pero solo DONET puede cambiar la “frase” de
selección. en AutoLISP, primero debe poner un “prompt”.
Crear filtros puede ser simple o complicado, dependerá de la “query” que vaya a aplicar.
Ejemplo: seleccione toda la LÍNEA en layer “0”:
Puede ser simple, versión de AutoLISP:
Figura 165 - SelectAll en AutoLISP
Aprovechando, creo que aún no lo he dicho, ¿se dio cuenta de que la función SETQ es
responsable de asignar el valor a una variable?
La selección puede ser complicada, ver:
Figura 166 – Crear puntos y seleccionar con filtro
Figura 167 – Resultado
Este pequeño programa genera 10 mil puntos aleatorios (pseudo, va) dentro de un
cuadrado que va de (0,0) a (1000,1000) y luego c los que están en una ventana entre
(400,500) y (600,700) y finalmente pinta éstos de rojos. Sí, todo esto para ejemplificar
cómo hacer el filtro y ni siquiera mostré cómo sería el mismo filtro en DOTNET.
En DOTNET, el programa para generar puntos aleatorios se vería así:
Figura 168 – Creación de puntos, filtro complejo para selección (archivo 07)
El resultado el el mismo que la versión en Visual Lisp.
¿recuerdas cuando dije que el número DXF es un ENUMERADOR? Comparar:
Figura 169 – Identificar el enumerador
Conceptos importantes que aparecen en esta tena:
NameSpaces: Autodesk.AutoCAD.Geometry y
Autodesk.AutoCAD.DatabaseServices
Clase SelectionFilter
Transaction, veremos a continuación
Usar USING para deshacerse de objetos “desechables”
Ejercicio:
Cree un looping FOR EACH que escriba el nombre y el valor del enumerador DxfCode
en la línea de comando. Consejo use [Enum].GetValues(GetType(DxfCode))
Transacciones
Cuando trabajamos para acceder a la base de datos de AutoCAD (y también a Civil 3D),
no nos referimos a sus objetos por el OBJECTID de cada objeto. ¿recuerda la idea de
NIF? Muy bien. Pero para acceder a las propriedades de cualquier objeto, necesitamos su
instancia. En el código anterior, utilicé la instrucción NEW para crear INSTANCIAS da
clase DBPoint en la línea 23 (¡iba a ver!)
Este punto solo existe en la memoria y solo será parte de la base de datos de AutoCAD si
y solo SI:
1) Agréguelo a algún BlockTableRecord, en el ejemplo lo agregué a model space
2) Indique a AutoCAD qué punto se insertó a través de la transacción, en la línea 26
( AddNewlyCreatedDBObject )
3) “Entregue el paquete” es decir, COMMIT, en la línea 50 del código DOTNET
Sin estos pasos no funcionará. (¡mentira, puedes hacerlo sin una transacción también,
búscalo!
¿Recuerdas de USING y DISPOSE? Muy bien. Las TRANSACTION en AutoCAD, así
como todos los objetos derivados de DBOBJECT (línea, punto, layer, textstyle…) son
DISPOSABLE.
En general, DBOBJECT no causan un error fatal si no utiliza DISPOSE o USING, pero
TRANSACTION puede. Por cierto, ¿alguien ha tenido los botones de la barra de edición
de perfil y alienación del Civil 3D “congelados”? Diría que el problema es una
TRANSACTION abierta, que no fue DISPOSED....
Figura 170 - Transaction sin USING y sin DISPOSE
Crear
Mi sugerencia y así es como lo hago normalmente:
Figura 171 - Crear TRANSACTION (archivo 08)
Dijiste que TRANSACTION es DISPOSABLE, así que quieres decir que puedes hacer:
Figura 172 - DISPOSE, COMMIT y ABORT (archivo 08)
Si, pudiera. Mientras recuerdes el DISPOSE. Prefiero especialmente la primera opción.
Nido
En ausencia de una buena explicación:
Figura 173 - Coloque TRANSACTION dentro de otro: anidar
Coloque una transacción dentro de otro.
Imagine el siguiente escenario:
1) Al usar NOTASERV2 (https://tbn2net.com/NOTASERV2)
2) Es necesario abrir una transacción para leer las propriedades de alineación y
dibujar la tabla en MODELSPACE. Esta transacción debe tener COMMIT
3) La tabla mostrará las coordenadas de los PI’s de alineación. Ahora hay un
problema NO HAY API PARA ESTO
4) ¿cómo resolverlo? Hice lo siguiente: creo una transacción temporal que se
cancelará
5) En él, edito el estilo de alineación para que solo muestre el bloque POINT OF
INTERSECTION.
6) Explota la alineación y recoge los bloques generados.
7) Abortar la transacción temporal
8) Crea la tabla
9) COMMIT en la transacción inicial
https://tbn2net.com/NOTASERV2
Reproduciré parte de lo que hice en NOTASERV2 y, en lugar de dibujar una tabla,
simplemente insertaré los bloques que resultaron de los dos PI’s.
Figura 174 - Transacción Temporal (archivo 09)
El programa principal está ahí.
Si tenemos esto:
Figura 175 - Alineación típica
Después de ejecutar el código tendríamos esto:
Figura 176 - PI's de alineación
Por el estilo del bloque que usé, dibuja un círculo:
Figura 177 – pantalla de Alignment Style: verifique el bloque utilizado en el “Marker Style”
Ejercicios:
1) Implemente el método ModificarEstilo(estilo como AlignmentStyle)
2) Cuando termine, intente crear un perfil, profileview, labels etc. e intenta ejecutar
el mismo programa
3) ¿Ocurre algún problema? (¡sí, ocurre!)
4) ¿Cuáles?
5) ¿Cómo resolverlo?
Consulte: cree el programa con funciones incompletas, ya que aún no tenemos los
subsidios para complementar el comando.
Finalizar
No hay mucho que decir, excepto:
Puede retirarse de una transacción colocando un DISPOSE sin un COMMIT antes
Puede renunciar a una transacción que une USING sin tener que poner ABORT,
simplemente llegando a END USING sin tener COMMIT
Si utiliza explícitamente DISPOSE, ya no podrá utilizar la transacción después de esta
DISPOSE.
Para que los cambios que realice surtan efecto, debe tener un COMMIT al FINAL de sus
cambios. No ponga COMMIT hasta que termine.
Figura 178 - COMMIT solo al final ¿de acuerdo?
Abortar
¿Qué pasa si quiero cancelar la transacción?
Figura 179 - Abortar la transacción
Si es posible. Simplemente pon:
Tr.Abort()
¿Cuándo vas a necesitar esto? Un ejemplo sería una aplicación que tiene una transacción
larga, donde la computadora interactúa con el usuario, pero en cierto punto, le dio una
m* muy grande y necesita deshacer las cosas… particularmente creo que podría haber
usado USING y se fue antes de COMMIT, pero, de todos modos.
Ejercicio:
1) ¿Puedes poner ABORTAR después de COMMIT?
2) ¿Y poner antes?
3) ¿A qué conclusión llegaste con estas dos pruebas?
Acceder la base de datos de AutoCAD
Documentos
Crear
Ya henos accedido al documento actual. Manipulamos el documento actual y para crear
un documento, #comofas? (sí, con S.…) Esto es simple. Para crear un documento:
Figura 180 - Crear un documento Civil 3D (archivo 10)
Mira que interesante. 61 líneas de códigos y tenemos un DWG con una alineacióncon
una curva circular. Ahora mire la cantidad de recursos que necesitaba para esto:
Figura 181 - NameSpaces utilizados para crear un dwg do Civil 3D (archivo 10)
¿Mencioné el investigador de objetos? Ya sí. CTRL+ALT+J
Después de que tengas la idea y hagas la receta del pastel (mira los comentarios del
código), solo escribe. ¿necesitas decorar? ¡claro que no! Pero debe tener un buen sentido
de comprensión de dónde encajan las cosas. Mira la figura de arriba.
SaveFileDialog es un FORM. Estará en Systen.Windows.Forms
Alignment, es algo que se dibuja en la pantalla y todo lo que se dibuja (y lo que no se
dibuja) en AutoCAD, debe estar en una base de datos:¡ DatabaseServices! En este caso,
el de Civil 3D.
Documento Actual
Esto ya está abierto si accedió al comando desde la línea de comando por lo que no hay
misterio:
Figura 182 - Documento actual (archivo 08)
Pero ¿qué pasa si simplemente no hay documento?
Figura 183 - AutoCAD sen documentos
Si no tiene un documento, el documento actual será “Start Page”. Entonces hay un
documento. Entonces, sí, hay un documento y no, no lo hay. Esto lo descubrí al trabajar
con EVENTOS:
Figura 184 - Eventos DocumentAtivated y BeginDocumentClose
Este fragmento de código está en el nuevo programa que estoy escribiendo.
BeginDocumentClose básicamente elimina el documento que se cierra de la lista de
documentos que el programa monitorea y apaga los EVENTOS asociados con él.
DocumentActivated se activa cada vez que el usuario cambia el documento actual.
Ejercicio: abra dos dibujos que contengan cosas y mire el TOOLSPACE del Civil 3D. Es
natural que, al cambiar de dibujo actual, TOOLSPACE se modifique para representar los
datos del dibujo Actual, ¿no? Ahora cierre los dibujos, pero sin cerrar TOOLSPACE. Se
cierra también. Este es un comportamiento esperado, porque si no hay nada que mostrar,
no permita que el usuario tenga acceso a él, o puede hacer clic en un botón que necesita
un documento para existir y si eso sucede (¡sucederá ¡), puede ocurrir un error fatal.
Hablaremos de EVENTOS…
Abrir
Abrir un documento. Bueno, no es muy diferente de CREAR.
Figura 185 - Abrir archivo (archivo 11)
Abrir y guardar. Muy trivial. Tenga en cuenta que estoy modificando el archivo,
importando puntos por él
Ejercicios:
1. Implemente algunas medidas de seguridad contrarias para evitar errores al
leer las puntadas. Este usuario puede haber puesto una coma donde no
debería hacerlo hecho, puede haber saltado una línea, de todas formas, puede
haber olvidado completar una columna...
2. Utilice db.Save sin las medidas de seguridad implementadas
(IO.File.Move(...)).
¿recuerdas que dije que puedes trabajar sin TRANSACIONES?
No hay ninguno visible allí.
No me gusta particularmente. Lo tienes o no lo tienes.
Salvar
Lo hice dos veces en los códigos anteriores.
Hagamos ejercicio. Cree un código que abra un DWG y verifique la versión (use
db.OriginalFileVersion ) y, si es diferente de la versión actual, guarde con la versión actual.
Model Space
Algún código aquí ya ha utilizado BlcokTableRecord de MODELSPACE.
¿Por qué estoy hablando de Model Space? Civil 3D sólo dibuja en MODELSPACE. Es
el que dibuja en AUTOCAD el que dibuja en PAPERSPACE. Ten eso en mente.
además, en algún momento mencioné que MODELSPACE es un bloque. Bien, sé que no
lo es, pero tómalo como si lo fuera.
¿Qué es un bloque? Es un montón de objetos: líneas, textos, polilíneas... y en cuanto
PAPERSPACE, bueno, es un bloque para cada layout...
Figura 186 - jerarquía de objetos de AutoCAD
En la imagen, Application es AutoCAD.
Luego viene el administrador de documentos, que tiene una lista de documentos que
puede agregar y quitar.
Luego viene el documento en sí. Eso tiene un nombre, lugar y una DATABASE.
DATABASE tiene algunas tablas: BLOCKTABLE, LAYERTABLE,
DIMSTYLETABLE….
BLOCKTABLE, tiene los OBJECTID de cada BLOCO (BLOCKTABLERECORD)
O MODELSPACE es un BLOCKTABLERECORD, por lo que se puede decir que es un
bloque...
Figura 187 - Acceda al ModelSpace (archivo 07)
¿Recuerdas el programa CriarPontosAleatoriosVB que creamos?
Layouts
Bueno, vamos a mostrarte con un programa. El siguiente programa solicita la selección
de cualquier carpeta que tenga archivos DWG. Luego escanee la carpeta y las
subcarpetas en busca de estos archivos de forma recursiva. En ellos lista los layouts y sus
propriedades. El resultado es un archivo de texto guardado en la carpeta elegida, con la
información.
Artículos importantes para aprender:
1. DBDictionary
2. FileInfo
3. PropertyInfo
4. GetType
5. Reflection
6. DirectoryInfo
Figura 188 - Listar los Layouts de los archivos de una pasta (archivo 12)
Ejercicios:
1) Copie solo los comentarios del código al bloc de notas. Trata de entender la receta
del pastel.
2) Lea solo la propriedad “PlotConfigurationName” del layout. Es el nombre de la
PC3 (plumas) que el layout utiliza.
3) Suponga que desea cambiar a “test.pc3”. Guarde los archivos en la misma
carpeta, pero con un nombre diferente.
Objetos
En informática, un objeto es una referencia a una ubicación de memoria que tiene un
valor. Un objeto puede ser una variable, función o estructura de datos. En la
programación orientada a objetos, la palabra objetos se refiere a una instancia de
una clase.
Ya henos utilizado varias clases: Layout, Database, BlockTableRecord.
ObjectID
En la base de datos de AutoCAD, todos los objetos tienen un OBJECTID. Ya lo henos
visto. Incluso dije que él es como su NIF.
DBObject
Clase PADRE, que abstrae los métodos que son comunes a todos los objetos hijos,
dibujables o no: ENTITY, LAYER, LAYOUT, TEXTSTYLE
Entity
Objetos que son dibujables: LINE, DBTEXT, MTEXT, POLYLINE, POINT etc.
Si repara la sintaxis del método GetObject de la clase Transaction, verá que la salida es
del tipo DBObject. Entonces tenemos que hacer CAST (guarde esta palabra) o la
conversión al tipo de objeto que queremos, para acceder a las propriedades que se
ajustan a ese tipo.
Leer propriedades
Siempre que solo desee leer las propriedades de un objeto, elija abrirlo como de solo
lectura. esto puede ahorrarte dolores de cabeza durante la ejecución.
Leer un objeto de solo lectura significa hacer: tr.GetObject(res.ObjectId, OpenMode.ForRead)
Figura 189 - Leer propriedades (archivo 13)
Ejecuta el código. Espero que le des esto:
Figura 190 - Primero Error Fatal
Mira el código. Te diré... TRY en la línea 25 no pudo evitar el error fatal anterior.
Acostúmbrese a ver esto o preste mucha atención cuando use GETOBJECT.
El error eNotOpenForWrite ocurrirá cada vez que intente MODIFICAR una propiedad
de un objeto que está abierto SOLO LEER. En el caso de que intenté cambiar el
COLORINDEX a rojo (1).
Escribir propriedades
Para ESCRIBIR propriedades en un DBOJECT, primero debe PERMITIR esto. Esto
significa que lo abrió para leer y escribir explícitamente, o UPGRADEOPEN, como en
la línea 40 del código.
Entonces haga:
Dim dboj As DBObject = tr.GetObject(res.ObjectId, OpenMode.ForWrite)
O:
Dim dboj As DBObject = tr.GetObject(res.ObjectId, OpenMode.ForRead)
dboj.UpgradeOpen()
ejercicios:
1) Cambie la línea 17 del código a la primera opción y ejecute el programa.
2) Ejecute el programa y haga clic en una línea
Espero que le des esto:
Figura 191 - Error no FATAL, haga clic DETAILS
Es impresionante la cantidad de veces que recibo prints con esta pantalla y la persona no
hace clic en DETAILS. Así que, por favor HAGAN CLIC.
Nociones de reflexión
Listar todas las propriedades
De hecho, ya he mostrado un poco de esto en el código que lee las propriedades de los
layouts. Adaptemos el SNIPPET (¡mantén esta palabra!)
Figura 192 – no olvides importar Systen.Reflection (archivo 13)
Figura 193 - Código que enumera las propriedades (archivo 14)
¿Qué, no funciono? ¡Felicitaciones! Dejé una falla en el código a propósito. Encuéntralo
y arréglalo; de lo contrario, el comando LISTAROBJETOS no funcionará.
Figura 194 -¡ No funcionó!
Listar todos los atributos
Esta parte me fue útil cuando quería aprender cómo ingresarun nombre para la
propiedad y hacerlo más explicativo para el usuario. Ver la página siguiente.
Figura 195 - Listado de atributos de las propriedades de un objeto (archivo 15)
Bien, sé que eso no dice mucho, pero anota estas palabras:
1) TypeDescriptor
2) PropertyDescriptor
3) DisplayName
4) Description
5) Converter
Mire el resultado del programa al seleccionar un círculo:
Figura 196 - Listado de algunos atributos de las propriedades
Decórenos un poco, creando un pequeño FORM, que nos muestra las propriedades del
objeto seleccionado:
Figura 197 - Form, TabControl, PropertyGrid (archivo 16)
Figura 198 - Comando DOTNETPROPERTIES
Palabras para guardar:
AcadObject (linha 41)
PropertyGrid, TabControl, Form
Uso mucho PROPERTYGRID. Y para usarlo, necesito saber cómo agregar:
1) Category
2) DisplayName
3) Description
4) TypeEditor
5) TypeConverter
Figura 199 – PropertyGrid
Veremos más sobre este y otros en las clases de Windows.Forms
Mira, sé que hay WPF. No lo uso porque no tengo que hacerlo. Si no sabe qué es, siga:
https://docs.microsoft.com/pt-br/visualstudio/designers/getting-started-with-wpf?
view=vs-2019
https://docs.microsoft.com/pt-br/visualstudio/designers/getting-started-with-wpf?view=vs-2019
Figura 200 - ¿A dónde ir?
¿Se puede hacer esto con AutoLISP y DCL?
Figura 201 - ¡Desafío aceptado!
Figura 202 – Imitación de PropertyGrid con DCL
Mira, no es hermoso ni práctico, solo lo hice para mostrar que puedes imitar. Vea que
puse el DisplayName y la Description. Un poco más de creatividad y puedes poner
TypeEditor.
Creando objetos
Ya henos creado puntos, Cogo Points, e incluso una alineación en otro diseño, ¿me
crees? Algunos elementos básicos:
Figura 203 - Dibujar objetos (archivo 17)
Tenga en cuenta que comprimí el código en la línea 24. Dado que esta pantalla no se
ajusta a todo, veamos las partes. Vea que introduje una estructura de programación más:
el Select Case (Switch).
También agregue un método interesante:
doc.TransactionManager.QueueForGraphicsFlush()
Él actualiza la pantalla en tiempo de ejecución (Ejercicio: ¿Qué significa eso?), de lo
contrario, solo se actualizará cuando finalice el comando.
Punto
Figura 204 - Crear Punto (archivo 17)
Ya habíamos hecho esto, incluso con más opciones.
Ejercicio:
Explique la instrucción WITH que aparece al inicializar una nueva instancia de la clase
DBPOINT
Línea
Figura 205 - Crear Línea (archivo 17)
La línea también es una ENTITY. Simple para dibujar. ¿Lo complicamos un poco?
Ejercicio:
Agregue una línea discontinua en el segundo GETPOINT, utilizando la primera
respuesta como BASEPOINT
Polilínea
Figura 206 - Crear Polilínea (archivo 17)
Tenga en cuenta que la polilínea necesita más de dos puntos para “aparecer”
efectivamente en la pantalla.
Ejercicio:
1. Investigue la sintaxis del método ADDVERTEXAT en la línea 81 y describa
los argumentos.
2. Agregue preguntas al usuario donde pueda responder con valores para los
últimos tres argumentos.
Texto
Figura 207 - Crear texto simple (archivo 17)
El texto no tiene mucho secreto.
Ejercicio:
1. Identificar las propriedades editables de un TEXT. Consejo: use el programa
DOTNETPROPERTIES que creamos anteriormente.
2. Cree una pregunta para que el usuario elija la alineación del texto (middle
center, top left etc.)
Bloque
Figura 208 - Crear bloque (archivo 17)
Para crear un bloque, usamos la clase BLOCKREFERENCE, pero para eso, necesitamos
del OBJECTID del BLOCKTABLERECORD que contiene la definición del bloque. En
el código anterior, te muestro cómo CREAR un BLOCKTABLERECORD ANÓNIMO
y dibujar un círculo y un punto en él.
Ejercicio:
1. Busque el método NEW de la clase BLOCKREFERENCE y explique los
argumentos.
2. Sabiendo que la lista de bloques disponibles está en la BLOCKTABLE del
documento, cree un LOOPING que muestre los nombres disponibles y luego
pregunte al usuario si desea insertar uno de la lista, o si tiene la intención de
crear el BLOCKTABLERECORD.
3. Si elige crear, solicite el nombre del bloque. Comprueba que ya no existe.
4. Si ya existe, pregunte si desea sobrescribir.
5. Si lo desea abra el BLOCKTABLERECORD y elimine los elementos
existentes antes de dibujar nuevos elementos dentro de él.
Nociones de ergonomía del software
No hay una manera fácil de enseñar esto, así que lea cuidadosamente:
a) Definición
Ciencia que estudia la comodidad, uso, organización y documentación del software;
tiene como objetivo facilitar y optimizar el trabajo del usuario en la computadora.
Propone patrones de
Presentación de pantallas
diálogos
herramientas de trabajo
menús
documentación
técnicas de archivos
técnicas de optimización
ayuda (help)
b) Ventajas:
atracción hombre-máquina
programas mejor documentados
costos de mantenimiento reducidos
software más eficiente
software con funciones más potentes
facilidad de aprendizaje
reducción de las perturbaciones psicológicas del usuario en relación con la
computadora
c) Desventajas:
esfuerzo adicional en desarrollo de software.
d) Principios Básicos:
1 – Esfuerzo mínimo del Usuario:
el usuario debe realizar solo aquellas funciones que son absolutamente
esenciales y que el sistema no puede realizar.
Transferir una función al software incluso si el usuario puede realizarla.
No repita el trabajo realizado:
Los datos solo se deben alimentar una vez; el programa debe ser reutilizable,
así como rutinas, consultas, comandos, definiciones de archivos, etc.
El trabajo no productivo debe ser eliminado. Ej: la fecha debe ser
proporcionada por el sistema la; "Recovery" debe ser automática.
Facilitar el acceso a la información sobre el sistema:
Uso de rutinas de ayuda "help": documentación escrita completa, pero solo
suficiente y necesaria para la tarea del usuario.
Las instrucciones del sistema deben ser directas y específicas, que no
requieren interpretación (agregar números, descifrar un código, etc.)
eliminar el trabajo duplicado: todo el trabajo debe poder realizarse utilizando
el sistema, sin etapas burocráticas intermedias.
2 - Memoria Mínima de usuario:
el usuario debe memorizar lo menos posible.
el aprendizaje del sistema debe ser un proceso jerárquico e incremental.
El usuario solo debería tener que aprender lo esencial para su tarea.
Aprender una pequeña parte del sistema, debe recompensar al usuario con la
capacidad de hacer un trabajo real, incluso si es limitado.
El usuario no debería tener que aprender terminología no relacionada con la
tarea: las instrucciones del sistema o las comunicaciones deben realizarse en
el lenguaje natural de la tarea.
La terminología debe ser coherente en todo el software con el que
interactuará el usuario.
Los comandos de usuario deben tener una sintaxis simple y natural, y no
deben ser complejos y compuestos.
3 - Frustración Mínima:
Evitar demoras en la realización de tareas.
Cuando se utilizan menús u otras técnicas equivalentes, el sistema debe
permitir al usuario experimentado vaya directo a la tarea deseada.
La organización jerárquica de los menús o técnicas equivalentes debe ser tal
que el usuario no tenga que realizar ni omitir explícitamente tareas
innecesarias.
La orientación o help debe estar disponible de manera consistente en todo el
sistema.
Recordar acciones pasadas: en caso de interrupción de una serie de pasos
interrelacionados. El sistema debe proporcionar (si se solicita) un resumen
de las acciones tomadas antes de la interrupción.
Elección de actividad: el usuario debe poder interrumpir o finalizar cualquier
actividad en cualquier momento y seleccionar otra.
Después de terminar la segunda actividad, el sistema debe permitir reanudar
la actividad interrumpida en el punto de interrupción, en una acción simple,
como presionar una tecla (o equivalente)
Autoconfiguración y autoverificación: la instalación de un hardware o
software básico debe estar respaldada por técnicas de autoconfiguración y
autoverificación.
Se debe proporcionar orientación para cualquier acción cuyos resultados no
sean obvios.
4 – Maximiceel uso de patrones y hábitos:
Siempre use ciertas teclas para las mismas funciones.
Siempre coloque información similar en las mismas posiciones en la
pantalla.
Diseño de formato de pantalla consistente
La información devuelta al usuario como resultado de su acción, debe
ubicarse en el punto donde el usuario la espera: generalmente en la línea
siguiente.
Enfoque y terminología coherentes para todas las funciones del usuario.
Mecanografiar una carta en un procesador de textos debe ser lo más cercano
posible q la misma actividad en la máquina de escribir. Esto implica un
mínimo de reentrenamiento.
5 - Máxima tolerancia para diferencias humanas:
Los sistemas deben almacenar perfiles sobre cómo cada usuario prefiere
realizar tareas.
Estos perfiles deben condicionar el sistema a los patrones de trabajo del
usuario cuando el usuario inicia una sesión.
Uso de métodos visuales y audibles para atraer la atención.
Uso de formas gráficas o de dibujo para ayudar a la comunicación visual.
aceptar enfoques “procedurales” y "no procedurales" para las técnicas de
orientación y tareas compleja, como el desarrollo de consultas.
6 - Máxima tolerancia a los cambios ambientales:
el sistema debe admitir cambios en el entorno de hardware/software con un
esfuerzo mínimo del usuario.
El sistema debe reconfigurarse automáticamente en el caso de agregar o
quitar unidades de computadora (excepto en el caso de dispositivos de
hardware críticos, como la CPU (UPC) o la unidad de disco donde reside el
software).
Los programas de aplicación no deberían necesitar ser recompilados para
cambios en la base de datos, ya sea contenido, método de acceso o ubicación
del archivo, que no cambien la lógica de procesamiento para el programa de
aplicación en cuestión.
Los programas de aplicación deben ser compatibles y transportables entre
diferentes modelos de computadora. Tenga cuidado con la exclusividad de
cierto modelo/ marca de computadora, ya que causará problemas durante el
transporte.
La asignación de espacio debe ser automática, sin necesidad de intervención
o acción del usuario.
7 - Notificación inmediata de los problemas:
Notificar al usuario de un problema tan pronto como se detecte
Notificar posibles problemas antes de que ocurran.
Antes del cambio permanente en la información almacenada, el sistema debe
mostrar los resultados del cambio y requerir la aprobación del usuario.
La sintaxis y la terminología del comando deben editarse de forma
interactiva con una respuesta inmediata que indique el error y la acción
correctiva.
El usuario debe ser notificado cuando haya alcanzado un porcentaje
substancial de uso del espacio (por ejemplo 80%) para que el usuario pueda
tomar medidas preventivas por adelantado.
La edición de la entrada debe ser interactiva, indicando errores y
proporcionado orientación y medios para corrección inmediata. Después de
la corrección, el sistema debe volver al punto donde fue interrumpido.
8 – Máximo control de tareas por parte del usuario:
El usuario debe controlar y administrar la secuencia de trabajo siempre que
no haya actividades que requieran una secuencia.
El usuario debe poder modificar las propriedades de procesamiento.
La secuencia de impresión de cartas o informes debe ser dada por el usuario.
El sistema debería permitir al usuario definir sus propios nombres para
funciones, comandos o datos, y debería “recordar” estas definiciones para su
uso futuro.
El usuario debe poder establecer opciones "default" y el sistema debe
“recordar” estas configuraciones en el futuro.
El usuario debe poder almacenar y recuperar información de manera
consistente, siendo a él transparente los problemas de localización y
almacenamiento físicos.
9 – Máximo suporte para tareas:
El usuario no debería necesitar otros recursos para realizar la tarea.
La documentación de la tarea debe estar "online", estructurada
jerárquicamente y bien indexada.
Un usuario debe poder comunicarse con otros a través de las instalaciones
del sistema.
El usuario debe tener acceso a métodos “personalizados” para obtener
información, como filtros para generar informes.
En resumen: confíe en el usuario lo menos posible. No sabe lo que pasa por su cabeza.
Figura 209 - https://vidadesuporte.com.br/
Nociones de Windows.Forms
Ya henos creado un pequeño WINDOWS FORM en el programa
DOTNETPROPERTIES utilizando las clases FORM, TABCONTROL y
PROPERTYGRID.
Por supuesto, no siempre lo haremos de esta manera, porque los FORMS más complejos
“complicarían” mucho la imaginación.
Figura 210 - ¡No estás muerto cuando luchas!
Crear Form
Créenos nuestros FORMS visualmente, así que comencemos con eso. En Visual Studio
(en C# es lo mismo), haga clic en:
Figura 211 - Insertar WINDOWS FORMS
Tenga en cuenta que cuando inserte WINDOWS FORMS, tendremos un rectángulo
(¿WINDOWS?) para que podamos jugar con él.
Ah, ¿Ya sabes cómo programar y prefieres usar WPF (Windows Presentation
Foundation)?
Figura 212 - Windows Forms X WPF
Si cumple el objetivo: proporciona una pantalla hermosa, funcional y auto explicativa
para el usuario, vale la pena.
Diagramación
De la ayuda de Microsoft:
https://docs.microsoft.com/pt-br/dotnet/framework/winforms/
dado que los formularios son la unidad base de su aplicación, es esencial dedicar algo de
planificación a sus funciones y diseño. Un formulario es básicamente una pantalla en
blanco que usted, como desarrollador, mejora con controles para crear una interfaz de
usuario y con códigos para manipular dados. Con ese fin, Visual Studio proporciona un
entorno de desarrollo integrado (IDE) para ayudar a escribir códigos, así como un
conjunto sofisticado de controles escritoscon.NET Framework. Al completar la
funcionalidad de estos controles con su código, puede desarrollar las soluciones que
necesita de forma rápida y sencilla.
Comencemos con la pantalla en blanco entonces:
https://docs.microsoft.com/pt-br/dotnet/framework/winforms/
Figura 213 - Pantalla principal de Windows Forms
Tres cosas a tener cuenta:
1) La pantalla FORM
2) La cajá de herramientas (o controles que podrá insertar, si no aparece, menú Ver /
caja de herramientas, en inglés: ToolBox)
3) La tabla de propriedades (si no se muestra, menú Ver / ventana de Propriedades)
En general, todos los controles “dibujables” son rectángulos con algo dibujado dentro:
Figura 214 - Algunos controles de la caja de herramientas
Tenga en cuenta que cuando hace clic en el control en la cajá de herramientas, Visual
Studio asume que desea insértalo en WINDOWS FORMS. Luego haga clic en el área
FORM y vea el control insertado.
Luego, haga clic en el control que acaba de insertar en el área FORM y vea la tabla de
propriedades.
Tenga en cuenta que es posible asignar un nombre al control, es posible definir colores,
fuentes y otras propriedades. No voy a explicar control por control ni hablar de sus
propriedades. Simplemente haga clic en el control y mire las propriedades y en la parte
inferior mire la descripción:
Figura 215 - Cuadro de Propriedades
En el ejemplo, hice clic en el control PROPERTYGRID (¡realmente me gusta!). Ver sus
propriedades arriba.
Controles
¿Se te ocurrió la idea de los controles? ¿estás convencido que son “cajas” que insertas en
tu FORM para hacer algo?
¿Notaste que estas cajas son CLASES? ¿Y que, al insertarlos en el FORM, los
INSTANTÓ? ¿Pero donde sucedió esto? Aquí, en el método InitializeComponent:
Figura 216 – InitializeComponent
Tenga en cuenta que, en general, no debería preocuparse por este método
InitializeComponent, ya que es creado automáticamente por el DESIGNER de Visual
Studio y digamos que es algo temperamental con las modificaciones de este método.
Siempre realice modificaciones en la pantalla de edición de FORM y no en el código:
Figura 217 - ¡no te muevas aquí si no sabes lo que estás haciendo!
Vea que cada control necesita un NEW para ser creado. Desplácese el código a la parte
donde se inicializa cada control.
Observe que se asigna un nombre, posición, fuente y cualquier otro: propriedades
requeridas.Figura 218 - Inicialización de controles
Reforzando: ¡NO EDITE NADA AQUÍ SI NO SABE LO QUE ESTÁ HACIENDO!
Concéntrese en hacer que la pantalla sea hermosa y útil:
Figura 219 - TreeView, PropertyGrid y DataGridView
Ejercicio:
Dibuja esto FORM:
Figura 220 - FORM para crear una alineación
¿Muy complicado?
Ver los controles utilizados:
Figura 221 - Controles usados
PANEL: use para “espaciar” los controles de organización, por ejemplo, para alinearlos
horizontalmente, como el TEXTBOX del nombre de la alienación con un botón en el
costado. TEXTBOX y BUTTON está dentro de un PANEL.
COMBOBOX: muestra una lista de opciones. En el ejemplo, muestra los tipos de
alineación (centerline por ejemplo)
BUTTON: todos los botones, con imagen de fondo o no (ver botón OK, no tiene imagen
de fondo)
TABCONTROL: para elegir propriedades generales (General) y criterios de diseño
(Design Criteria)
LABEL: se usa para escribir algunos textos dentro de la pantalla.
TEXTBOX: campos de onde el usuario puede escribir algo
El resto es dibujar los botones en PAINTBRUSH y modificar las propriedades de los
controles utilizando la tabla de propriedades.
Ejercicio: establezca la propiedad DOCK de los controles. Varíe su valor y observe los
cambios en la pantalla.
Eventos
Los eventos son métodos que se activan mediante alguna acción, generalmente por parte
del usuario. En el contexto de FORM, se activa un evento CLIC cada vez que el usuario
CLICA algo, ya sea un botón, una lista o incluso un panel. Pero vea: el hecho de que el
evento se active no significa que algo tenga que suceder.
Otro ejemplo, cuando el usuario elige una opción de tipo de alineación en COMBOBOX,
este control genera un evento SeletedltenChanged.
Uno más: al escribir cualquier cosa en un TEXTBOX, se desencadena el evento
TextChanged.
Para ser interesante, creemos un programa que cree PROFILES FROM SURFACE en
todas las alineaciones seleccionadas. ¡Cualquier similitud con MPERFIL no es una mera
coincidencia!
Vea:
Figura 222 – MPERFIL (archivo 18)
Agregue GROUPBOX para escribir los nombres de campo (Offset, Prefix, Label Set,
Superface, Layer y style).
Ahora piense: “NO CONFÍE EN EL USUARIO”.”.
Ver el campo OFFSET. Se le debe dar un valor NUMÉRICO, pero créanme, el usuario
escribirá CUALQUIER COSA allí ¡incluso NADA! Entonces necesitas validar lo que
escribe allí, ¿estás de acuerdo?
Luego, usted decide, puede hacer que el campo se vuelva roja si escribe algo
inapropiado. Puede deshabilitar el botón OK, te todos modos, ¡use la creatividad!
Con el editor FORM abierto, haga doble clic en el control TEXTBOX. Vea que se abre
el editor de código:
Figura 223 - Evento TextChanged (archivo 18)
Pase el mouse sobre la palabra TextChanged. Ver el globo explicativo
Ahora es hacer lo que se ha propuesto. Valide el valor ingresado para que sea un número
válido.
¿Y si no es así? Adoptaremos un valor predeterminado.
Figura 224- Validación de un campo TEXTBOX (archivo 18)
Analiza el código. Necesitamos que el valor de OFFSET sea un número REAL. Al
mostrar el FORM, este valor debe llenar el campo OFFSET. Cuando el usuario escribe
algo en el campo, debe validarse y si escribe algo que no se puede convertir en un
número, el valor de campo se restablece.
Tenga en cuenta que el proceso de validación puede necesitar reescribir el valor original
de la variable OFFSET. Si esto ocurre, debe estar preparado para deshabilitar el evento
TEXTCHANGED antes de reescribir el valor, ya que esto desencadenará un nuevo
evento TEXTCHANGED. Dependiendo de cómo escriba el código, esto puede
convertirse en un RECURSO y bloquear el programa por desbordamiento de pila
(http://ptcomputador.com/P/computer-programming-languages/88738.html).
http://ptcomputador.com/P/computer-programming-languages/88738.html
¿Qué pasa con el PREFIJO? Bueno, él es un STRING y se usará para nombrar PERFIL.
Tenga en cuenta que Civil 3D tiene algunas reglas de nomenclatura:
Figura 225 - Validar nombres
Ejercicio:
Cree un evento para el campo PREFIJO, que verifica si el usuario escribió algunos de
estos caracteres y, de ser así, reemplácelo con un espacio o “_”.
Ok / Cancel / Help
¿Leíste ese texto sobre ergonomía al comienzo de la clase? Por supuesto no. Bueno,
léelo y léelo, léelo de nuevo.
Cada vez que cree un FORM, proporcione al usuario una forma para que diga:
“Sí, es cierto, ¡puedes hacerlo!”
“No, no importa”
“Dios mío, ¿qué es esto?”
Son los botones OK, CANCEL e HELP.
Observe que en FORM ya tiene estos botones. Veamos
Figura 226 - botón OK (archivo 18)
Tenga en cuenta que puede crear una acción para el botón OK, pero la forma más
sencilla es decirle a FORM cuál es el botón OK. ? Esto también se aplica al
botón CANCEL:
Figura 227 - Botón CANCELAR (archivo 18)
Y el botón AYUDA (help)
Ente no tiene forma, tiene que definir una acción:
Figura 228 - Botón AYUDA (archivo 18)
Un método más para recordar:
Systen.Windows.Forms.Help.ShowHelp
Poniendo todo junto: Comando CRIARPERFIS
Mostré una de sus SOBRECARGAS (investiga qué método es la sobrecarga).
¿Qué pasa con los otros campos?
Ah, ¡ahora sí! “Juguemos” con Civil 3D para completar los campos Layer, Estilo,
LabelSet y superficie. Primero, modifiquemos el método NEW e inserte el NameSpace
que usarenos:
Figura 229 - Sub New (archivo 18)
Esta modificación del método NEW es necesaria porque entre una llamada y otra del
comando que estamos creando, el usuario puede haber creado o eliminado alguna layer,
superficie, estilo o labelset.
Vea la estructura general de la clase FORMOPCOES (nuestro formulario):
Figura 230 - Método insertado: PreencheCampos (archivo 18)
Se llama al método PreencheCampos() cuando activamos el comando
CREARPERFiLES, porque, como se indicó, el usuario puede haber eliminado o creado
estilos, etc. Veamos #comofas para completar los campos:
Figura 231 - Método PreencheCampos() (archivo 18)
¿Recuerda la orientación a objetos? Por eso puedo iterar con un FOR en la colección
civilDoc.Styles.ProfileStyles
Ejercicios:
¿Por qué aparece el método CLEAR (líneas 61, 69, 76 y 83) antes de completar las
listas?
Ya tenemos un evento que evalúa la acción del usuario al cambiar el valor de
compensación. Veamos qué sucede si elige algo en COMBOBOX:
Figura 232 - Eventos COMBOBOX (archivo 18)
Ver que yo era más “económico”. En un SUB pongo todos los eventos COMBOBOX.
Ejercicio: separe cada COMBOBOX con su propio evento.
Ahora: veamos el método CRIARPERFIS, ya como un comando:
Figura 233 - Comando CRIARPERFIS (archivo 18)
Ejercicio:
1) Ejecute el comando al menos dos veces y compruebe que se produce un error.
2) Corrija este error.
3) “Olvidar” para completar cualquier campo. Ejecuta el programa. Da error al crear
el perfil. Implemente una verificación de los campos para ver si todo están
correctamente llenado.
PropertyGrid
Ya henos creado un FORM, aunque sea simple. utilizando PropertyGrid.
Bueno, agreguemos algunos elementos geniales, los ATRIBUTOS, ¿los recuerdas?
1) Category Attribute
2) DisplayName Attribute
3) Description Attribute
4) TypeEditor
5) TypeConverter
Primero, imaginemos un comando que necesita mucha información. Para hacerlo legal,
que esté relacionado con el Civil 3D. imagine esto:
Tiene un dibujo de una encuesta y necesita CONECTAR LOS PUNTOS. Tiene dos
formas de salir: hágalo manualmente o cree un programa que resuelva gran parte de su
dilema.
Primero, imaginemos el flujo del programa:
1) Comenzar
2) Solicitar selección de puntos.
3) Ofrezca opciones sobre cómo conectar estos puntos.
4) Conectar los puntos
5) Finalizar
Para comenzar, cree el comando. Ordenar la selección con un filtro, ya lo hicimos, es
simple. Opciones de oferta, ya lo hicimos usando la línea de comando. Pero espera, dije
que podemos hacerlo en un FORM. Cuando tenga muchas preguntas, es mejor hacerlo
en un FORM, con opciones predeterminadas. Permanecer en la línea de comando tiende
a ser tedioso. Use los puntos y termina. El acabado es fácil: COMMIT.
Trabajamos en el interfaz(FORM, o MOCKUP):
Figura 234 - Programa LIGAR PUNTOS (archivo 19)
¿Qué tal? ¿Se ve bien verlo?
¿Ves el botón ( ) en el campo de distancia?
¿Ves que la tabla en la parte inferior da el nombre de la propiedad con una descripción
larga?
¿Ves los textos en NEGRITA?
Category
En la imagen anterior, las palabras son:
1) Buscar
2) Identificación
3) Dibujo
Use para categorizar propriedades. Imagine que tiene varios y quiere organizarse en
categorías. Por lo tanto, puede y quiere organizarse en categorías. Por lo tanto, puede
comprimir categorías que no modifica con frecuencia, por ejemplo (consulte
PROPERTIES de AutoCAD)
DisplayName
1) Delta
2) Diferencia
3) Layer
4) Prever serrado
5) Descripción para filtrar
Tome el ejemplo de la variable “descripción para filtrar”. No puede definir un nombre de
variable.
Para esto se usa DisplayName: traduce el nombre de la variable dentro del código a un
nombre fácil de usar.
Description
Esa enorme frase que aparece en el cuadro sobre los botones OK, CANCEL e HELP.
Proporciona una descripción más detalla de lo que es la variable.
Veamos en el código cómo colocamos estos atributos:
Figura 235 – uso de los atributos en las propriedades de la clase OPCOES (archivo 19)
Tenga en cuenta que el usuario no necesita SABER que las clases, Opciones,
EditaDistancia, LayerConverter y de enumerador Ordenación existen, por lo que dejé
como PRIVATE dentro da clase LIGARPONTOS:
Figura 236 - Estructura inicial de la clase LIGARPONTOS (archivo 19)
Ahor, ¿por qué necesitamos estas “clase auxiliares”
TypeEditor
Vea la figura, en la línea 126:
Figura 237 – UITypeEditor (archivo 19)
El atributo “Editor” que agregue a la propiedad DIST ( “Distancia máxima” aparece para
el usuario). Agrega este botón:
Figura 238 – Botón para editar la distancia usando GetDistance (archivo 19)
Cuando hace clic en este botón ( ) el método EditValue (línea 34):
Figura 239 - Método EditValue sobrescrito de la clase UITypeEditor (archivo 19)
La clase UITYPEEDITOR es la que implementa la definición del atributo EDITOR que
agregué en la clase OPCIONES
Conceptos que utilicé: POLIFORMISMO, SOBRECARGA, HERANCIA. ¿Recuerda la
orientación a objetos? ¡Si ¡
Por lo demás, necesito esta clase para dibujar el botón ( ). Hago esto en la línea 30 de
la imagen de arriba, devolviendo UITypeEditorEditStyle.Modal.
Y obviamente, sobrecargar el método EDITVALUE en la línea 34. Hay un error en este
código. Me tomó años corregirlo. Intente maximizar la pantalla del programa y haga clic
para editar.
TypeConverter
TypeConverter es responsable de mostrar los valores al usuario, en el ejemplo, la clase
OPCOES tiene una propiedad que menciona la LAYER que se utilizará para dibujar las
líneas. Pues bien. Me refiero a este layer por su OBJECTID y no por su NOMBRE. 
¡Cambiará el nombre del layer! ¡Nunca confíes en el usuario!
Tenga en cuenta que O TypeConverter es un atributo, que sobrecargo varios métodos:
Figura 240 - LayerConverter: hereda y sobrecarga métodos TypeConverter (archivo 19)
Tenga en cuenta que, si necesito agregar más propriedades relacionadas con LAYER,
solo necesito agregar TypeConverter, como en este extracto:
Figura 241 – Uso de LayerConverter (archivo 19)
Y el efecto de esto:
Figura 242 - Lista de layers (archivo 19)
¿Ver la lista de layers? Ahora el usuario elige de la lista en lugar de escribir. Tiene
mejores soluciones. Civil 3D implementa un pequeño FORM que permite EDITAR,
CREAR layers. Solo ten imaginación.
Mostrar esta lista impide que el amigo escriba el nombre del layer incorrecto.
Proporciona la posibilidad de cambiar el nombre del layer (ya que no cambia el
OBJECTID), no permite crear layers cuando solo debe usar la lista.
Consulte las explicaciones de cada método anulado para obtener más detalles.
Ahora pregunto ¿necesitas todo esto?
Eso es solo la punta del iceberg. ¿Qué pasa si quieres portar tu programa a otros
idiomas? ¿Compilar todo con otros Strings? Consejo: utilice derivar las clases
DisplayName, Category y Description y use RESOURCE LANGUAGE en los idiomas
que desee.
Figura 243 - Punta del Iceberg
Juntando todo: Método LigaOsPontos()
Figura 244 - Método interno: conectar los puntos (archivo 19)
Figura 245 – Convertir nombre en número (archivo 19)
Figura 246 - Filtrar puntos pares e impares (archivo 19)
Figura 247 - Y finalmente, dibuja la línea (archivo 19)
Corriendo:
Figura 248 – Suponiendo que tiene los puntos en el borde de una carretera (archivo 19)
Figura 249 - Resultado de puntos conectados (archivo 19)
Desafío
En SOLO 280 líneas vimos Clase. Atributo, Herencia, Sobrecarga, Windos Forms, línea
de comando, Typeditor, Typeconverter, Category, Displayname, Description, base de
datos de AutoCAD, base de datos de Civil 3D, Ergonomía de software, Public/Private ¡y
ni siquiera agregamos una acción para el botón HELP!!!
Sí, sé que el “algoritmo” de predicción de cerrillado está lejos de ser ideal, ya que solo
toma puntos pares e impares de una lista ordenada.
Después procesar las líneas creadas identificando situaciones así:
Figura 250 – Las líneas se cruzan
Ver, con este enfoque, necesitamos almacenar las líneas y hacer un looping que pruebe
cada línea con las otras y, en caso de cruzar, descruzar. La situación anterior ocurre
porque el algoritmo de ordenación consideraba solo la ordenada X y, por lo tanto, al
elegir puntos pares e impares, se mezclan en el eje Y.
Allí vera otro concepto de programación: COMPLEXIDADE DE TENPO
(https://pt.wikipedia.org/wiki/Complexidade_de_tenpo)
Si dibuja 1000 líneas, tendrá una complejidad de O(n²/2), es decir, necesitará
(aproximadamente) 1000 x 1000 / 2 pruebas. ¿T e das cuenta de cuánto tiempo puedo
llevar esto?
Habría clases y clases hablando sobre algoritmos y sus complejidades. Yo mismo estudié
esto durante un semestre completo en el curso de Informática.
¡El propósito de este curso NO ES TAN AMBICIOSO!
Ejercicios:
1) Adapte el programa para almacenar las líneas dibujadas cuando necesite
predecir serrado.
2) Cree un looping que pruebe si las líneas se cruzan. Si se cruzan, corríjalas
y salta a la siguiente iteración.
La solución está en el archivo del proyecto. Si no puedes imaginar cómo resolverlo.
https://pt.wikipedia.org/wiki/Complexidade_de_tempo
TreeView
Muestra una colección jerárquica de elementos etiquetados, cada uno representado por
un TreeNode.
https://docs.microsoft.com/pt-br/dotnet/api/systen.windows.forms.TreeView?
view=netframework-4.8
En Civil 3D, el TREEVIEW más famoso está en Prospector:
Figura 251 - TreeView de Prospector
Después lo de Settings. Bueno, puedes entender, ¿Verdad?
TreeView es un control muy simple para trabajar. Básicamente es una lista de nodos que
tiene varias propiedades y una de ellas es una lista de nodos.
El resto es “decorarlo” para dibujar los iconos correctos y tener algunos eventos que
pueden ocurrir al hacer clic en el nodo, al expandir, comprimir, etc.
Si tiene una buena idea para usarlo, úselo, ¡tu programa será genial!
https://docs.microsoft.com/pt-br/dotnet/api/system.windows.forms.treeview?view=netframework-4.8
Pero tenga cuidado, puede ser muy lento si está trabajando con una gran cantidad de
datos y desea cargarlos todos a la vez. Un ejemplo: hace dos años, creé un pequeño
programa para visualizar SLIDES, que son “casi” archivos vectoriales creados por
AutoCAD para ser utilizados en DCL. Me imagino que ya has visto esta imagen si usaste
EXPGE:
Figura 252 - Slide del mapa Mundial utilizando en EXPGE
El mapa del mundo es un SLIDE.
Figura 253 – Uso de TREEVIEW en el visualizador Slide
El programa mencionado anteriormente, busca en la lista de DRIVES y llena
TREEVIEW con los nombres de estas unidades. Al hacer clic en cada subnodo, se abre y
muestra sus carpetas. Al hacer clic en cada subnodo, se abre y cambia sus carpetas.
Bueno, hablando recursivamente, hacer esta operación en TODA la computadora sería
muy estúpido. Llevaría mucho tiempo, incluso horas.
Para resolver esto, incluso erasimple usar eventos:
Figura 254 - Evento BeforeExpand
Vea, un pequeño truco: al hacer clic en el botón ( ) para expandir un nodo, antes de
que se actualice la pantalla, le digo al programa que “repuebla” el nodo si es un nodo
(carpeta) en expansión.
En la siguiente imagen, llamo la atención sobre la clase IMAGELIST. ¿Notó que el
programa tiene iconos de carpetas y unidades en TreeView? Para hacer estos íconos,
necesitarás PaintBrush, ¿te imaginas?
Figura 255 – TreeView necesita una lista de imágenes si aparecen las imágenes
¿Ves el editor de colección de imágenes? Le permite agregar y eliminar imágenes. Gran
parte del tiempo dedicado al desarrollo de un programa está en la creación de la interfaz
de usuario. Dibujar iconos, por ejemplo, puede llevar horas…
Pero puede estar seguro: no es superfluo. ¡Se vende una hermosa interfaz!
Aquí se explica cómo agregar nodos a TREEVIEW:
Figura 256 – Inserción del nodo TREEVIEW
Mira qué interesante, aprendimos un método más: Directory.GetLogicalDrives. y
aprendimos a agregar nodos a TREEVIEW.
Ejercicios:
Inserte un TREEVIEW en el FORM y agregue nodos. A los nodos, agregues
nodos hijos
Vaya al código FORM y agregue eventos para cuando el usuario haga clic
en el nodo.
Use el editor de diseño FORM para “arreglar” su TREEVIEW:
Figura 257 - Uso del editor de Design de Form en TREEVIEW
Ejercicios:
1) Cree un comando dentro de la clase de este FORM para que podamos
llamarlo en la línea de comando AutoCAD
2) Al llamar al comando, haga que recorra el POINTGROUP S de un dibujo
y agregue un nodo para cada POINTGROUP
3) En cada nodo POINTGROUP, agregue nodos hijos para cada
COGOPOINT de POINTGROUP
4) En cada nodo COGOPOINT, agregue nodos para las coordenadas X, Y, Z
Figura 258 – Agregar nodos a TRREVIEW (archivo 20)
El resultado:
Figura 259 - resultado del comando LISTARPOINTGROUP S (archivo 20)
Otro ejemplo de TREEVIEW:
Figura 260 – Mas un ejemplo de TREEVIEW
Figura 261 – Imágenes dibujadas en PAINT
Para agregar imágenes a TREEVIEW, deben ser parte de su solución. Hacemos esto
agregando recursos a la solución.
Figura 262 – agregue recursos a la solución
DataGridView
Muestra datos en una cuadrícula personalizable.
https://docs.microsoft.com/pt-br/dotnet/api/systen.windows.forms.DataGridView?
view=netframework-4.8
DATAGRIDVIEW es una tabla. Con él podemos mostrar listas, matrices etc.
Hay muchas formas de trabajar con él. En general, necesitará una fuente de datos que
llene la tabla y posiblemente cree columnas e inserte filas
Figura 263 – varios controles en un FORM
Y mira qué genial, no tiene que ser solo celdas con textos escritos, hay varios tipos de
columnas:
https://docs.microsoft.com/pt-br/dotnet/api/system.windows.forms.datagridview?view=netframework-4.8
Figura 264 - Tipos estándar de columnas DATAGRIDVIEW
¿Qué pasa si te digo que puedes derivar un tipo de columna / celda para que pueda hacer
más cosas?
Figura 265 - Clase derivada de DataGridViewTextBoxCell
Para incluir un pequeño botón en una celda, deriva la clase DataGridViewTextBoxCell.
Ver que ella todavía escribe un texto, pero ahora incluye un botón. TypeConverter (¿lo
recuerdas?) para formatear el valor numérico de la apuesta al valor “StationFormat”!
Crear Columnas/líneas
Para crear columnas, use el editor de diseño FORM. Obviamente puedes hacer esto a
través del código:
Figura 266 - Insertar/Eliminar columnas en DataGridView (archivo 21)
Ejercicios:
1) Agregue un comando para mostrar el FORM anterior en AutoCAD
2) ¿Es posible agregar líneas en DATAGRIDVIEW ya en AutoCAD?
3) ¿Es incorrecta la línea 20 o es correcta?
4) La clase LíneaDatos se puede cambiar para mostrar, por ejemplo, el área,
el perímetro y el número de vértices de las Parcels. Modifícalos para
esto.
5) Modifique el comando para leer esta información de todas las PARCELS
en el dibujo.
Manipular Form
Ya henos visto cómo mostrar un FORM de manera MODAL. Ahora, ¿qué significa eso?
Significa que recibe el foco e interrumpe AutoCAD hasta que haga clic en OK o
CANCEL, es decir, hasta que dicho FORM se cierre. Cuando lo cierra, la ejecución
vuelve a AutoCAD:
Figura 267 - AutoCAD interrompido en la línea 318 (archivo 19)
Las acciones que realice en FORM no debería tener efecto en AutoCAD hasta que el
usuario salga de FORM. Si ha leído la sección de ergonomía del software, debe
comprender que al cerrar FORM con CANCEL, AutoCAD debe estar exactamente como
estaba antes de SHOWDIALOG. Entonces utilicé un método CLONE en la clase
Opciones. Por lo tanto, las opciones solo se cambian INCLUSO si el usuario hace clic en
OK.
¿Hay alguna manera de mostrar un FORM no MODAL?
Sí, pero esto es más adecuado para trabajar con PALLETSET (FORMS que se
ADAPTAN a la pantalla de AutoCAD, tales como Properties del AutoCAD o el Event
Viewer do Civil 3D).
interactúa con la línea de comando
Ya henos visto en PropertyGrid cómo interactuar con la línea de comando utilizando el
atributo TypeEditor.
Luego vienes y dices que no te caía bien que de todos modos lo encontraste difícil. Y
desea colgar los botones en los que hace clic y la acción que estaría en TypeEditor ahora
está dentro del FORM, como un evento de botón.
¿Está bien? Sí, sin problemas. Es cuestión de gustos. ¡Pero lea la parte de ergonomía
nuevamente!!!!
Ejercicios:
1. ¿Qué es TypeEditor?
2. ¿Qué significa decir que mostró una FORM MODAL?
¿Necesita algo especial para “chatear” con el usuario desde la línea de comandos cuando
tenemos un FORM? Sí, en teoría necesitas esto:
https://adndeVBlog.typepad.com/autocad/2012/05/taking-mouse-inputs-from-a-modal-
dialog-box.html
Figura 268 – UserInteraction
Pero si hace la prueba que he propuesto (maximice el FORM y luego haga clic en el
botón este UserInteraction VA A FALLAR).
https://adndevblog.typepad.com/autocad/2012/05/taking-mouse-inputs-from-a-modal-dialog-box.html
Figura 269 -UserInteraction VAI FALHAR
Windows
A lo largo de los ejemplos, mostré algunos controles útiles para “chatear” con Windows.
Básicamente necesitas recordar:
1. SaveFileDialog, para buscar un lugar para guardar
2. OpenFileDialog, para buscar un archivo para abrir
3. FolderBrowserDialog, para elegir una carpeta
Obviamente, deberá manipular los archivos. Estamos hablando de archivos CSV, TXT,
recuerde:
1. Systen.IO.StreamWriter, para escribir en el archivo
2. Systen.IO.StreamReader, para leer desde el archivo
3. Systen.IO.File.FileInfo, para información de archivo
4. Systen.IO.File.DirectoryInfo, para obtener información de la carpeta.
En los ejemplos que he mostrado, ya he usado los cuatro.
Cuando use los dos primeros, preste atención a la CODIFICACIÓN:
Figura 270 – recordar de la codificación: Systen.Text.Encoding (archivo 12)
La codificación controla cómo se lee/escribe la información. Si guarda texto que tiene
acentos, la cedilla codificada UTF8 (que no tiene estos caracteres) será un problema. ver
https://docs.microsoft.com/pt-br/dotnet/api/systen.text.encoding?view=netframework-4.8
Ejercicios:
Localice los programas de muestra que contienen los controles y las clases enumerados
https://docs.microsoft.com/pt-br/dotnet/api/system.text.encoding?view=netframework-4.8
anteriormente. Los usarás como ejemplo.
Excel
Ya henos hablado con el usuario desde la línea de comando. Ya henos intercambiado
información con Windows en un archivo TXT y henos buscado información a través de
FILEINFO y DIRECTORYINFO. Con eso, puedes hacer mucho.
Pero, por supuesto, no es suficiente. Necesitamos interactuar con EXCEL. Un ejemplo,
en las obras de saneamiento, las built se realiza por un registro de campo en hojas de
cálculo, donde se encuentran los pozos de registro, con sus profundidades. Entonces
imaginemos esto. Tenemos una calle, donde se registraron alcantarillas. De éstos se
recogieron cuotas y profundidades y en el paseo se recogieron los puntos de conexión.
Para ser interesante, imagine que se registraron de acuerdo con la estaca, el lado y offset
en relación con el eje de la calle (¿tal vez con cintamétrica?)
Veamos cómo acceder:
Aplicación
Para usar Excel, agregue su referencia DLL:
Figura 271 - Referenciar EXCEL
Tenga en cuenta que debe encontrarlo en COM. Pero si no está allí, busque en el GAC
(Global Assenbly Cache)
Figura 272 - Excel en GAC
Luego importe el NameSpace:
Imports Microsoft.Office.Interop.Excel
Libro de trabajo, hoja de cálculo
Ahora puedes usarlo:
Figura 273 – Acceso a la hoja de cálculo en el libro de trabajo (archivo 22)
Células
Las celdas a las que accederá como RANGE:
Figura 274 - Leer datos de la celda (archivo 22)
El RANGE puede ser una sola celda, pero también puede ser un range de celdas, por
ejemplo: A1;D4”. En el ejemplo anterior, debido al código, es más fácil encontrar el
valor informando la fila y la columna.
En el ejemplo, creé una función que lee los datos de la celda y predice los errores que el
usuario puede cometer. Verá, puede haber escrito un texto en una celda que vería que
contenía un número, o escribió un número, pero de todos modos lo formateó como texto
y la coma se mezcló con el punto. ¡La imaginación del usuario no tiene límites!
Consejo:
Si necesita escribir una gran cantidad de datos en una hoja de cálculo, no haga esto:
Figura 275 - Forma lenta de escribir datos en EXCEL (archivo 23)
¿Te das cuenta de que pongo un looping para escribir los valores celda por celda? Esto
puede ser en especial lento, especialmente si deja EXCEL visible. Esto se debe a que
“animará” el llenado de las celdas y verá que cada una de ellas se llena.
Figura 276 - Don't do that!
Prefiere pegar los datos de una vez:
Figura 277 – pegue los datos a la vez en EXCEL (archivo 23)
La diferencia en el rendimiento en este ejemplo es sorprendente en comparación con el
anterior.
EXCEL también le permite formatear celdas:
Figura 278 - Formateando las celdas
En el ejemplo anterior, un SNIPPET para un nuevo programa que estoy escribiendo.
En él, además de formatear las celdas, estoy MEZCLANDO alguna (busque el método
MERGE en el código).
Como siempre, vale la pena mirar el oráculo:
https://docs.microsoft.com/en-us/office/VBa/api/excel.range.cells
https://docs.microsoft.com/en-us/office/vba/api/excel.range.cells
Civil 3D
Todo lo que henos hecho hasta ahora proporciona una base para trabajar con Visual
Studio, AutoCAD y Civil 3D.
Vea, Civil 3D es una vertical de AutoCAD. Por lo tanto, no debería ser denasiado
complicado aprender a programar para él si comprendió la idea de Orientación a objetos
que vimos al comienzo del curso y, por supuesto, ¡saber dónde encontrar la “ayuda! De
la API.
Cuando vimos Orientación de objetos, vimos los conceptos de propiedades y objetos. Si
observa cualquier alineación, es un objeto, tiene propiedades, como una línea o polilínea.
Por supuesto, tendrá propiedades relacionadas con la alienación, como la estaca inicial,
velocidades de diseño, peraltes, perfiles, etc.
No memorice lo que aprendes aquí. Aprende a entender DÓNDE buscar:
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
Figura 279 - Civil 3D API Reference
Use Visual Studio para su ventaja:
Figura 280 - Use Visual Studio para su ventaja
¡Enumerará los métodos y propiedades de los OBJETOS! Pon las dos imágenes de arriba
juntas y tendrás todo lo que necesitas para crear tus programas.
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
Documento actual
Para trabajar con Civil 3D, tal como lo hacemos con AutoCAD, todo comienza por
“tomar” Civil 3D y luego el documento actual:
Figura 281 – Acceda al documento Civil 3D actual (archivo 19)
Figura 282 - Acceso al documento Civil 3D y otros dibujos (archivo 10)
Una vez que tengas civilDoc, puedes jugar con él:
Figura 283 – visualización de las propiedades y métodos civilDoc (instancia de la clase CivilDocument)
Prospector
Se podrá acceder a todo el prospector en el civilDoc de la imagen anterior. Quiero decir,
no todo, solo lo que está en la API. Sí, hay cosas que no son....
Ejercicio:
Compara las imágenes:
Figura 284 – Inspección de civilDoc y Civil 3D prospector
Cogo Points
Los cogo points son los puntos de Civil 3D. puedes crear, modificar, eliminar… lo que
sea. Usa la imaginación.
Ya hay algunos ejemplos aquí en el curso para crear y enumerar estos puntos. Así que
creemos un programa para ejemplificar un mayor uso de DataGridView e Cogo Points.
Lo primero que haremos es MOCKUP (form sim funciones, solo botones):
Figura 285 - Form ListarCogoPoints (archivo 24)
He usado:
1. ToolStrip en la parte superior
2. DataGridView com múltiples columnas
3. ToolStrip en la parte inferior
abra el Esquena del documento (menú Mostrar/otras ventanas), vea cómo se verá:
Figura 286 - Estructura del Documento (archivo 24)
La parte más importante del diseño será la propiedad DataPropertyName:
Figura 287 - DataPropertyName das colunas (archivo 24)
Nota:
Cada coluna tendrá un DataPropertyName. Elija las columnas que desea mostrar en su
hoja de cálculo, mirando la ayuda de Civil 3D API para un Cogo Point:
Figura 288 - Propriedades Cogo Point
Importante: escriba el nombre de la propiedad tal como está en la ayuda.
Elijo en el ejemplo: PointName, PointNumber, Elevation, Northing, Easting,
Longitud y Latitud.
Ahora, veamos el comando principal:
Figura 289 - Comando LISTARCOGODATAGRIDVIEW (archivo 24)
¿Notaste que no pongo todo el código en un solo método?
Este es un concejo muy importante: trate de mantener pequeño el tamaño de cada
método, que se ajuste a una página o que se ajuste a su pantalla sin tener que desplazarse.
Entonces la comprensión de lo que hace el método será mayor.
Lea el código solo en los comentarios. Tendrá mucho sentido. Entonces preocúpate por
el código.
Sí, no explique esta propiedad de DATASOURCE de DataGridView. Ver ayuda:
https://docs.microsoft.com/pt-
br/dotnet/api/systen.windows.forms.DataGridView.datasource?view=netframework-4.8
Tal vez entiendes la ayuda, tal vez no. Solo piense en FUENTES DE DATOS.
La primera cosa “extraña” que aparece es la clase MANIPULATOR. Gestiona los
métodos CREAR /DELETE de la lista de puntos:
https://docs.microsoft.com/pt-br/dotnet/api/system.windows.forms.datagridview.datasource?view=netframework-4.8
Figura 290 - Clase ayuda para administrar CREAR / BORRAR puntos (archivo 24)
Un consejo más:
TODO en la línea 20 significa reemplazar BindingList con SortableBindingList. Hay
uno aquí en STACKOVERFLOW:
https://stackoverflow.com/questions/23661195/DataGridView-using-sortablebindinglist
STACKOVERFLOW es un sitio web que DEBE COLOCAR EN SUS FAVORITOS.
Figura 291 - Convierta el código con telerik
¡AH, NO PODRÍA QUE ESO PASARA! Conviértalo aquí: http://converter.telerik.com/
Regrese y mire la cantidad de botones que agregamos al FORM. Ahora, agreguemos un
evento que “escuche” los clics en estos botones:
https://stackoverflow.com/questions/23661195/datagridview-using-sortablebindinglist
http://converter.telerik.com/
Figura 292 – acciones del botón de form LIstarCogoPoints (archivo 24)
Ejercicios:
1. Averigüe qué son “sender” y “e” en las líneas 237 e 238
2. Explique Me.DialogResult en las líneas 253 e 256
Método Exportación()
El método exporta los puntos de la tabla a un archivo de texto tabulado. La primera línea
contendrá los nombres de las propiedades de donde provienen los valores. Esto será muy
útil en caso de que desee agregar / eliminar columnas.
Figura 293 - Método Exportar (archivo 24)
Ejercicios:
1. Explique “&=” en las líneas 214 e 217
2. Explique “row.IsNewRow” en la línea 222
3. ¿Por qué usé USING?
Método de Importación()
Este método importa los puntos en el archivo de texto en el mismo formato que crea el
método Export(): columnas tabuladas, donde la primera línea informa el nombre de la
propiedad que tendrá el valor asignado.
Figura 294 - Método Importar (archivo 24)
Ejercicios:
Compare esta solución de datos con la versión de importación de datos con EXCEL.
1. ¿Se da cuenta de que la versión EXCEL es más enyesada?
2. Explique.
Bonus:
Al insertar columnas para mostrar LATITUDy LONGITUD, terminamos creando un
“convertidor” de coordenadas geográficas y coordenadas LOCALES.
Pero esto ni siquiera es lo principal.
Figura 295 – sospecha de latitudes y longitudes (archivo 24)
Observe las latitudes y longitudes. Sabiendo que el proyecto se encuentra en la zona 22.
Hemisferio sur, se esperaban valores como LAT=-25 y LON=-49.
¿Civil 3D está mal?
No. Los valores están en radianes. Entonces dices: La P*M*!!!
Evento CellFormatting de DataGridView
Vamos a solucionar esto usando el evento CellFormatting de DataGridView:
Figura 296 - Evento CellFormatting (archivo 24)
Este evento ocurre cuando DataGridView “pintará” (pronto explico esta pintura) el valor
en la celda.
Luego, el evento anterior, al darse cuenta de que pintará una celda de las columnas de
latitud y longitud, en lugar de escribir el valor en RADIANES, convierte el valor en
GRADOS DECIMALES.
Entonces dices: ¡Entendí! Y cuando el usuario, va a escribir un valor allí ya va a
convertir, ¡genial!
Y… no.
¡Solo harás esto en la página siguiente!
Evento CellParsing de DataGridView
Figura 297 - Envento CellParssing de DataGridView (archivo 24)
Ahora, el usuario puede escribir un valor en grados y DataGridView convertirá
GRADOS a RADIANES y luego guardará en la propiedad.
Figura 298 - Columnas de las Latitudes y Longitudes correctas (archivo 24)
El evento CellParsing se llama inmediatamente después de que el usuario haya
modificado el valor de la celda. Luego DataGridView convierte el valor, para luego
escribir el valor correcto en el objeto de línea.
Ahora compila y ejecuta el programa.
¿Funcionó? Intenta editar algo. Espero que den este error:
Figura 299 - Error de datos (archivo 24)
DataGridView es algo temperamental. Este error ocurrirá si escribe “a” en la coluna
“Leste”, por ejemplo, ya que espera que ingrese un número y no un texto. Para corregir o
inhibir este error, agregue un evento más:
Figura 300 – omitir el error de Datos Error (archivo 24)
Point Groups
Crear / filtrar
¿Qué pasa con los Point Groups?
Bueno, ya tenemos el ejemplo de Treeview, que manipula el Point Group,¿recuerdas?
Figura 301 - Ejemplo de treeview con point group (archivo 20)
Creo que lo más importante aquí sería mostrarle cómo crear Point Groups basados en
descripciones de puntos.
De hecho, ya tengo este programa listo aquí: https://tbn2net.com/PG4ALL
Figura 302 – Cómo construir una QUERY
Ver la imagen. Un point group debe tener una QUERY para decir qué puntos irán a ese
https://tbn2net.com/PG4ALL
grupo.
Veamos tu código fuente entonces.
Figura 303 - creación point Groups (archivo 25)
Genial ¿eh? ¿Y puedes hacer eso con AutoLISP??
Figura 304 - Top Model
Sí, es posible, mira cómo lo hice:
Figura 305 - Crear Point Group con AutoLISP
Originalmente hice este comando en AutoLISP. Lo porte a TBN2C3D
(https://tbn2net.com/TBN2C3D) hace aproximadamente 3 años.
Estilo
¿Y para editar estilo del cogo point, o el Point Group?
Bueno, solo toma el estilo y edita…
Tenga en cuenta que la versión de Auto LISP, edité el PointStyle utilizando point group.
Figura 306 - Point Style en Civil 3D
Mira la pantalla de arriba. Ahora mira donde cambio el estilo:
https://tbn2net.com/TBN2C3D
Figura 307 - Editar el Point Style (archivo 25)
Surfaces
superficies en Civil 3D. ¿Qué es posible hacer??
Creo que la pregunta es ¿qué QUIERES hacer? Crear, eliminar… esto es posible.
¿modificar el estilo a través de API? Hum … mira la edición de estilo de puntada que se
ve en la página anterior. Es casi lo mismo. La diferencia es que tendrá más elementos
para editar:
Figura 308 - Estilos de superficie
En general, los estilos de los objetos de Civil 3D siguen esta línea:
Estilo.GetDisplayStyleXXXXXXXXXXXXX ( YYYYYYYYYYY )
Donde XXXXXXXXXXXXXXX puede ser:
Plan
Model
Section
Profile
Y, YYYYYYYYY será un enumerador que le dirá qué elementos de la tabla desea. Si
tomamos la tabla de arriba como referencia:
Figura 309 – edición del estilo de superficie (archivo 25)
¿Qué pasa si queremos trabajar con una superficie?
Figura 310 - Trabajando con superficies
Mira, hay muchos métodos que podemos usar. Mira la API:
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
Elijamos uno: FindElevatiionAtXY
Este método obtiene la elevación en las coordenadas X, Y indicadas.
FindElevatiionAtXY
Pero si solo lo llamo, no será divertido. creemos un programa que haga más que eso:
1. Solicitud de una superficie (TINSURFACE)
2. Solicitar una coordenada
3. Cree un texto en esta coordenada (DBTEXT)
4. Cuando el texto se mueve de su lugar, lee solo la dimensión de la superficie
y edita el texto
5. Para ser una verdadera joya: justo después de NETLOAD, debe escribir
algunas palabras en la línea de comando (por ejemplo, el nombre del
comando usar))
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
Comencemos con el comando AmarrarPontoNaSuperficie.
Figura 311 - Comando AmarrarPontoNaSuperficie (archivo 26)
Como siempre, lea el código primero en los comentarios. Luego nos fijamos en los
métodos que se crearon para que la magia suceda. ¿Él miró? Ahora mira el código, ¿qué
ves en el nuevo??
Método RegAppName(“nombre”), para registrar un XDATA, pero ¿qué es
XDATA?
SetDatabaseDefaults, para establecer los patrones del dibujo actual
(textstyle, layer, por ejemplo)
Text.Xdata, para definir el valor de la propiedad XDATA en la entidad
TypedValue, tupla que contiene un enumerador DXFCODE y cualquier
valor
ResultBuffer, que almacena una lista de tuplas TypedValue
Método RegAppName
Este método registra el nombre de la aplicación, para que podamos agregar datos
extendidos a la entidad. Después de ejecutar el comando AmarrarPontoNaSuperficie,
intente usar el comando XDLIST de Express Tools y seleccione el texto que acaba de
dibujar.
Figura 312 - Método RegAppName (archivo 26)
Si no registramos el nombre de nuestra aplicación, no será posible almacenar el
HANDLE de la superficie en el texto y, por lo tanto, no pudimos identificarlo.
Vea que es muy similar a agregar un layer, un bloque etc.
Ahora, veamos cómo se ve la XDATA que necesitamos. Mira la línea 147:
Figura 313 - Crear un ResultBuffer (archivo 26)
Básicamente, ResultBuffer almacena un ARRAY de TypedValue. Por supuesto, eso no
es todo (busque ResultBuffer AutoCAD en el oráculo):
https://knowledge.autodesk.com/search-
result/caas/CloudHelp/cloudhelp/2017/ENU/AutoCAD-NET/files/GUID-A43BA3F1-
513E-42E5-A21F-633FAF97B5C9-htm.html
Figura 314 - Comando XDLIST
Bueno, mira la XDATA que creamos en la imagen de arriba.
https://knowledge.autodesk.com/search-result/caas/CloudHelp/cloudhelp/2017/ENU/AutoCAD-NET/files/GUID-A43BA3F1-513E-42E5-A21F-633FAF97B5C9-htm.html
Eventos
Regrese a la declaración del programa. Falta la parte cuando el texto actualiza su
contenido cuando se mueve. Esto ocurre en eventos.
Antes de continuar, algunas recomendaciones:
1. No confíes en el orden en que se llaman los eventos
2. No haga que un evento se llame a sí mismo
Ahora, pensemos, al mover el texto, debería actualizarse. Entonces podríamos usar un
evento ObjectModified. Mire la recomendación 2. El texto para mover genera el evento
ObjectModified, ya que el texto ha sido modificado. Luego cambias el texto. Eso
dispara otro evento ObjectModified, dentro del evento que aún se está ejecutando. De
acuerdo, desbordamiento de pila. Error fatal, adiós, AutoCAD.
Para resolver esto, podríamos apagar el evento ObjectModified durante la edición y
volver a cablear cuando haya terminado. Pensando eso:
Figura 315 - Evento ObjectModified (archivo 26)
Interface IExtensionApplication
Primero, ¿Qué es una interfaz?
https://docs.microsoft.com/pt-br/dotnet/visual-basic/programming-guide/language-
features/interfaces/
Las interfaces definen las propiedades, métodos y eventos que las clases pueden
implementar. Las interfaces permiten definir las funcionalidades como pequeños grupos
de propiedades, métodos y eventos estrechamente relacionados. Esto reduce los
https://docs.microsoft.com/pt-br/dotnet/visual-basic/programming-guide/language-features/interfaces/problemas de compatibilidad, ya que es posible desarrollar implementaciones avanzadas
para las interfaces sin arriesgar el código existente. Puede agregar nuevas funciones en
cualquier momento desarrollando interfaces e implementaciones adicionales.
La interfaz IExtensionApplication necesita implementar dos métodos:
Initialize, se llama justo después de NETLOAD
Terminate, se llama al cerrar AutoCAD
Figura 316 - Interface IExtensionApplication (archivo 26)
Esta interfaz es útil cuando su programa requiere algo de inicialización tan pronto como
se carga.
Figura 317 - Método Inicialice llamando después NETLOAD
Convertir HANDLE (String) en ObjectID
En el código XDATA almacena el HANDLE de la superficie. Pero para usar en el
evento ObjectModified, necesitamos recuperar este ObjectId. Para esto tienes este
pequeño método:
Figura 318 - Método HandleToObJectID (archivo 26)
Método AddToModel
Para simplificar un poco el método principal, separe este extracto en otro método. Inserta
la entidad suministrada en ModelSpace.
Figura 319 - Método AddToModel (archivo 26)
Método DocumentActivated
Este método se llama cuando el usuario va a otro documento. De hecho, debería estar en
el evento DocumentCreated, pero ahora lo está. Haz el cambio como un ejercicio.
Figura 320 - Método DocumentActivated (archivo 26)
Si no agrega este método, el programa no funcionará en otros documentos.
Método AddEvent
Este método activa el programa en el documento indicado. Lo hice por separado, ya que
se llama más de una vez, para que pueda agregarle más eventos. Por ejemplo:
ObjectErased.
Figura 321 - Método AddEvent (archivo 26)
Método Doc
Mira CODELENS, 11 referencias. Es una mierda escribir la línea 54 todo el tiempo, lo
simplifiqué y también AddToModel.
Figura 322 - Método Doc (archivo 26)
Sí, lo sé. 195 líneas de código para mostrar FindElevationAtXY.
Figura 323 – FindElevationAtXY (archivo 26)
¡Si él explicara solo a él, ni siquiera sería divertido, así que ejercitamos el MasterChef
que está en ti haciendo una receta de pastel!
Ver el resultado:
Figura 324 - Textos con cuotas automáticas
Ejercicios:
Identifique y explique para qué son:
1. ResultBuffer
2. TypedValue
3. DxfCode
4. Xdata
5. IExtensionApplication
6. AddHandler
7. RenoveHandler
8. AddressOf
9. Const
10. NumberStyles
11. RegAppTableRecord
12. RegAppTable
13. UpgradeOpen
14. DowngradeOpen
SampleElevations
Este método permite obtener una lista de puntos 3d proyectados en la superficie.
Imaginemos un problema:
Cree una polilínea 3D proyectada en la superficie, es decir, tiene las mismas dimensiones
que la superficie en las coordenadas de sus vértices, utilizando una polilínea 2D como
eje
Para hacer esto, primero la receta del pastel:
1. Pregunte por el eje
2. Pregunta por la superficie
3. Crear la polilínea 3d
Simple, ¿no es así? Para complicarlo, si ya tenemos la polilínea 3D, actualice sus
vértices de acuerdo con la geometría de la polilínea 2D.
¿Sigue siendo simple? Enlace la polilínea 2D con la polilínea 3D y la superficie de tal
manera que si cambia el eje 2D, la polilínea 3D se modifica automáticamente.
Para resolverlo, tomar é prestados los métodos AddToModel y Doc del problema
anterior (FindElevationAtXY):
Figura 325 - AddToModel y Doc (archivo 27)
Ahora, veamos el comando que crea la polilínea 3D.
Figura 326 - comando CONVERTEEN3D (archivo 27)
Hasta ahora nada que no hayamos visto.
Figura 327 - Método Atualiza3DPoly (archivo 27)
Ahora, cosas nuevas. Comience leyendo el código en los comentarios, luego lea el
código. Recuerde hacer esto siempre, al menos en los programas de este curso, ¡porque
la receta del pastel está ahí!
Figura 328 - Cake Boss
Finalmente, la última parte del problema, actualizar la polilínea 3D:
Figura 329 - Método ATUALIZAPOLY3D (archivo 27)
Todavía necesitamos automatizar el proceso de actualización de polilínea 3D cuando se
cambia la polilínea 2 D
Ejercicios:
1. Agregue XDATA a la polilínea 2D
2. Agregue el evento ObjectModified en la polilínea 2D
3. Explique por qué puse ese “<summary>” en la línea 115 y varios otros
métodos a lo largo del curso.
Alignments
Alineamientos en Civil 3D. Mira, es solo una polilínea mejorada.
Las polilíneas 2D pueden tener segmentos rectos y arcos.
Dicho esto, todos los métodos que ves para una polilínea son para alienación.
Algunas peculiaridades:
La alineación, así como TODOS los objetos dibujables de Civil 3D (alineación, corredor,
punto, superficie) son bloques. De acuerdo, no lo son, pero cuando explotan se
convierten en bloques. Enfréntalo como si ya lo fueran.
La alineación consta de 3 tipos básicos:
1. Tangente
2. Arco
3. Espiral
Estos tres se pueden agrupar para formar curvas compuestas (espiral, arco, espiral),
curva inversa (arco, arco), etc.
Figura 330 - Crear Alineaciones
Estas composiciones permiten aplicar restricciones de geometría, por ejemplo, una curva
entre dos tangentes mantiene la tangencia y el radio si cambiamos la dirección de las
tangentes.
Sabiendo esto, ahora podemos inspeccionar la API para ver qué es posible hacer con la
alineación:
Figura 331 - Propriedad Entities de la alineación
¿OCHO sobrecargas? ¿Qué significa esto?
Esto significa que hay 8 formas de crear una curva fija (arco). Si miras la imagen a
continuación, tendrá sentido:
Figura 332 - Agregar Curva (arco)
Esto va para tangentes y espirales, tiene varias formas de crear. Obviamente no los
mostraré a todos, porque no viene al caso.
Pensemos en un problema:
Divide una alineación en cualquier estaca. Sí, lo sé, ya lo solicitaron en “Autodesk Civil
3D Ideas Station” (https://forums.autodesk.com/t5/civil-3d-ideas/idb-p/31)
Primero la receta:
1. Solicitar alineación
2. Solicitar una estaca
3. Cree una copia de la alineación.
4. Itere a través de las entidades de alineación hasta que encuentre la estaca y, a
partir de ahí, elimine las entidades restantes.
a. Si la estaca está en una posición intermedia, corte en la posición
correcta.
5. En la segunda alineación (el clon), elimine las entidades hasta que lleguen a
la estaca
a. Si la pila está en una posición intermedia, corte en la posición
correcta.
Comando CORTARALINHAMENTO (control de corte)
https://forums.autodesk.com/t5/civil-3d-ideas/idb-p/31
Figura 333 - Comando CORTARALINHAMENTO (archivo 28)
Como siempre, lea el código en los comentarios primero
Método EraseEndEntities
Este método corta la alineación en la estaca informada, eliminando la parte final de la
misma. Tenga en cuenta que la última entidad puede necesitar ser parcialmente cortada.
Si es una tangente o un arco, es simple, simplemente corrija el punto inicial o final, pero
si es una espiral, se necesita más trabajo, ya que necesita calcular algunos parámetros
más. Ah, puede ser necesario corregir la entidad antes de la editada, para corregir el
punto final.
Figura 334 - Método EraseEndEntities (archivo 28)
El método resultó ser excelente, así que continúe en la página siguiente.
Figura 335 - Método EraseEndEntities, continuación (archivo 28)
Para calcular la espiral, se necesitaban dos métodos más:
Figura 336 – Calculo de espiral (archivo 28)
El primero calcula el punto de intersección de dos líneas tangentes a la alineación,
cuando pasan por las estacas informadas inicial y final.
El segundo calcula las coordenadas de los puntos que determinan la línea cuando el
punto de partida es el punto en el que toca la alineación en la estaca informada. El
segundo punto de la dirección de esta línea.
Tenga en cuenta que faltará el método EraseStartEntities. Dejaré esto como ejercicio.
Copie el código de EraseEndEntities y modifique las líneas necesarias, ya que las dos
son prácticamente idénticas.
Vea la imagen a continuación para ver el resultado. Para ser realmente genial, debe:
romper el perfil, profileviews, agregar las mismas labels de las estacas de la alineación
original en el clon, etc.
Figura 337 – Alineación recortada
Stations
Las estacas de alineación se pueden ser rellenas, intermedias, de superlevadura, de
geometríaya para recoger una lista de ellas, simplemente llame al método,
GetStationSet.
Figura 338 – Comando LISTARESTACAS (archivo 29)
Este comando es muy simple de entender. Mira que esta vez, elegí crear HTML. El
resultado está menos hecho.
Figura 339 - Resultado del comando LISTARESTACAS (archivo 29)
Ejercicios:
1. Verifique las otras firmas del método Alignment.GetStationSet()
2. Intente ejecutar el programa en una alineación que contenga peraltes
3. He visto notas que mezclan geometría horizontal y vertical.
a. Solicite la selección de greide y la iteración de bucle a través de
los PVI de perfil. De ellos, obtenga información sobre las curvas
verticales: PVC, PTV, PIV con estaca y elevación
b. Consulte el siguiente ejemplo (featurelines)
4. Compruebe qué otras propriedades le interesan mostrar en las pilas e
inclúyalas en el código (ejemplo: dirección instantánea en la pila, altura del
greide, declividad)
ProfileViews
Profileviews se encuentran en las propriedades de las alineaciones, así que comience con
la alineación si desea crear profileviews. Una vez creado 9 o abierto, si ya se ha
creado),solo observe los métodos y propiedades.
Para ejemplificar, supongamos lo siguiente:
Por alguna razón, necesita crear polilíneas en el profileview y debe convertir estas
polilíneas en perfiles. Esto ya se me ocurrió cuando las personas geotécnicas crearon los
perfiles de segunda y tercera categoría. No tenían esas “habilidades” para dibujar los
perfiles ya, así que dibujaron con polilíneas. Si lo sé. Yo pensé lo mismo.
De todos modos, se da el problema y el ejemplo hace posible estudiar 2 objetos:
ProfileView y Profile.
Los métodos más útiles son:
1. FindStationAndElevationAtXY, para para convertir una coordenada X,Y
de WCS a (Estaca, Elevación)
2. FindXYAtStationAndElevation, para calcular X,Y en WCS a partir de una
estaca y elevación
Utilizo ambos para crear las proyecciones de los objetos creados en el nuevo
complemento que estoy escribiendo, ya que no uso las proyecciones nativas de Civil 3D,
que no ofrecen ninguna API para trabajar.
Por lo demás, podría crear un programa para automatizar el llenado del BANDSET
(https://tbn2net.om/MBANDSET) o los sombreados (https://tbn2net.com/Mprofhatch):
https://tbn2net.om/MBANDSET
https://tbn2net.com/Mprofhatch
Figura 340 - Comando MBANDSET
Comando CRIARPERFILDEPOLILINHA
Figura 341 Creación de Profiles a partir de polilínea (archivo 30)
El perfil funciona de manera muy similar a la alineación, por lo que también tiene la
propiedad ENTITIES con una lista de ProfileEntity (ProfileCircular, ProfileTangent,
ProfileParabolaAsymmetric, ProfileParabolaSymmetric) cada una con sus propias
propiedades.
Sites
Los sites contienen varios elementos: Parcels, Featurelines, Gradings, Alignments.
Alignments
Las alineaciones que procesa normalmente, como lo haría con las alineaciones que están
fuera de los sites. (ver civilDoc.GetSitelessAlignmentIds ).
FeatureLines
Piense en ellos como una mezcla de polilínea 3D con alineación.
Las featurelines sufrieron algunas actualizaciones de API, por lo que se agregaron
muchas cosas nuevas, lo que impide crear programas para versiones anteriores de Civil
3D.
Quizás lo más difícil es crear una nota de servicio para las featurelines. Así que
pensamos en ese programa que genera una tabla de puntos de replanteo para la
alineación de la featureline.
Comando NSFEATURELINE
Figura 342 - Comando NSFEATURELINE (archivo 31)
Bueno, vale la pena la imaginación. ¿Qué hay de nuevo aquí? Un método para calcular
las apuestas featureline: GetStationsFeat()
Método GetStationsFeat
Figura 343 - Método GetStationsFeat (archivo 31)
Nuevas cosas para aprendes:
1. Curve.GetPointAtParameter
2. Curve.GetParameterAtPoint
3. Curve.GetDistAtPoint
4. Bulge, es la medida de la curvatura del arco. Está dado por: 2* (altura del
sector del arco) / cuerda del arco)
Ejercicios:
1) Agregue las pilas intermedias en la lista que devuelve el método GetStationsFeat
con un intervalo de 20 metros, por ejemplo
2) Explique la línea 41:
Parcels
¿Qué necesitas de las parcels? ¿Área, perímetro, lista de vértices, descripciones,
estadísticas de lote por bloque, frente a cada segmento?
De estos, creo que lo más “difícil” es obtener a los confrontadores. ¿Es por eso que los
reports no lo hacen? ¡Entonces vamos a pensar en algo en este sentido!
Figura 344 -comando OBTERCONFRONTANTESDELOTES (archivo 32)
El comando es solo tener una idea. Lo difícil es encontrar al confrontante.
Algunas observaciones:
1) El programa no detecta islas (vacíos dentro del lote) en los lotes, solo el contorno
externo.
2) No detecta confrontación callejera, si no es un paquete también
3) Todos los segmentos del lote deben tener segmentos coincidentes. No reconocerá
vértices virtuales (C3DMENO WINS!!! https://tbn2net.com/C3DMENO)
4) El usuario es complicado. No dibujará los vértices correctos, por lo que el
programa admite una tolerancia de 0,0001 de distancia entre los puntos al probar
si son iguales.
5) El programa no verifica si tiene vértices duplicados antes de crear la parcela.
Figura 345 - Para el lote 60, el círculo es un vértice virtual
Al ejecutar este comando, el resultado es:
https://tbn2net.com/C3DMEMO
Figura 346 - resultado del comando OBTERCONFRONTANTESDELOTES
Método SearchConf
Figura 347 - Método SearchConf (archivo 32)
El método no tiene misterio. Es realmente una fuerza bruta, toma el segmento del lote
que va a probar y lo compara con todos los segmentos de todos los lotes que pasa como
argumento. Aquí, es necesario crear algunos dispositivos para poder reducir esta lista de
candidatos vecinos. Imagine una asignación de 6000 lotes (¡he hecho!) cada uno con al
menos 4 lados. Para probar confrontantes y generar un Memorial de todo esto. Solo esta
búsqueda genera (4*6000 * 4*6000 / 2 = 2,88x10^8, ¿está bien para usted?)
Método IsNear
Figura 348 - Método IsNear (archivo 32)
Como mencione, no confíes en el usuario. Había encontrado formas de dibujar mal y los
vértices de los lotes que DEBERÍAN ser coincidentes, no lo serán. Aquí hay un buen
programa para hacer: verificar la consistencia de los vértices.
Método Segmento
Figura 349 - Método Segmento (archivo 32)
Faltaba poner un nombre “gringo” en el método. Bueno, extrae un borde de la polilínea,
para facilitar la prueba de coincidencia de confrontación (¿eso sonó pleonasmo?)
Método Parcel2Polyline
Figura 350 - Método Parcel2Polyline (archivo 32)
Este método es para hacerlo un poco más fácil. El paquete es como una REGION de
AutoCAD. Entonces, en principio, le permite hacer “islas” en los lotes.
Cosas que este método PODRÍA hacer:
1) Prevenir vértices duplicados
2) Calcular y agregar vértices virtuales
3) Verifique la dirección (en sentido horario / antihorario)
4) Establecer el punto de inicio de la polilínea
los métodos AddToModel y Doc, copié de los otros módulos. Cheque.
Ejercicios:
1) En posesión de la polilínea de lote, exporte las coordenadas de los vértices a
Excel, así como los nombres de los enfrentados.
2) Cree un caché de lotes con sus respectivas polilíneas para que el método
Parcel2Polyline no demore tanto la ejecución en lotes muy grandes (1000 lotes o
más)
3) Cree una selección por ventana en el lote que se calculará, para filtrar solo los
lotes más cercanos, reduciendo el tiempo de ejecución al procesar toda la
subdivisión.
Pipenetworks
Bien, volviendo a nuestro problema con el registro de redes de alcantarillado, imagine
que tiene una hoja de trabajo de registro como esta:
Figura 351 – Hoja de registro de AS BUILT de alcantarillado (archivo 22)
Cómo se vería un programa en Civil 3D, suponiendo que las conexiones pueden ser
representadas por COGOPOINTS y los PVs son pozos rectangulares y los tubos son
circulares.
También considere que:
Columna
tipo de
datos descrição
Tipo String tipo de PV: PV, CL, PVR, PVQ
Nombre String nombre del PV de importe
Estaca Double Marco de alquiler de PV en el eje de lacalle
Offset Double offset del alquiler de PV en el eje de la calle
Cuota Double Cuota del PV del importe
Profundidad Double Profundidad del PV
Lado String
lado del pv con respecto al eje: izquierdo o
derecho
Anchura Double Anchura interior del PV
Longitud Double Longitud interior del PV
Conecta String
Nombre del PV de la corriente abajo, cuando
tiene tubo que conecta
Diámetro Double diámetro del tubo
GeratrizMontante Double
cuota de la generatriz inferior de montante del
tubo
GeratrizJusante Double cuota de la generatriz inferior de abajo del tubo
Figura 352 - Descrición de columnas
La receta del pastel:
1) Elija la alineación de la calle
2) Elija la red donde insertar los PV
3) Elija el archivo EXCEL desde el que leer los datos
4) Leer los datos de Excel
5) Dibuje los PV y almacene la lista de PV, para
6) Dibujar los tubos y conéctelos a los PV
Simple, ¿no es así? Veamos cómo se verían estos pasos.
En primero lugar, necesitaremos un comando: CADASTROREDES.
Comando principal: CADASTROREDES
Figura 353 - Comando CADASTROREDES (archivo 22)
Tenga en cuenta que no hay nada más allá de lo que henos visto hasta ahora. Sí, hay
métodos que no mostré, pero ya los llamé. Imagine que “DrawStructures” aún no se ha
escrito:
Figura 354 - Referencia a un método inexistente
Visual Studio le informará que el método no existe y le dará algunas sugerencias. Acepta
que crea el método. Luego, ve allí y escribe lo que hace el método.
El primer método que tendremos que incluir es GETDATAFROMEXCEL.
Método GETDATAFROMEXCEL:
Este método leerá los datos de cualquier archivo XLSX y leerá los datos formateados
como en la hoja de cálculo de ejemplo. Veamos cómo se verán los datos que lee. La
tabla al principio define las siguientes columnas:
Figura 355 - Estructura de datos de hoja de cálculo de Excel (archivo 22)
Y el programa que lee los datos:
Figura 356 - Leer los datos en EXCEL (archivo 22)
¿Qué hay de nuevo en este código?
Una cosa interesante que agregué: Una barra de progreso. Una de las recomendaciones
es que, en operaciones largas, agregue una barra de progreso, para no hacer que el
usuario se sienta ansioso. Si cree que el programa está tardando demasiado y no está
haciendo nada, terminará. Obviamente te llamará y dirá que el programa se ha
bloqueado….
Figura 357 - El programa se bloqueó
Ejercicios:
1. Explique la declaración WITH en la línea 153
2. Busque la clase PROGRESSMETER en la API de AutoCAD y explique
sus métodos. ¿Qué sucede si olvido colocar STOP?
3. ¿Qué sucede si llama a METERPROGRESS más veces de las que debería?
Inserté dos métodos más en este código:
1. ReadString, para leer un valor de texto
2. ReadDouble, para leer un valor de tipo número real.
La razón es simple: el usuario ESCRIBIRÁ cosas incorrectas en las celdas. Y algunos de
estos errores son fatales.
Figura 358 - Métodos para leer valores de celdas en EXCEL (archivo 22)
¿Entendiste la idea de prevenir errores?
Método GetPipenetworkByName
Regrese al código de comando CADASTRODEREDES. Después de leer los datos de
EXCEL, el siguiente paso es abrir la red para su edición, después de todo, vamos a
agregarle PV y tubo. Pero elegimos pedir el nombre de la red en la línea de comando
(dar una razón). Entonces, dado el nombre, obtengamos la red y, si no existe, creamos
una:
Figura 359 - Buscar o crear PIPENETWORK (archivo 22)
Ejercicios:
1. ¿Qué nuevas clases y métodos ves? Identifícalos y explícalos. Consejo:
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
2. Explique las líneas 76 y 82.
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
Método DrawStructures
Figura 360 - Método DrawStructures (archivo 22)
Este método es responsable de diseñar el PV. Vea cómo convertir la apuesta y el
desplazamiento en coordenadas X, Y, en la línea 442,
Ejercicios:
1. Sabiendo que el método POINTLOCATION calcula X e Y, cuando se
proporcionan datos de replanteo y compensación, ¿cuál sería el método que
hace lo contrario?
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
2. Mire la línea 463. Identifique el método ADDSTRUCTURE. Busque su
sintaxis en la API. Deberá comprender este método para comprender por qué
tiene el método GetFamilyAndSizeOfStructure en la línea 456.
3. Explique cómo se calculó la rotación del PV. Dibuje un dibujo que muestra
la alineación y los puntos (X,Y) y (xEixo, yEixo)
4. Explique el looping DO en la línea 471
http://docs.autodesk.com/CIV3D/2019/ENU/API_Reference_Guide/index.html
Método GetFamilyAndSizeOfStructure
Figura 361 - Método GetFamilyAndSizeOfStructure (archivo 22)
No hay una manera fácil de hacer esto. Vea, el método AddStructure, requiere una
serie de argumentos, que al principio no tenemos:
Figura 362 - AddStructure Parameters
No tenemos: structureFamilyId, structureSizeId
Esta información está en la PARTSLIST de PIPENETWORK. La función del método
GetFamilyAndSizeOfStructure es encontrar estos dos parámetros y para eso, se ejecuta
a través de todo el PartsList. Si no, él INTENTA crear.
¿Por qué intentarlo? Debido a que le catálogo se puede configurar de tal manera que
evita la adición de otros “PartSize”. Por ejemplo, no es posible agregar un tubo con
diámetros de 2300 mm si este valor no está en la configuración del tubo allí en
PartBuilder:
Figura 363 – PartBuilder
Ejercicios:
1. Explique el método GetDataFiledBy en la línea 222
2. ¿Por qué tuve que hacer UpgradeOpen en la línea 245?
3. Explique el parámetro “addIfNot” del método
GetFamilyAndSizeOfStructure en la línea 236. ¿Qué puede suceder si
elimina el bloque IF de la línea 236?
Tenga en cuenta que en el método GetFamilyAndSizeOfStructure, agregué 2 métodos
más para implementar:
GetSizeFilterFieldSI, para leer y convertir el valor de lectura en unidades del sistema
internacional
SetSizeFilterFieldSI, para convertir valores del sistema internacional a la unidad
correcta y almacenar en el campo especificado
Figura 364 - Leer / Grabar datos con unidades en PartsList (archivo 22)
Civil 3D depende mucho de las unidades de medida. Por lo tanto, debe tener en cuenta
las unidades utilizadas en PartBuilder, ya que pueden no ser las mismas que espera leer
/ escribir en EXCEL.
Figura 365 - Cómo se configuraron los parámetros en PartBuilder para el tubo circular
En EXCEL, aceptamos que los valores están en METROS. ¡Pronto se hace necesario
convertir unidades!
Después de insertar los PV, necesitamos insertar tubos y queremos que se conecten a los
PV lanzados. Regrese al código del programa CADASTRADORES:
Figura 366 - Dibuje primero los PV, luego los tubos (archivo 22)
¿Te das cuenta de que, para diseñar los tubos, los PV ya deben diseñarse? ¿No? Por dos
razones: necesitamos las coordenadas de los PV y necesitamos conectar el tubo a los PV.
Método DrawPipes
Figura 367 - Método DrawPipes (archivo 22)
Para dibujar el tubo, es necesario tener el PV aguas arriba y aguas abajo, ya que
necesitamos sus coordenadas. También necesitamos conectar el tubo a los PV. En el
paso anterior, es decir, en el método DrawStructures, filtramos los datos leídos
dibujando los PV y almacenándolos en un DICTIONARY, con el nombre y OBJECTID
creados para el PV. También filtramos las líneas en las que aparece la columna
“CONECTA” que dice efectivamente que hay dos PV conectados.
Ejercicios:
1. Busque el método pipe.ConnectToStructure, defina sus parámetros
2. ¿Cuál es el LineSegment3D que aparece en la línea 521? ¿Cómo se
relaciona con el tubo?
3. ¿Notó el método GetFamilyAndSizeOfPipe en la línea 508? Impleméntelo
utilizando el método GetFamilyAndSizeOFStructure como SNIPPET.
Esto es lo que se necesita para diseñar el tubo:
Figura 368 - AddLinePipe, Civil 3D API
Nuevamente necesitamos información que no tenemos: pipeFamilyId e pipeSizeId.
Método GetFamilyAndSizeOfPipe
Figura 369 – Método GetFamilyAndSizeOfPipe (archivo 22)
Al igual que el método que GetFamilyAndSizeOfStructure, el método
GetFamilyAndSizeOfPipe itera a travésde PartsList buscando por un PartSize que
coincida con el diámetro leído en el registro EXCEL. Si no puede encontrarlo,
INTENTE crear uno y agregarlo a la PartsList.
¿Qué pasa con el método EQUAL que aparece en la línea 302? En informática, un
número real no siempre es lo que esperamos de él. Imagina un número con 20 decimales.
Se redondeará a un número con 8 o 16 decimales (corrígeme si no tienes sentido),
dependiendo del sistema operativo (32 o 64 bits). Por lo tanto, no confíe en 2.5 (número
real) * 1000,0 (número real) para que sea igual a 2500 (número entero).
Figura 370 - método Equal (archivo 22)
Es eso. En 541 líneas hicimos un programa PARA 3D CIVIL, que:
1) Elija la alineación de la calle
2) Elija la red donde insertar los PVs
3) Elija el archivo EXCEL desde el que leer los datos
4) Leer los datos de EXCEL
5) Dibuje los PV y almacene la lista de PV, para
6) Dibuje los tubos y conéctelos a los PVs
Observe la cantidad de espacios de nombres que utilizamos:
Figura 371 - Todos los NameSpaces para este programa (archivo 22)
Además, hablamos con:
1) Windows
2) Excel
3) AutoCAD / Civil 3D
4) Usuario
Figura 372 – Etiqueta de calidad
Corridors
Me imagino que los corredores son lo más complejo en Civil 3D. el necesita:
1. Alineamientos
2. Perfiles
3. secciones típicas
4. Superficies
Y logra generar:
1. Featurelines
2. Superficies
3. Convención de la pendiente
4. Secciones de plantilla
Y proporciona subsidios para:
1. Cuantificar volúmenes (Shapes)
2. Cuantificar longitudes (Featurelines)
3. Cuantificar áreas (shapes horizontales)
4. Notas de servicio
5. Otras alineaciones y perfiles
Sin mencionar que involucra estilos para:
1. El corredor mismo
2. Puntos
3. Links
4. Shapes
5. Peine de pendiente
6. Superficies
¿Olvidé alguna? Si.
El proceso de creación del corredor está muy bien vinculado en el editor del corredor:
Figura 373 - Editor de propriedades del corredor
No hay mucho más que hacer, excepto que tenemos que hacer un corredor a la vez. Allí
el proyecto es una subdivisión, donde la mayoría, si no todas, las calles se hacen con la
misma sección. Pasas horas modelando corredores.
E el ejemplo anterior, elegí modelar todos los corredores de todas las calles en un solo
corredor, ya que el proceso de modelado de los movimientos de tierra de la subdivisión
en su conjunto lo permite y en este caso es más ventajoso:
Figura 374 - Corredor único
A pesar de ser laborioso, es fácil de entender. Los corredores están muy bien
organizados jerárquicamente en:
1. Baselines
2. BaselineRegion
a. Surface target
b. Width target
c. Elevation target
3. Codes
a. Points
b. Links
c. Shapes
4. Surfaces
a. Usando Links
b. Usando FeatureLines
5. Boundaries
a. Corridor Extents
b. Featurelines
c. Etc
6. Slope Patterns
a. Featurelines
Baselines
Las baselines definen qué ejes y perfiles se utilizarán como referencia. Aquí es donde
completamos la alineación y el perfil (o featureline, en el caso de Civil 3D 2017 en
delante).
Apenas eso. No tenemos que preocuparnos por el replanteo (todavía).
Solo podemos tener una o varias alineaciones. Luego tenemos una colección de líneas de
base en el pasillo.
BaselineRegion
Las baselineregions definen la sección típica, o secciones típicas, así como el intervalo
de aplicación (pilas de inicio y fin). Por lo tanto, tenemos una baselineregions para cada
baseline.
Las secciones típicas a su vez son una colección de Subassenblies, que por su vez son
una colección de Points, Links y Shapes.
Es importante tener esto en cuenta, ya que, para trabajar con el corredor, se requerirán
MUCHOS loopings
Target Mapping
El target Mapping es el proceso de definir targets (oh…). en esta parte, creo que
Autodesk tomó algunas malas decisiones, pero, de todos modos.
Para ejercitar la creación de los corredores, imaginemos que queremos unir todos los
corredores en uno, como hice en el proyecto de ejemplo. Esto facilitará la comprensión
de cómo crear corredores, después de todo para unir, tendremos que deconstruir todo y
reconstruirlo en uno. Además, comprendamos que no se puede simplemente insertar una
baselineregion si se superpone a una existente, i insertar una tras otra con un intervalo
más corto.
Así que veamos a la receta del pastel:
1. Seleccione los corredores
2. Interpretar las baselines
a. Ordenar baselines que usan la misma alineación (y perfil)
i. Ordenar las baselineregions en orden ascendente
ii. Reparar superposiciones
3. Almacene esta información
4. Borrar los pasillos
5. Crea un corredor
6. Use la información almacenada
a. Crear las baselines
i. Crear los baselineregions
1. Hacer el target mapping
7. ¡Construir!
¿Parece fácil?
Y es. Comencemos con el comando principal.
Comando MESCLACORREDORES
Figura 375 - Comando MESCLACORREDORES (archivo 33)
Para un cambio: lea el código a través de los comentarios y luego el código.
Ejercicio:
¿Por qué eliminar la baseline temporal? Si se iba a eliminar, ¿por qué crear?
Agregue dos métodos:
1. InterpretaCorredores
2. AdicionaBaselines
Método InterpretaCorredores
Figura 376 - Método InterpretaCorredores (archivo 33)
Para que el programa funcione en consecuencia, debemos asegurar de que la
baselineregion no se superpongan. Podríamos hacerlo tomando la información
directamente de los corredores, pero iba a contaminar el código y hacer que las cosas
fueran más difíciles de leer.
Con este en mente, creé algunas estructuras de datos que almacenan solo lo que voy a
usar, lo que facilita el proceso de ordenar las listas de datos que luego ayudarán a evitar
erros superpuestos.
Figura 377 - Estructuras de datos (archivo 33)
Hay tres estructuras, en realidad son clases. Preferí las clases, al instanciarlas, ya
instanciaba las listas que almacenan. Cada uno con su propia información.
Descubra en la API de Civil 3D sobre:
1. Baseline
2. BaselineRegion
3. AppliedAssenblySetting
Y descubra el método SORT en listas, para comprender cómo el programa clasifica la
lista en las líneas 98 y 103. Este método evitará dolores de cabeza al agregar
BaselineRegion:
Figura 378 - Error al agregar BaselineRegion con intervalo superposición
Otro beneficio de hacer ordenado las baselines es poder ver las alineaciones ordenadas
en la pantalla de edición de propriedades del corredor. Es obvio que tendrá que ver esto
en algún momento y si hay muchas baselines/baselineregions, la organización es
esencial:
Figura 379 - Baselines organizadas
Método AdicionaBaselines
Figura 380 - Método AdicionaBaselines (archivo 33)
Los comentarios, ¡los comentarios primero!
Ahora estudie las líneas 135 a 141. ¿Tenía sentido?
Ejercicios:
1. Explique la línea 118
2. Elimine la prueba IF en la línea 155, y intente el programa.
3. “Olvídate” de poner la línea 168 (comentarla) y ejecutar el programa.
4. Predefina el intervalo de modelado (frecuencia de assenbly) a 10 metros en
la tangente, arcos y espirales de la alineación, sin modelar los puntos
geométricos, antes de construir el corredor (¡descubra dónde hace esto!)
Surfaces
¿Y para crear superficies en los corredores?
Figura 381 - Agregar superficies en los corredores (archivo 33)
¡Este es tan simple que ni siquiera es gracioso! ¿Por qué saber hacer esto? De nuevo:
subdivisiones. Puede elegir crear múltiples corredores y crear una superficie para cada
uno. O bien, cree un comando que verifique que todas las superficies TODAVÍA tengan
Boundary (¿Qué hacen los Boundarys en sus corredores nunca desaparecen de la nada o
dejan de funcionar? Las mías sí…)
Ejercicios:
Adapte el código anterior para crear superficies en todos los corredores seleccionados.
Según el código anterior, cree un programa que verifique los boundaries de los
corredores y ajústelos si es necesario. Utilice Corridor Extents as outer boundary:
Figura 382 - Corridor Extents as outer boundary
¡Sigamos con los corredores! ¿qué más quieres saber? #comofas a NOTASERV
(https://tbn2net.com/NOTASERV2)?
Por supuesto, no voy a poner su código aquí, jejeje, ¡pero veamos un pedacito!https://tbn2net.com/NOTASERV2
¿Qué necesitamos para generar la factura del servicio de alquiler?
Estaca, código de punto, offset y elevación. Luego solo pon eso en Excel.
Lo primero que debemos hacer es tener en cuenta qué códigos de corredor vamos a
procesar. En la imagen a continuación, venos los códigos para Daylight, Hinge, ETW.
También necesitaremos las coordenadas del eje.
Figura 383 – Codificación de la sección típica
Mira, puedes hacerlo con banquetas, con otros códigos, no importa. Comprenda cómo
funciona el código y puede adaptarlo a sus necesidades.
Por ejemplo, acabo de hacer la nota de servicio usando los POINTS.
Luego dices: ah, pero quería ver los LINKS
Figura 384 - ¡Quiero imágenes!
Reflexiona: ¿qué es un link, sino una RECTA? Es una línea que une dos POINTS.
Agregue un código a la línea y tendrá el link. Únete a los links en un perímetro cerrado,
pon un código y tendrás la SHAPE.
Comando CRIARNOTADELOCACAO
Figura 385 - comando CRIARNOTADELOCACAO (archivo 34)
¿Leíste los comentarios?
Vayamos al código. Reconocer los métodos ProcessaNS y ExportaParaExcel.
Bastante obvio, ¿no es así? Esa es la idea. Si logré hacerte esto al menos, otros, o incluso
tú en el futuro, entenderán lo que hace el programa
Método ProcessaNS
Figura 386 _Método ProcessaNS (archivo 34)
El método ProcessaNS, es quién obtendrá los datos. Tenga en cuenta que este método es
muy estricto, no permite agregar más columnas en tiempo de ejecución como
NOTASERV2.
Será su ejercicio en el futuro:
Agregue formas para que el usuario agregue / elimine / ordene columnas, así como elija
códigos que desea procesar (recuerde, los country kit usan códigos en sus respectivos
idiomas).
Ejercicios:
1. ¿Notó que la cuota debe aumentarse con el valor de la cuota de greide?
2. ¿notó que la línea 73 tiene un método subrayado?
3. Lea las líneas 104 a 107. ¿Qué piensa sobre esto?
4. Estudie el método Baseline.SortedStations. Compare con los reports
normales en Civil 3D que requieren SampleLineGroup en la alineación.
Veamos el método PrepareDados. Lo separe en otro método para no contaminar el
código y encajar aquí en WORD, jejeje.
Método PrepareDados
Figura 387 - Método PrepareDados (archivo 34)
Tenga en cuenta que las matrices comienzan en el índice cero y no en 1.
¿Por qué configure el tipo de datos en OBJECT y no DOUBLE? Porque voy a llenar la
matriz con Strings y double. Y él pide celdas vacías. Para exportar a Excel, si definió
todo como double, las celdas vacías irían con un valor de CERO, lo cual no es correcto,
ya que la celda debe estar en blanco y aun así debe separar el llenado de los títulos de los
datos.
Método GetStationOffsetElevation
Figura 388 - Método GetStationOffsetElevation (archivo 34)
Aquí sucede la magia. Mira, el mismo código se puede modelar más de una vez. Las
banquetas lo tienen. Entonces, tal vez sería más interesante devolver una colección de
puntos.
Pero su código para completar datos en Excel tendrá que modificarse para comprender
esto y crear tantas columnas como sea necesario. En NOTASERV2 di dos soluciones
para esto:
1. El usuario crea el número apropiado de columnas
2. NOTASERV2 agrega LÍNEAS a los puntos del mismo código, manteniendo
el número de columnas.
Ambos tienen ventajas y desventajas.
Método ExportaParaExcel
Figura 389 - Método ExportaParaExcel (archivo 34)
Verá, el código es muy flexible cuando se trata de pegar los datos, ya que puede tener
cualquier dimensión, ya sea filas o columnas. La única restricción es que las dos
primeras líneas de la tabla son títulos y subtítulos, considerando que fusionará los títulos
en dos celdas.
Puede separar el llenado de los títulos y subtítulos, que no toma tanto tiempo, del llenado
de los datos, pero si realiza un looping de filas y columnas, puede tomar mucho tiempo.
Ejercicios:
1. Separe el relleno de los títulos u subtítulos.
2. Haga una versión en looping que llene las celdas por celda y compare los
tiempos de ejecución en una alineación extensa.
Resultado
Figura 390 - Resultado de ejecutar el comando
Ver el resultado. Tenga en cuenta que ya henos formateado los datos.
Ejercicios:
1. Permitir al usuario elegir una plantilla de hoja de cálculo
2. Permita que elija la fila y columna de inicio para pegar los datos. Esto
permitirá tener los encabezados con los datos de la empresa, proyectos, etc.
Settings
Drawing Settings
Le di algunas pinceladas para acceder a los SETTINGS de Civil 3D, para elegir el layer
predeterminada al crear perfiles.
Para elegir labrestes, estilos, etc.
¿Qué sucede si quisiera que la estaca escrita en el programa de notas de servicio
aparezca formateada con el station index? ¿Es posible?
créenos un pequeño método que convierta las pilas al formato que queramos:
Figura 391 - Formateando estacas (archivo 34)
Mira, no es que vas a necesitar todos esos argumentos. Elimine los que desee, incluya
otros.
Ahora, mira la línea 227, ¿reconoces a Wally?
Ah, será necesario importar el NameSpace
Imports Autodesk.Civil
Styles
Figura 392 - Acceso Styles (archivo 30)
LabelStyles
En general, los objetos que tienen labels simples, acceden directamente:
Figura 393 – PointLabelStyles
Objetos que pueden tener LabelSets (colección de labels), como alineación, perfil:
Figura 394 – ProfileLabelSetStyles (archivo 30)
BandSets
Los BandSets son exclusivos de ProfileView e SectionView. Piense en ello como otra
colección de objetos, que podrá manipular.
Espero que hayas tenido la epifanía de notar que esto es más o menos:
OBJETOLabelSetStyles
OBJETOStyles
OBJETOLabelStyles
Ah, FirstOrDefault es una extensión de método agregada por NameSpace Systen.Linq
a las colecciones que implementa un método Iten estándar.
Lo usé varias veces en los ejemplos. Vuelva a visitarlos y vea que NameSpace está allí.
CUIX
A lo largo de este curso, henos creado docenas de comandos para trabajar con Civil 3D,
con AutoCAD, Notepad, Excel e incluso Windows. Sin embargo, todos los comandos
que creamos deben llamarse desde la línea de comando y, bueno, no tuvimos mucho
cuidado con el hecho de que el usuario no sabía los nombres de los comandos “en su
cabeza”. No trabajamos en LINUX trabajamos en Windows y nos gustan los iconos.
jejejeje.
El Custom User Interface nos permite crear menús, barra de comandos, a ribbon, permite
personalizar algunas acciones, por ejemplo: es posible acceder al comando
ALIGNMENTPROPERTIES haciendo doble clic en una alineación. Genial ¿eh?
Al contar que una hermosa interfaz para el usuario hará que la experiencia sea más
agradable. Me gusta pasar el mouse sobre un botón en Civil 3D y él me da explicaciones
de lo que hace. Y mira, ¡algunos incluso tienes video si esperas unos segundos!
A continuación, puede ver la ribbon C3DRENESG4
(https://tbn2net.com/C3DRENESG4)
Figura 395 - Ribbon do C3DRENESG4
Por supuesto, hay quienes no lo usan, prefieren escribir los comandos en la línea de
comando, pero seamos sinceros, algunos comandos tienen nombres enormes y son
difíciles de recordar.
Figura 396 – Ayuda de línea de comando
Civil 3D no le mostrará este tipo de ayuda si no hace su tarea y crea el archivo CUIX.
https://tbn2net.com/C3DRENESG4
Figura 397 - Archivo CUIX
¡Veamos cómo crear el o archivo CUIX!
1. Use el comando CUI,
2. en la pestaña Transfer,
3. haga clic en el botón Create un new customization file
Figura 398 -Crear archivo CUIX
Guarde el archivo en alguna parte:
Figura 399 – Guarde el archivo CUIX
Vuelva a la pestaña CUSTOMIZE y haga clic en OPEN:
Figura 400 - Aba Customize, Open
Agrega un comando. Tenga en cuenta que el comando debe crearse dentro de su archivo
CUIX:
Figura 401 - Agregar comando
Figura 402 – Creación de un comando
Lo que necesita llenar:
Name: asigne al comando un nombre corto, pero no abreviado para el comando.
Description: cuéntanos qué hace el comando.
Extended Help File: puede dejar en blanco. Si va a crear el archivo XAML que solicita,
abra un comando que tenga el video de ejemplo e imítelo aquí
Command Display Name: cómo llamar al comando en elidioma local desde la línea de
comando
Macro: es lo más importante. Siempre comience con “^C^C_” luego el comando que
creó. Ese “^C^C_” tiene que aparecer, ¿de acuerdo?
Elenent ID: su comando podrá pasar a través de otro CUIX. El usuario hará algo así.
Créame. El Elenent ID está destinado a ser un identificador único, para no tener un
problema con comandos de terceros similares. Adopte una nomenclatura obvia:
NOMEDOPLUGIN_NOMEDOCOMANDO, por ejemplo.
Small Image: abra Paint brush, cree una imagen de 16x16 pixeles. Luego haga clic en
este campo y haga clic en el botón ( ) para buscar dónde lo guardó.
Large Image: ídem, pero la imagen debe ser de 32x32 píxeles. En las pruebas que hice,
AutoCAD cambia el tamaño apropiado para mostrarla en la pantalla. Luego, asegúrese
de que sea legible una vez que el menú esté listo.
Cree todos los comandos que le parezcan interesantes para que aparezcan en su menú,
barra de comandos ribbon.
Toolbars
Después de crear los comandos, puede comenzar creando una barra de comandos:
Figura 403 - Agregar Toolbar
Figura 404 – Agregar comandos en la barra de herramientas
Para agregar los comandos, haga clic en el cuadro Comand List y arrastre sobre la barra
la Toolbar en el cuadro superior.
Menús
Figura 405 - Crear menús
El proceso es idéntico a la creación de las toolbars. Solo tenga cuidado de seleccionar el
nodo correcto en el cuadro “Customizations in Main File”
Obviamente, asegúrese de que los comandos se estén creando en el archivo CUIX
correcto.
Ribbon
El proceso de creación de ribbons es un poco diferente. Primero, debe crear los paneles y
luego crear las ribbons, insertar los paneles en ellos.
Figura 406 - Crear un panel
El panel formatea el layout de los botones. Para que se vea genial, debes distribuir líneas
o incluso subpaneles.
Intente hacer clic con el botón derecho del mouse en los íconos de TREEVIEW (¡¡¡a-
há!!!). Ver los posibles comandos.
Después de crear el panel, puede crear la ribbon e insertar el panel en ella:
Figura 407 -Agregar TABS
Vea cómo CUIX está listo:
Figura 408 - CUIX terminado
Figura 409 - Menús, ToolBars e Ribbon del curso de programación
La mejor manera de entender cómo hacer el archivo CUIX es experimentar.
Vea que el marco superior derecho siempre muestra una vista previa de lo que configura:
Figura 410 - Preview de la edición de la barra de herramientas
Dejé un comando importante atrás, la ayuda. Sí, necesitas tenerlo.
Vuelva a Visual Studio y cree un comando para abrir la ayuda.
Figura 411 – Agregue la información e “información de Assenbly"
Ahora, cree dos comandos más:
Figura 412 - Comandos CURSOAPIABOUT y CURSOAPIAJUDA (archivo 01)
Al ejecutar el comando CURSOAPIABOUT:
Figura 413 - Comando CURSOAPIABOUT
Sí, estos nombres raros tienen una razón: hacer pensar en estandarizar los nombres de los
comandos. A lo largo del curso mezclé palabras en inglés y español, y, a veces, combiné
las dos. ¿Le parece una práctica cuestionable? ¡Qué bien¡, ¡Ahora no olvidará esta frase
perdida en el medio de todo el texto!
Html Help WorkShop
Es el programa que crea el archivo CHM con la ayuda de su plugin. Sí, hay esta es
bastante simple y práctica.
Figura 414 – Comience por crear un proyecto
Figura 415 – Definir el nombre del proyecto
Mientras crea un nuevo proyecto, es probable que todavía no tenga ningún archivo listo,
por lo tanto, simplemente haga clic en “Siguiente” hasta que el programa vuelva a
aparecer.
Una vez allí haga clic en la pestaña “Contents”. Puede ser que él pida crear uno.
Aceptar:
Figura 416 – Creación de Contents
Se le pedirá la ubicación de guardado. Informar.
Haga clic en el botón Nuevo ( ) y cree un archivo HTML.
Guardar haciendo clic en el botón ( ).
Haga clic en el botón Insert la Page
Figura 417 - Insertar página en el índice
Figura 418 – Agregar una presentación
Tenga en cuenta que la presentación es un resumen de lo que hace su plugin, la
motivación para haberlo hecho, de todos modos...
El ícono de la carpeta ( ) inserta un tema que tendrá hijos, por ejemplo, una página
para comandos.
Use las flechas ( ) si necesita reordenar el índice.
Figura 419 - Estructura de contenido
Tenas que deberían existir
1. Presentación
2. Instalación
3. Desinstalar
4. Lista de comandos
5. Apoyo
6. Actualizar registro
Tenga en cuenta que esta es una lista de tenas que agrego a los programas. Usted es libre
de elegir los temas que desea publicar.
Importante:
¿Cómo sé que hacer clic en el botón de ayuda en esta pantalla abrirá la ayuda en esta
pantalla abrirá la ayuda en la página correcta?
Figura 420 – Vinculación de ayuda con el botón de ayuda forms
Simplemente ingrese el nombre del archivo HTML que generó para obtener ayuda.
Ejemplo:
El comando que muestra esta pantalla es LISTARCOGODATAGRIDVIEW
En el evento CLIC del botón de ayuda, haga lo siguiente:
Figura 421 - Edición del método Barras_ItenClicked del form LIstarCogoPoints (archivo 24)
Tenga en cuenta que obtener la ruta del archivo de ayuda será muy repetitivo. Cree un
método que sea accesible para todos los lugares que necesitan el nombre del archivo.
¿Notas el tercer argumento del método, Help.ShowHelp? es el nombre del archivo
HTML que contiene la ayuda que necesito y este archivo está dentro del archivo CHM
(el archivo de ayuda en sí).
AutoLOAD
¿Alguna vez pensó si era posible que nuestro plugin se cargara después de intentarlo a
través de NETLOAD?
Si es posible. ¿Recuerdas cuando hicimos el comando AmarrarPontoNaSuperficie?
Implementa la interfaz IExtensionApplication, que realiza lo que pones en el método
Initialize:
Figura 422 - Método Initialize (archivo 26)
Muy bien. Ya tenemos la mitad de la solución.
Ahora falta la parte que realmente instala el programa.
Primero lea este link:
https://www.keanw.com/2009/05/creating-denand-loading-entries-automatically-for-
your-autocad-application-using-net.html
Solo el link se explica por sí mismo.
https://www.keanw.com/2009/05/creating-demand-loading-entries-automatically-for-your-autocad-application-using-net.html
¡Bueno, copié su código y lo puse en todos mis programas en DOTNET!
Figura 423 - Implementación del código Initialize (archivo 35)
No hay misterio. La idea es escribir algunas claves en el registro de Windows:
Figura 424 - Claves en el registro de Windows
Método que devuelve la lista de comandos implementados de la DLL.
Figura 425 – Subrutinas que devuelven la lista de comando implementados en la DLL (archivo 35)
¡Reflexión al fin!
Solo por curiosidad, vaya al registro de Windows y vea la cantidad de comandos que
creamos en este curso. Abre la llave:
\HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R23.1\ACAD-
3000:409\Applications\CursoApiCivil3D\Commands
Importaciones:
Se requieren varios IMPORTS para que el programa funcione. Y eso no es todo. Mire la
línea 14, necesita compilar diferentes DLL para diferentes versiones de C3D
Figura 426- Importaciones necesarias (archivo 35)
Vea cómo se verá NETLOAD ahora:
Figura 427 - NETLOAD ahora informa que cargó la DLL
Tenga en cuenta que, de ahora en adelante, ya es necesario NETLOAD cada vez.
Cuando el usuario abre AutoCAD, la información registrada en la clave:
\HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R23.1\ACAD-
3000:409\Applications\CursoApiCivil3D\Commands
(para Civil 3D 2020, esta clave cambia a otras versiones)
Causan que AutoCAD cargue la DLL por sí mismo.
Compilación en otras versiones
Mira, no es porque Autodesk creó una nueva versión de Civil 3D que su código dejará de
funcionar
A veces agrega nuevas funciones a la API y vas felizmente y crea un comando genial.
Cuando compila, descubre que no se ejecutará en versiones anteriores. en TBN2C3D
hay mucho de esto:
Figura 428 - Comandos incompatibles con versiones anteriores
La forma menos costosa de decirle al compilador que desea cambiar el código en tiempo
de compilación es agregar las directivas:
Figura 429 - Directivas de compilación
En el ejemplo TBN2C3D, las versiones anteriores solo muestran un mensaje que dice
queson incompatibles.
¿Y cómo sé que son versiones diferentes?
Definición de constantes personalizadas:
Figura 430 – Definición de constantes personalizadas
Recuerda:
1. Consulte las DLL de AutoCAD y Civil 3D en la versión que va a compilar
2. Definir .NET Framework
3. Adapte el código a tiempo para la versión de AutoCAD / Civil 3D utilizando
las directivas de compilación.
Autodesk Exchange Apps / TBN2NET
De todo lo que se ha expuesto aquí espero sinceramente que hayas aprendido algo.
Traté de pasar las mejores prácticas de programación a AutoCAD y Civil 3D que aprendí
durante una carrera de 20 años.
No tomé un curso de programación. Incluso comencé una licenciatura en informática,
pero eso no era para mí. Pero eso no fue en vano, ¡finalmente entendí lo que era la
Orientación de Objetos, allí!
Hoy tengo un sitio web, con los programas que desarrollé, espero que lo visiten:
(https://tbn2net.com):
Figura 431 – Site TBN2NET: https://tbn2net.com
Quizás en algún momento en el futuro podamos ser socios en los negocios, ¡así que hay
ese espacio reservado para eso en la esquina inferior izquierda!
https://tbn2net.com
https://tbn2net.com
Tal vez quieras ganar algunos caracoles vendiendo tu programa en la tienda de
Autodesk (https://apps.autodesk.com/):
Figura 432 – Tienda de aplicaciones de Autodesk
Es posible que no le interese vender, solo desarrollar para si propio uso o el de su
empresa. Pero esté atento: ¡Sus programas tienen derechos de autor! Si los escribe en la
compañía le está pagando por ello, entonces posee los derechos de su programa. Ya tuve
este “placer”. Abandone dos programas muy grandes que serían excelentes. Hoy su
código está en algún servidor de correo electrónico no utilizado. Eso es bastante
aburrido.
En cualquier caso, asegúrese de documentar su código. No lo deje sin AYUDA y pierda
tiempo tomando prints y dibujando íconos en PAINT. Recuerde siempre: el usuario es
complicado, siempre es su culpa. ¡pero no lo dejes en un arbusto sin un perro!!!!
https://apps.autodesk.com/
Figura 433 - https://vidadeprogramador.com.br/2018/02/20/reproduzindo-o-bug/
https://vidadeprogramador.com.br/2018/02/20/reproduzindo-o-bug/
Programas de ejemplos
En el material, consulte el proyecto de visual Studio por el número de archivo VB en la
lista a continuación.
Archivo
VB
Comando Descripción, tenas cubiertos
01 HELLOWORLD ejemplo inicial
CURSOAPIAJUDA Abre la ayuda (archivo CHM)
CURSOAPIABOUT Información actual de la versión del plugin
02 VERSAOAUTOCAD Información de la versión CAD
03 DOCUMENTOATUAL Información sobre el documento
04 PEDEDISTANCIA Ejemplo de uso de Editor.GetDistance
PEDENUMERO Ejemplo de uso de Editor.GetInteger
PEDENUMEROREAL Ejemplo de uso de Editor.GetDouble
PEDIRSTRING Ejemplo de uso de Editor.GetString
PEDIROPCAO Ejemplo de uso de Editor.GetKeywords
PEDIRCOORDENADA Ejemplo de uso de Editor.GetPoint
05 CLICARENTIDADE Ejemplo de uso de Editor.GetEntity
06 LISTARCOGOPOINTS Lista cogo points en la línea de comando
07 CRIARPONTOSALEATORIOSVB Crear puntos aleatorios para probar las
selecciones de filtro
08 COMANDOQUALQUER Template de comando (Using)
COMANDOQUALQUER2 Template de comando (Dispose)
09 OBTERPIS Ejemplo de “anidamiento” de transacciones
10 CRIARDOCUMENTO Crea un DWG de Civil 3D
11 ABRIRDOCUMENTO Abra un documento de Civil 3D e inserte
puntos
12 LISTARLAYOUTS Enumerar las propriedades de los layouts de
archivo en una carpeta
13 LERPROPRIEDADEOBJETOS Abrir objetos para editar
14 LISTAROBJETO Nociones de reflexión
15 LISTARATRIBUTOSDEPROPRIEDADES Nociones de reflexión en atributos
16 DOTNETPROPERTIES Enumerar propriedades en interfaces COM y
DOTNET y mostrar en PropertyGrid
17 CRIARALGUNSOBJETOS Crear iterativamente objetos con preguntas en
la línea de comando
18 CRIARPERFIS Crear perfiles de superficie
19 LIGARPONTOS Conecte los puntos que se espera que estén al
borde de una calle
20 LISTAPOINTGROUP S Ejemplo de uso de TREEVIEW
21 ejemplo de DataGridView
22 CADASTRODEREDES Registro de red para demostrar la creación de
Pipenetwork, manipulación de la Parts List y
lecturas de datos en Excel
23 Cómo pegar datos en Excel de manera más
eficiente
24 LISTARCOGODATAGRIDVIEW Ejemplo complenento de DataGridView con
“databinding”
25 PG4ALL Manipulación de PointGroup con queries
26 AMARRARPONTONASUPERFICIE Ejemplo completo de manejo de eventos para
actualizar la dimensión de un texto de
acuerdo con su posición y una superficie
27 CONVERTEEN3D Ejemplo de crear una polilínea 3D usando
elevaciones de una superficie
ATUALIZAPOLY3D Sugerencia sobre cómo podría usar eventos
para automatizar
28 CORTARALINHAMENTO Esquena de comando que BREAK en una
alineación
29 LISTARESTACAS Enumera las apuestas de una alineación por
tipo de apuesta (geometría, inundación,
peraltes, etc.)
30 CRIARPERFILDEPOLILINHA Ejemplo de manipulación profileview, con
conversión de posición X, Y para replanteo,
offset
31 NSFEATURELINE Nota de servicio de featureline
32 OBTERCONFRONTANTESDELOTES Manipulación de parcels para obtener
confrontantes.
33 MESCLACORREDORES Manipulación de corredores, utilizando como
ejemplo la mezcla de corredores
CRIARSUPERFICIENOCORREDOR Cómo crear superficies de pasillo
34 CRIARNOTADELOCACAO Cómo obtener datos de las secciones
calificadas (sin samplelinegroup, solo pasillo)
35 INICIALIZAÇÃO Cómo crear una AutoLOAD
Figura 434 - Lista de archivos de código VB con los comandos creados
Dudas
a) Estructuras de programación
b) Orientación a objetos
c) AutoCAD
d) Civil 3D
e) Excel
f) Windows Forms
g) Ayuda
h) CUIX
Cierre
¡Eso es todo, gracias a los participantes que han aguantado hasta ahora! Sinceramente
espero que sea de gran beneficio para todos. Como nadie está hecho de hierro y en esta
ciudad también hay cerveza de barril, ¡ahora es el momento!
Figura 435 – Cierre
	Introducción
	Estructuras de programación
	Instrucción Sub
	Instrucción Function
	If
	For
	While
	DO
	Case/Switch
	Try
	Requisitos
	Civil 3D
	Visual Studio
	Excel
	HTML Help WorkShop
	Referenciar DLLs
	Comprensión de la orientación a objetos
	Tipagen
	Público/Privado/Distribuido
	Clase/Módulos/Estructuras
	Fields (campos)
	Properties (Propriedades)
	Métodos
	Instancia
	Herencia
	Atributos
	Enumeradores
	Constantes
	Hello World
	Crear Comando
	Acceda a AutoCAD
	Acceda al documento actual
	Poniendo todo junto...
	Importaciones
	Entrada de datos
	Distancias
	Número entero
	Número real
	Texto
	Palabras clave (Keywords)
	Coordenadas
	Entidades (líneas, textos etc.)
	Selecciones
	Crear filtros para la selección.
	Transacciones
	Crear
	Nido
	Finalizar
	Abortar
	Acceder la base de datos de AutoCAD
	Documentos
	Crear
	Documento Actual
	Abrir
	Salvar
	Model Space
	Objetos
	ObjectID
	DBObject
	Entity
	Leer propriedades
	Escribir propriedades
	Nociones de reflexión
	Listar todas las propriedades
	Listar todos los atributos
	Creando objetos
	Punto
	Línea
	Polilínea
	Texto
	Bloque
	Nociones de ergonomía del software
	a) Definición
	b) Ventajas:
	c) Desventajas:
	d) Principios Básicos:
	1 – Esfuerzo mínimo del Usuario:
	2 - Menoria Mínima de Usuário:
	3 - Frustración Mínima:
	4 – maximice el uso de patrones y hábitos:
	5 - Máxima tolerancia para diferencias humanas:
	6 - Máxima tolerancia a los cambios ambientales:
	7 - Notificación inmediata de los problemas:
	8 – Máximo control de tareas por parte del usuario:
	9 – Máximo suporte para tareas:
	Nociones de Windows.Forms
	Crear Form
	Diagramación
	Controles
	Eventos
	Ok / Cancel / Help
	Poniendo todo junto: Comando CRIARPERFIS
	PropertyGrid
	TreeView
	DataGridView
	Manipular Form
	Interactua con la línea de comando
	Windows
	Excel
	Aplicación
	Libro de trabajo, hoja de cálculo
	Células
	Civil 3D
	Documento actual
	Prospector
	Cogo Points
	Point Groups
	Surfaces
	Alignments
	Sites
	Pipenetworks
	Corridors
	Settings
	Drawing Settings
	CUIX
	Toolbars
	Ribbon
	Html Help WorkShop
	AutoLOAD
	Compilación en otras versiones
	Autodesk Exchange Apps / TBN2NET
	Programas de ejemplos
	Dudas
	Cierre