Una aplicación de diseño basado en las gramáticas generativas y en la vida artificial (página 2)

Desde el punto de vista artístico, un software es una obra abierta, un proceso hipertextual que se apoya en la exploración, la multi linearidad y la autoría múltiple.

De esta última forma, la ausencia del autor y de la obra en el sentido tradicional típica de los hipertextos implica la necesidad de plantear algún mecanismo alternativo que provea lo que la obra tradicional ofrece; en efecto, se debe reintroducir por algún lado una nueva forma de autoría, sin la cual el lector se encontraría frente a un contexto totalmente indeterminado, que por ende no puede desarrollar ninguna experiencia estética significativa.

Este mecanismo alternativo es el software y su ingeniería es una forma de autoría artística de acuerdo a la estética propia de los hipertextos.

4.3 Para una filosofía del software

El software es un sistema complejo, en el cual actúan un medio de comunicación y un conjunto de saberes. Detrás de la interfaz, entonces, en el software existe siempre una entidad cultural que opera paralelamente a sus funciones operativas [Arns, 2004].

El reconocimiento de la naturaleza cultural del software revela sus responsabilidades sociales, ya que es esta cultura que condiciona el que hacer de los usuarios y que es, explícitamente o implícitamente, una forma de poder y de manipulación [Raskin, 2003] [McKenzie, 2004]. Es importante señalar, además, que dichos procesos aparecen en todas las formas con las cuales el software se presenta; en efecto la manipulación existe sea cuando el software es un producto comercial sea cuando es un producto libre y compartido, así que esta última forma no es necesariamente la solución a estos problemas. Por ende, hay que abordar aquellos procesos estructurales que forman la identidad del software y que son heredados por todos sus sabores: la complejidad inherente a todos los procesos interactivos, el problema del conocimiento y las interfaces.

Como primer objetivo, el diseño del software debe garantizar la equilibrada distribución y la transparencia del conocimiento: algoritmos y código deben ser entonces siempre abiertos y accesibles a los usuarios. Es más, el código se presentará a toda razón cómo un texto y tendrá que ser escrito para ser leído como tal.

En este sentido, hoy tenemos tanto la necesaria potencia del hardware cuanto adecuados entornos de programación, así que el problema es esencialmente de ingeniería de software y de diseño de interfaces. Para esta última tarea se debería quizás verificar, además de las características funcionales de las interfaces en los términos que hemos analizado, la misma razón de su existencia. De toda forma, estas deberían servir para fortalecer el proceso hermenéutico y mayéutico y para liberar el intercambio cultural y el acceso a los conocimientos dentro los sistemas autopoieticos del arte y de la educación. Por esta razón, es necesario que el diseño de las interfaces abandone la lógica del gadget tecnológico y de los efectos especiales, que produce solamente una estética retórica y distorsionada.

4.4 La interfaz

Por estas razones la interfaz, en una aplicación de diseño generativo, es determinante. Naturalmente aquí no estamos hablando del diseño de la interfaz en términos gráficos o estéticos. Las interfaces GUI, en efecto, no necesariamente son las más eficientes y en muchos casos complican los procesos y distraen al usuario.

En segundo lugar, las interfaces constituyen una pantalla que se interpone entre el usuario y las funciones del software, y por lo tanto constituyen un marco operativo que limita las opciones del usuario.

En tercer lugar la estructura de la interfaz y su navegabilidad constituye una estructura que define el proceso de diseño del usuario.

En este sentido la interfaz es una componente delicada porque puede facilitar o inhibir la creatividad de los usuarios. En el caso del diseño generativo, la interfaz debe posibilitar el acceso a todo el potencial del software, es decir, el usuario debe ser aquel que diseña los procesos en lugar de utilizar procesos ya diseñados.

Trabajando con gramáticas, el usuario debe tener una herramienta que facilite el diseño, la implementación y las pruebas de estas gramáticas, editarlas con facilidad, guardarlas en el disco, analizarlas, etcétera.

Estas opciones son esencialmente de interfaz, ya que el código correspondiente no presenta ninguna dificultad especial, eso es, no cuesta mucho implementarlas.

Sin embargo es muy difícil llegar a determinar los elementos de esta interfaz y su arquitectura. Para optimizar estos aspectos el diseñador del sistema y el programador deben ser diseñadores. Entonces se llega a un diseño eficiente mediante la experimentación de cada solución. La experiencia y las pruebas determinan la estructura final de la interfaz.

4.3 Una herramienta intermedia

Desde el punto de vista educativo, el arte generativo, la estética de la obra abierta y los hipertextos constituyen la razón más importante para una alfabetización informática alternativa: de acuerdo a estas premisas estéticas, la herramienta digital no es un producto que se utiliza como una receta operativa, sino es un sistema abierto de recursos para crear diferentes soluciones experimentales. En otras palabras, una real alfabetización informática para los artistas y los diseñadores no significa difundir productos comerciales, sino capacitar en el diseño y desarrollo de software personalizado y original. Para esto, desde el punto de vista educativo, tenemos dos alternativas: optar para la programación pura o utilizar herramientas intermedias. Este ultimo caso permite reubicar los límites tradicionalmente definidos para usuarios y programadores de una forma más simple e intuitiva.

La necesidad de personalizar el software aparece casi de inmediato cuando se necesita adaptar las funciones de una aplicación a exigencias especiales. En contextos de diseño, por ejemplo en el campo de la animación tridimensional o en la arquitectura, esta exigencia se manifiesta casi siempre, así que algunos paquetes aplicativos ofrecen la posibilidad de personalizar las funciones del software mediante scripts en algún lenguaje de programación interno. Estas opciones permiten que la programación pueda ser aprovechada por un mayor número de usuarios, y constituyen una excelente puerta de entrada al mundo de la programación profesional.

Por otro lado, se puede pensar en herramientas que ofrezcan la libertad de la programación sin exigir todo el dominio de sus complejidades, como los entornos visuales de programación para aplicaciones multimedia.

Una herramienta intermedia, entonces, es aquella que a través de un oportuno diseño de la interfaz, permite que un usiario no programador pueda aprovechar de las posibilidades que solo la programación ofrece.

Las gramáticas generativas y el diseño paramétrico son ejemplos de herramientas intermedias.

5 Implementación

5.1 Objetivos

Objetivos cualitativos

• Debe permitir al usuario el control completo sobre la programación de los diseños, las gramáticas y las primitivas gráficas.

• Debe permitir una dinámica de diseño flexible, abierta e interactiva

• Debe facilitar el aprendizaje de las técnicas de diseño generativas y la experimentación

• Debe apoyar y no condicionar el desarrollo creativo del usuario

Objetivos cuantitativos

• Costo bajo

• Ocupa poco espacio una vez instalado

5.2 Requerimientos

Requerimientos cualitativos

• Debe permitir el diseño de gramáticas personalizadas

• Debe permitir editar gramáticas y modificarlas interactivamente

• Debe permitir el control paramétrico del los diseños

• Debe soportar la visualización en plano y en perspectivas desde todo punto de vista

• Debe integrarse, conectarse y ser compatible con las principales aplicaciones comerciales y de uso libre de diseño 3D como 3DSMax, VRML, POVRay, Blender

Requerimientos cuantitativos

• Debe manejar por lo menos 6 niveles de recursividad

• Debe manipular conjuntos por lo menos de 50000 objetos

• Debe generar y visualizar los modelos en menos de 15 segundos

• Debe tener en librería por lo menos 10 primitivas y macros

5.3 Carcaterísticas prioritarias

Esta aplicación no apunta a la productividad, sino a la investigación y a la experimentación. La exigencia primaria es entonces que sea flexible y abierta, y que los usuarios puedan integrar el sistema mediante plug in o funciones personalizadas. El diseño orientado a objetos es aquí el más indicado. Se deberá entonces proporcionar clases, plantillas y librerias para que el usuario las pueda utilizar y personalizar facilmente.

Se utilizarán dos técnicas generativas: los sistemas L (L-Systems) y los Autómatas Celulares. La base será un sistema de gramaticas generativas, que el usuario podrá diseñar, personalizar, modificar en lo que son los elementos gramaticales y sintácticos. Las reglas deberán ser diseñadas por el usuario, sobre la base de plantillas y ejemplos que serán incluidos en la documentación y en la ayuda de la aplicación.

El modelo de diseño es en realidad una simulación de un proceso biológico donde se pueden establecer la naturaleza y los genes de los organismos. Un objeto generativo por lo tanto no existe como datos geometricos, sino como código genético que determina su desarrollo. El usuario deberá poder parametrizar también el proceso de crecimiento del objeto y de sus partes en modo interactivo y en tiempo real.

5.4 Características generales

5.4.1 Restricciones sobre el sistema y el proyecto

• No hará cálculo estructural ni cuotas, etc.

• No hará rendering ni animaciones.

• Permitirá leer un numero reducido de formatos gráficos (TGA y BMP)

5.4.2 Funciones de los subsistemas componentes

• Módulo de visualización y edición del objeto

• Módulo de generación de los objetos (L-Systems+Cellular Autómata).

• Modulo de parser a las primitivas gráficas

• Modulo de diseño de las gramaticas generativas

• Modulo de gestión de archivos

• Modulo de ayuda y ejemplos

5.4.3 Características del usuario

El usuario típico podría ser un arquitecto, un diseñador industrial, un diseñador gráfico, un artista visual. Se requieren algunos conocimientos básicos de diseño por computadora y nociones básicas de informática general. Se requieren también conocimientos básicos de técnicas generativas, fractales, IFS, L:Systems y Cellular Automata.

Es indicado para docentes, investigadores y estudiantes de dichas especialidades.

5.4.4 Entorno de desarrollo, operación y mantenimiento

El desarrollo de la aplicación se hará en VisualBasic 6.0 y paralelamente se hará una implementación orientada a objetos en C++.

La aplicación será compatible Windows, y requiere una configuración estandard de la computadora, sin embargo el sistema deberá tener las siguientes carácterísticas mínimas:

• Pentium III a 500 MHz o equivalente

• 256 Mb RAM

• 50 MB de espacio en el disco duro

• Resolución de pantalla 1024×768 en colores verdaderos

5.4.5 Criterios de aceptación

• Limpieza y claridad de la interfaz y de los procesos de diseño. El diseño generativo se asemeja realmente a un lenguaje de programación. Sin embargo el diseño no es tan lineal, así que las diferentes aproximaciones pueden generar un flujo de trabajo que puede confundir al usuario.

• Calidad del feedback con el usuario.

• Simplicidad y flexibilidad.

• Compatibilidad con los más difundidos sistemas de diseño tridimensional (3Dmax, POVRay, etc.).

Eficiencia de las herramientas para visualizar los procesos y sus componentes. Un objeto generativo s epuede volver muy complejo y puede resultar dificil entender y diferenciar sus partes.

5.5 Estrategias de solución

5.5.1 Middleware.

Una herramienta de diseño deberá ser abierta y personalizable. Esto no se refiere a implementar una interfaz modular, sino en el diseño de los mismos procesos. Las técnicas generativas no son recetas que se aplican en modo repetitivo, sino metodologías personales que entonces necesitan capacidades de programación. Por lo tanto se deberá implementar un sistema que está entre la filosofía de una aplicación tradicional y un entorno de programación.

5.5.2 Flexibilidad e interactividad.

Una de las ventajas que una aplicación de diseño generativo se refiere a la metodología emergente, abierta e interactivas que las herramientas generativas proporcionan, facilitando así una aproximación sistemica a los problemas del diseño. Dicha posibilidad permite integrar, en modo organico, las complejidades inherentes a los diferentes contextos a los cuales el diseño se refiere. Elementos prexistentes al diseño como las estéticas, las restricciones urbanísticas y ecológicas, los factores sociales y culturales pueden, gracias a la tecnología de la información, ser aprovechados más facilmente.

8.3 Interdisciplinariedad.

En segundo lugar, las herramientas generativas relacionan el diseño con los procesos naturales, tanto en los aspectos constructivos (bioingeniería, bioarquitectura) cuanto en los aspectos formales. Aqui las simulaciones y los modelos matemáticos permiten aprovechar creativamente de la complejidad y de la belleza de la naturaleza, ampliando notablemente las posibilidades creativas del diseñador.

8.4 Eficiencia.

Finalmente, la velocidad operativas de los modernos ordenadores permite al diseñador concentrarse en los aspectos estéticos y conceptuales y de experimentar rapidamente diferentes soluciones proyectuales ya que el proceso generativo se encarga de generar las diferentes variaciones de los diseños.

6 Codigo fuente

La codificación no presenta aspectos particularmente difíciles, sin embargo es complicado por la grande cantidad de parámetros que involucran todo el proceso de diseño, parámetros que deben ser pasados a las diferentes funciones.

En efecto el problema del código de un software generativo está en el diseño de los diferentes componentes, es decir en la arquitectura.

En este sentido la programación a objetos presenta ventajas indudables, porque la arquitectura se puede implementar en el diseño de las clases y es posible resolver los problemas más algorítmicos en los métodos de cada clase.

Para implementar el sistema se ha escogido el entorno de programación VisualBasic, entorno que sin ser propiamente orientado a los objetos como C++ o Java, permite igualmente una aproximación parecida ya que los elementos de la interfaz son considerados objetos, con sus atributos y métodos.

Siendo un software open source resulta muy importante como el código está escrito, los comentarios, etc.

En seguida se presentarán algunas porciones del código, las más significativas para entender la lógica subyacente.

El código completo está disponible en el CDROM anexado.

6.1 Codigo VisualBasic

Public Sub ParserR(X As Double, Y As Double, Z As Double, Alpha1 As Double)

'parser de una función random, procesa una cadena Rc (secuencia de simbolos) global

'esta cadena se genera mediante reglas definidas por el usuario

'es una secuencia de "a" y "F", donde F mueve el cursos sin dibujar nada

Dim Char As String

Dim mvX As Boolean, mvY As Boolean, mvZ As Boolean

Dim NP As POINT

'recuperamos la dirección del cursor desde los atributos globales

mvX = MoveX: mvY = MoveY: mvZ = MoveZ

'procesamos la función en la cadena Rc

For I = 1 To Len(Rc)

'empezamos a leer el caracter

Char = Mid$(Rc, I, 1)

'procesamos dependiendo del caracter

If Char = "F" Then

'recibimos el angulo de rotación Alpha1, calculamos la nueva posición

If mvX = True Then

X1 = X + Size: Y1 = Y: Z1 = Z

'rotación eje Z

NP = RotateZ(X, Y, X1, Y1, Alpha1)

X1 = NP.X

Y1 = NP.Y

ElseIf mvY = True Then

X1 = X: Y1 = Y + Size: Z1 = Z

'rotación eje Z

NP = RotateZ(X, Y, X1, Y1, Alpha1)

X1 = NP.X

Y1 = NP.Y

ElseIf mvZ = True Then

X1 = X: Y1 = Y: Z1 = Z + Size

'rotación eje Y

NP = RotateY(X, Z, X1, Z1, Alpha1)

X1 = NP.X

Z1 = NP.Z

End If

'actualizamos la posición del cursor

X = X1: Y = Y1: Z = Z1

ElseIf Char = "a" Then

NumObjects = NumObjects + 1 'se crea un objeto

If mvX = True Then

X1 = X + Size + Offset: Y1 = Y: Z1 = Z

'rotación eje Z

NP = RotateZ(X, Y, X1, Y1, Alpha1)

X1 = NP.X

Y1 = NP.Y

ElseIf mvY = True Then

X1 = X: Y1 = Y + Size + Offset: Z1 = Z

'rotación eje Z

NP = RotateZ(X, Y, X1, Y1, Alpha1)

X1 = NP.X

Y1 = NP.Y

ElseIf mvZ = True Then

X1 = X: Y1 = Y: Z1 = Z + Size + Offset

'rotación eje Y

NP = RotateY(X, Z, X1, Z1, Alpha1)

X1 = NP.X

Z1 = NP.Z

End If

'dibuja el objeto del simbolo a

Call Draw2(1, ADrawMode, X, Y, Z, X1, Y1, Z1, Alpha1)

'actualizamos la posición del cursor

X = X1: Y = Y1: Z = Z1

'el offset se pone a cero porque ya compensó el : o |

Offset = 0

End If

Next

End Sub

Public Function RotateZ(rX As Double, rY As Double, rX1 As Double, rY1 As Double, Alpha As Double) As POINT

'POINT es una estrucutra de 3 double

'rotación alrededor del eje Z

'hay funciones analogas para rot X y rot Y

'rX y rY es el centro de rotación corresponde al punto inicial, rX1 rY1 es el punto a rotar

Dim OCx As Double, OCy As Double, Radio As Double

Dim Tmpx As Double, Tmpy As Double

'traslado en la origen

OCx = rX1 – rX: OCy = rY1 – rY

'hago la rotación en la origen

Tmpx = OCx * Cos(Alpha) + OCy * Sin(Alpha)

Tmpy = -OCx * Sin(Alpha) + OCy * Cos(Alpha)

'traslado a la posición y devuelvo

RotateZ.X = Tmpx + rX

RotateZ.Y = Tmpy + rY

End Function

Public Sub Draw2(Color As Integer, Modo As Integer, X As Double, Y As Double, Z As Double, X1 As Double, Y1

As Double, Z1 As Double, Alpha As Double, DSize As Double)

Dim Angle As Double

Dim Angle1 As Double

Dim Pa As POINT, Pb As POINT, Pc As POINT, Pd As POINT 'vertices del cubo

Dim P2a As POINT, P2b As POINT, P2c As POINT, P2d As POINT

Dim Tmp As POINT, CCx As POINT, CCy As POINT, CC2x As POINT, CC2y As POINT

Dim aX As Double, aY As Double

Dim Xp As Double, Yp As Double, Zp As Double

Dim SizeP As Double

Dim MultiS As POINT

Dim Red As Integer, Green As Integer, Blue As Integer

'dibujamos según la primitiva de cada símbolo

Select Case Modo

Case 1 'línea ………………………………………………………………………………………………………

'dibuja linea, se traslada de StartX y StartY

X0 = StartX: Y0 = StartY 'coordenadas del centro de proyección

'A = 390: B = 300: C = 2000: D = VPoint '0<D<C ojo para proyección Z

'A = 300: B = 100: C = 100: D = 500 ' 0

FCanvas.Circle (X0, Y0), 8, RGB(255, 0, 0)

CCx.X = Point3D(X, Y, Z).X: CCy.Y = Point3D(X, Y, Z).Y

CC2x.X = Point3D(X1, Y1, Z1).X: CC2y.Y = Point3D(X1, Y1, Z1).Y

FCanvas.Circle (CC2x.X, CC2y.Y), 3, RGB(255, 0, 0)

FCanvas.Line (CCx.X, CCy.Y)-(CC2x.X, CC2y.Y), RGB(0, 0, 0)

Case 4, 5 'cubo y ladder ………………………………………………………………………………………..

'recibe el tamaño de los objetos segun a(1), b(2), c, d, e

If Color = 1 Then MultiS = MultiSa

If Color = 2 Then MultiS = MultiSb

If SavePOV = True Then

Call WriteSpherePOVRay(X, Y, Z, Size) 'función blob

If Modo = 4 Then Call WriteCubePOVRay(X1, Y1, Z1, DSize, Alpha) 'función cubo

If Modo = 5 Then Call WriteLadderPOVRay(X1, Y1, Z1, DSize) 'función ladder

ElseIf SaveMax = True Then

If Modo = 4 Then Call WriteCubeMax(X, Y, Z, DSize) 'función cubo

If Modo = 5 Then Call WriteLadderMax(X, Y, Z, DSize) 'función ladder

End If

'dibuja cubo en perspectiva

FCanvas.Circle (X0, Y0), 8, RGB(255, 0, 0)

'recibo el punto final X1,Y1,Z1

SizeP = DSize / 2 'el tamaño del segmento

'punto central X1 Y1 ya tiene rotación

CCx.X = Point3D(X, Y, Z).X: CCy.Y = Point3D(X, Y, Z).Y

CC2x.X = Point3D(X1, Y1, Z1).X: CC2y.Y = Point3D(X1, Y1, Z1).Y

FCanvas.Circle (CC2x.X, CC2y.Y), 3, RGB(255, 0, 0)

FCanvas.Line (CCx.X, CCy.Y)-(CC2x.X, CC2y.Y), RGB(255, 0, 0)

'cara adelante

'1 punto

Xp = X1 – SizeP: Yp = Y1 + SizeP * MultiS.Y: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pa.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pa.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'2 punto

Xp = X1 + SizeP: Yp = Y1 + SizeP * MultiS.Y: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pb.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pb.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'3 punto

Xp = X1 – SizeP: Yp = Y1 – SizeP: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pc.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pc.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'4 punto

Xp = X1 + SizeP: Yp = Y1 – SizeP: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pd.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pd.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'cara atras

'5 punto

Xp = X1 – SizeP: Yp = Y1 + SizeP * MultiS.Y: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2a.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2a.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'6 punto

Xp = X1 + SizeP: Yp = Y1 + SizeP * MultiS.Y: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2b.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2b.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'7 punto

Xp = X1 – SizeP: Yp = Y1 – SizeP: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2c.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2c.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'8 punto

Xp = X1 + SizeP: Yp = Y1 – SizeP: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2d.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2d.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'dibujando color según el simbolo

If Color = 1 Then

Red = 0: Green = 0: Blue = 0

ElseIf Color = 2 Then

Red = 150: Green = 0: Blue = 0

End If

'cara de adelante

FCanvas.Line (Pa.X, Pa.Y)-(Pb.X, Pb.Y), RGB(Red, Green, Blue)

FCanvas.Line (Pa.X, Pa.Y)-(Pc.X, Pc.Y), RGB(Red, Green, Blue)

FCanvas.Line (Pc.X, Pc.Y)-(Pd.X, Pd.Y), RGB(Red, Green, Blue)

FCanvas.Line (Pd.X, Pd.Y)-(Pb.X, Pb.Y), RGB(Red, Green, Blue)

'cara de atras

FCanvas.Line (P2a.X, P2a.Y)-(P2b.X, P2b.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2a.X, P2a.Y)-(P2c.X, P2c.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2c.X, P2c.Y)-(P2d.X, P2d.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2d.X, P2d.Y)-(P2b.X, P2b.Y), RGB(Red, Green, Blue)

'caras laterales

FCanvas.Line (P2a.X, P2a.Y)-(Pa.X, Pa.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2b.X, P2b.Y)-(Pb.X, Pb.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2c.X, P2c.Y)-(Pc.X, Pc.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2d.X, P2d.Y)-(Pd.X, Pd.Y), RGB(Red, Green, Blue)

Case 6 ' pilastro …………………………………………………………………………………………………………….

'recibe el tamaño de los objetos segun a(1), b(2), c, d, e

If Color = 1 Then MultiS = MultiSa

If Color = 2 Then MultiS = MultiSb

If SavePOV = True Then

Call WritePilPOVRay(X1, Y1, Z1, Size, MultiS.Y, Alpha) 'función pilastro

ElseIf SaveMax = True Then

End If

'dibuja pilastro en perspectiva

FCanvas.Circle (X0, Y0), 8, RGB(255, 0, 0)

'recibo el punto final X1,Y1,Z1

SizeP = Size / 2 'el tamaño del segmento

'puntos centrales X1 Y1 ya tiene rotación

CCx.X = Point3D(X, Y, Z).X: CCy.Y = Point3D(X, Y, Z).Y

CC2x.X = Point3D(X1, Y1, Z1).X: CC2y.Y = Point3D(X1, Y1, Z1).Y

FCanvas.Circle (CC2x.X, CC2y.Y), 3, RGB(255, 0, 0)

FCanvas.Line (CCx.X, CCy.Y)-(CC2x.X, CC2y.Y), RGB(255, 0, 0)

'cara adelante

'1 punto

Xp = X1 – SizeP: Yp = Y1 + Size * MultiS.Y – SizeP: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pa.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pa.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'2 punto

Xp = X1 + SizeP: Yp = Y1 + Size * MultiS.Y – SizeP: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pb.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pb.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'3 punto

Xp = X1 – SizeP: Yp = Y1 – SizeP: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pc.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pc.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'4 punto

Xp = X1 + SizeP: Yp = Y1 – SizeP: Zp = Z1 + SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

Pd.X = Point3D(Tmp.X, Tmp.Y, Zp).X: Pd.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'cara atras

'5 punto

Xp = X1 – SizeP: Yp = Y1 + Size * MultiS.Y – SizeP: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2a.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2a.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'6 punto

Xp = X1 + SizeP: Yp = Y1 + Size * MultiS.Y – SizeP: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2b.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2b.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'7 punto

Xp = X1 – SizeP: Yp = Y1 – SizeP: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2c.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2c.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'8 punto

Xp = X1 + SizeP: Yp = Y1 – SizeP: Zp = Z1 – SizeP

Tmp = RotateZ(X1, Y1, Xp, Yp, Alpha)

P2d.X = Point3D(Tmp.X, Tmp.Y, Zp).X: P2d.Y = Point3D(Tmp.X, Tmp.Y, Zp).Y

'dibujando

If Color = 1 Then

Red = 0: Green = 0: Blue = 0

ElseIf Color = 2 Then

Red = 150: Green = 0: Blue = 0

End If

'cara de adelante

FCanvas.Line (Pa.X, Pa.Y)-(Pb.X, Pb.Y), RGB(Red, Green, Blue)

FCanvas.Line (Pa.X, Pa.Y)-(Pc.X, Pc.Y), RGB(Red, Green, Blue)

FCanvas.Line (Pc.X, Pc.Y)-(Pd.X, Pd.Y), RGB(Red, Green, Blue)

FCanvas.Line (Pd.X, Pd.Y)-(Pb.X, Pb.Y), RGB(Red, Green, Blue)

'cara de atras

FCanvas.Line (P2a.X, P2a.Y)-(P2b.X, P2b.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2a.X, P2a.Y)-(P2c.X, P2c.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2c.X, P2c.Y)-(P2d.X, P2d.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2d.X, P2d.Y)-(P2b.X, P2b.Y), RGB(Red, Green, Blue)

'caras laterales

FCanvas.Line (P2a.X, P2a.Y)-(Pa.X, Pa.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2b.X, P2b.Y)-(Pb.X, Pb.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2c.X, P2c.Y)-(Pc.X, Pc.Y), RGB(Red, Green, Blue)

FCanvas.Line (P2d.X, P2d.Y)-(Pd.X, Pd.Y), RGB(Red, Green, Blue)

End Select

End Sub

Public Function Point3D(X As Double, Y As Double, Z As Double) As POINT

X0 = StartX: Y0 = StartY 'coordenadas del centro de proyección

'proyección Z

If View = "Z" Then