TU ANUNCIO / YOUR PUBLICITY

AQUÍ PODRÍA ESTAR TU ANUNCIO: / HERE COULD BE YOUR AD E-mail

miércoles, 4 de febrero de 2015

Optimized GIS for linear projects XII (Layout drawing) / SIG optimizado para obras lineales XII (El dibujo del trazado)

Previamente: / Previously:

Optimized GIS for linear projects XI (Reading DB Testing and Inspection)
SIG optimizado para obras lineales XI (Lectura de BD de ensayos e inspección)

Índice Index

1.- Introducción
   1.1.- Situación actual
   1.2.- Problemática detectada y justificación del trabajo
   1.3.- Objetivos
   1.4.- Estructura del estudio
2.- Estado del conocimiento
   2.1.- La topografía en la obra lineal
      2.1.1.- Elementos básicos de documentación topográfica
      2.1.2.- Composición de los elementos básicos del trazado
      2.1.3.- Software habitual para definición de trazados en obras lineales
   2.2.- Formatos de dibujo
      2.2.1.- El formato dxf
      2.2.2.- El formato vml
      2.2.3.- El formato svg
      2.2.4.- El formato dwg
   2.3.- La información documentada de obra
   2.4.- Sistemas de información geográfica
      2.4.1.- Revisión de programas de gis estándar
      2.4.2.- Revisión de programas de gis que no siguen los estándares
   2.5.- Tipos de lenguajes de programación
      2.5.1.- Lenguajes de bajo nivel
      2.5.2.- Lenguajes de nivel medio
      2.5.3.- Lenguajes de alto nivel
   2.6.- Tipos de bases de datos
      2.6.1.- Sql, la comunicación entre bases de datos relacionales
   2.7.- Los sistemas de representación gráfica tradicionales
   2.8.- Normativa aplicable
3.- Solución
   3.1.- Lectura de elementos topográficos: trazado y estructuras
      3.1.1.- Elementos topográficos del trazado: eje
      3.1.2.- Elementos topográficos del trazado: terreno
      3.1.3.- Elementos topográficos del trazado: plataforma
      3.1.4.- Elementos topográficos anejos al trazado: las estructuras
   3.2.- Lectura de bases de datos
      3.2.1.- Bases de datos de ensayos e inspección
         3.2.1.1.- Bases de datos de ensayos, suelos
         3.2.1.2.- Bases de datos de ensayos, densidades
         3.2.1.3.- Bases de datos de ensayos, mezclas bituminosas
         3.2.1.4.- Bases de datos de ensayos, hormigones
         3.2.1.5.- Bases de datos de inspección, control
         3.2.1.6.- Bases de datos de inspección, diario
         3.2.2.- Bases de datos extras
         3.2.2.1.- Bases de datos extras, fotos
         3.2.2.2.- Bases de datos extras, definición de estructuras
         3.2.2.3.- Bases de datos extras, definición de la capa de firme
         3.2.2.4.- Bases de datos extras, localización extra
    3.3.- El dibujo del trazado
        3.3.1.- El dibujo en planta
        3.3.2.- El dibujo en perspectiva
            3.3.2.1.- El dibujo con superficies planas
            3.3.2.2.- El dibujo en el navegador
    3.4.- La unión del trazado con las bases de datos
        3.4.1.- La unión de las estructuras al trazado
        3.4.2.- La unión de los ensayos de suelos al trazado
        3.4.3.- La unión de los ensayos de densidades al trazado
        3.4.4.- La unión de los ensayos de hormigones al trazado
        3.4.5.- La unión de los ensayos de firmes al trazado
        3.4.6.- La unión de los inspecciones de control al trazado
        3.4.7.- La unión del diario al trazado
        3.4.8.- La unión de la documentación fotográfica al trazado
    3.5.- La unión de la documentación y otras inspecciones
        3.5.1.- La unión pasiva
        3.5.2.- La unión activa
    3.6.- Base matemática novedosa utilizada
        3.6.1.- Pseudo-bases de datos
        3.6.2.- Redes de taylor multidimensionales
        3.6.3.- Sintegrales
    3.7.- Consultas a la información a través de formularios
        3.7.1.- Formularios de ensayos de suelos
        3.7.2.- Formularios de ensayos de densidades
        3.7.3.- Formularios de ensayos de hormigones
        3.7.4.- Formularios de ensayos de firmes
        3.7.5.- Formulario de inspecciones, control
        3.7.6.- Formulario de inspecciones, diario
        3.7.7.- Formulario de inspecciones, fotos
        3.7.8.- Formulario de seguimiento en dxf y kml
    3.8.- Resultados finales
4.- Conclusiones, futuras lineas de trabajo
5.- Bibliografía


3.3.- EL DIBUJO DEL TRAZADO / LAYOUT DRAWING


Una vez que se parte de los datos del eje, el siguiente paso es trasladar las coordenadas locales de la plataforma y el terreno a unidades tridimensionales. Posteriormente el modelo tridimensional se debe transformar en un modelo visualizable en 2D. Dentro de los sistemas de representación posibles me decanto en dos; el dibujo en planta para su rápida equiparación con los planos en proyecto, y el dibujo en perspectiva. En este ultimo caso me decanto por la perspectiva cónica dado que a igualdad de complejidad con otros sistemas (axonométrica, isométrica...)  es más visual y realista.

Once the data is part of the shaft, the next step is to translate the local coordinates of the platform and three-dimensional field units. Subsequently, the three-dimensional model must be transformed into a displayable 2D model. Within possible representation systems I prefer two; The plan drawing for quick equalization with the plans in the pipeline, and perspective drawing. In the latter case I opted for the conical perspective as to equal complexity with other systems (axonometric, isometric ...) is more visual and realistic.


3.3.1.- EL DIBUJO EN PLANTA / DRAWING PLANT


El trazado equivalente en planta es bastante sencillo ya que sólo se necesita obviar el dato de la cota (excepto para el orden del dibujo y de esa manera conoce que va arriba y abajo) y la transformación requerida sólo es modificación de escala, giro y traslación:

The equivalent layout in plan is quite easy as only need to ignore the data dimension (except for the drawing order and thus knows that goes up and down) and the required transformation is only modification of scale, rotation and translation :



Pi · G · k + T = Pf

G: Aplica el giro del azimut real
k: Pasará de metros a píxeles de pantalla.
T: Colocará el punto de observación en el centro de la pantalla.

G: Apply the actual azimuth rotation
k: will pass from meters to screen pixels.
T: will place the observation point in the center of the screen.



3.3.2.- EL DIBUJO EN PERSPECTIVA DRAWING IN PERSPECTIVE

Como ya se ha visto en 2.7, figura 3.3.2.a, el primer problema queda resuelto con la transformación de un punto 3D a uno 2D cónica (aérea) en el plano de comparación, Posteriormente una transformación de escala y otra de traslación lo colocarán correctamente en la pantalla.


As already seen in 2.7, Figure 3.3.2.a, the first problem is solved with the transformation of a 3D point one 2D conic (aerial) in the plane of comparison, later a transformation of scale and other translational what be placed correctly on the screen.


Figura 3.3.2.a: Definición de los elementos que componen el dibujo en perspectiva cónica.
Figure 3.3.2.a: Definition of the elements conical perspective drawing.
Las diversas fórmulas algebraicas siguen el siguiente proceso:

1º Se conoce C, punto centro del proceso, a una distancia dPC en la dirección de eje anterior se sitúa P. La cota superior óptima está en torno a los 9 metros por encima de C (pero debe ser modificable), por ello 9 metros será el valor por defecto.

2º A una distancia determinada se localizará P. Es fácil, conociendo los diversos puntos del eje, se conoce el vector de dirección y por ello P=C+d·v/|v|. La distancia óptima está en torno a los 20 metros (pero debe ser modificable)., por ello 20 metros será el valor por defecto.

3º Conocido el vector (Pxy,Cxy) se establece el plano de comparación vertical:
(Px-Cx) · y - (Py-Cy) · x + c = 0 a · x – b · y + c = 0

4º Se traza la recta de P-R: recta que pasa por dos puntos

5º Se halla el punto de corte entre la recta P-R y se busca el punto de corte, Q

6º Se calculan las coordenadas relativas en al plano de comparación (respecto al punto C, por ejemplo.

7º Se realizan las transformaciones de semejanza necesarias para adaptarlo a la pantalla.

Este proceso se repite para todos los puntos de la explanada y se vuelve a repetir para todos los puntos del terreno.

Anteriormente se deciden cuales van a ser los pk y ejes visibles. Un punto óptimo está el el rango de los 500 metros, para una altura del observados de 9 metros. También debe ser modificable. La figura 3.3.2.b incluye un esquema general del proceso de dibujo.


The algebraic algorithm follows the following process:

1 is known C, center point of the process, a dPC distance in the direction of the front axle stands P. The optimal upper bound is around 9 meters above C (but must be changed), so nine meters will be the default.

2 At a certain distance will be located P. It is easy, knowing the various points of the axis, the direction vector is known and therefore P=C+d·v/| v |. The optimal distance is around 20 meters (but must be changed)., So 20 meters is the default.

Known 3rd vector (Pxy, Cxy) vertical plane comparison is made:
(Px-Cx)·y-(Py-Cy)·x+c=0 ↔ a·x-b·y+c=0

Line through two points: 4th straight PR is drawn

5th the cutoff line is located between the PR and the cutoff is sought, Q

6 the relative coordinates are calculated in comparison to the plane (relative to the point C, for example.

7th similarity transformations necessary to fit the screen are performed.

This process is repeated for all points of the Esplanade and is repeated for all points of the terrain.


Previously decide which will be the pk and visible axes. An optimum is the range of 500 meters to a height of 9 meters observed. It should also be modified. 3.3.2.b The figure includes an overview of the drawing process.


Figura 3.3.2.b: Diagrama de la estructura general del proceso de dibujo
Figure 3.3.2.b: Diagram of the general structure of the process of drawing
Al final, como se observa en la figura 3.3.2.c, se muestra un ejemplo del resultado del proceso de dibujo.

At the end, as seen in Figure 3.3.2.c, an example of a result of the drawing is shown.


Figura 3.3.2.c: Resultado del dibujo
Figure 3.3.2.c: Result drawing


La elección del Eje y del Pk sitúa el punto de observación.
+ Los puntos situados detrás del observador también originan una recta de corte por lo que se puede originar un “efecto espejo” que debe ser evitado. La forma de hacerlo es la siguiente, el plano de comparación, de ecuación ax+by+c=0 se convierte en la función f=ax+by+c, si se sustituye (x,y) por los valores del punto P ésta nos dará un valor positivo o negativo. Sólo se tienen que dibujar aquellos puntos que den en esta función distinto signo al anterior.

+ Aunque a continuación se materializan los resultados en código de Visual Basic puede ser transcrito en cualquier otro lenguaje con sus respectivas correcciones sintácticas. Lo importante es la resolución pormenorizada de todas y cada una de las ecuaciones algebraicas propuestas con anterioridad.

Choosing Pk Axis and placed the observation point.
+ The points behind the observer also originate a straight cut so can cause a "mirror effect" should be avoided. The way is the following, the comparison plane, equation ax + by + c = 0 becomes f = ax + by + c function, if substituted (x, y) by the values of point P it will give a positive or negative value. You only need to draw the points that give this function than the previous sign.

+ Even then the results are embodied in Visual Basic code can be transcribed in any other language with their syntactic corrections. What matters is the depth resolution of each and every one of algebraic equations proposed previously.

Para entender el proceso seguido se explica la programación en la siguiente secuencia:

Para la lectura inicial de datos:
 → Subrutina Abrir → Subrutinas Lee_Bases_Datos, y Lee_Ejes

Para la visualización de estos:
 → Subrutina Recorrido → Subrutinas Lee_Bases_Datos, Lee_Ejes y Lee_Estructuras

Para ambos casos:
 → Subrutina Lee_Ejes → Leo_Uno_A_Uno
 → Subrutina Leo_Uno_A_Uno → Saltaor
  • _____________________
(NOTA: Los siguiente códigos están en VB o C)
Private Sub Abrir()
'Se busca el directorio que contiene datos
cmd.DialogTitle = "Importar"
cmd.FileName = "": cmd.CancelError = True
cmd.Filter = "Proyectos (*.enm)|*.enm|Todos los ficheros|*.*"
cmd.FilterIndex = 1: cmd.Action = 1: Directorio = cmd.InitDir: Directorio = cmd.FileName

'Se abre el directorio que contiene datos
Do
Directorio = Left(Directorio, Len(Directorio) - 1)
Loop Until Right(Directorio, 1) = "\"
Grupo_Ejes.Path = Directorio: Grupo_Ejes.Pattern = "*.ter"
'Se leen las bases de datos desde la sub-rutina Lee_Bases_Datos
Lee_Bases_Datos
'Se lee el trazado desde la sub-rutina Lee_Ejes
Lee_Ejes
'Se leen las estructuras del entorno, la sub-rutina Lee_Estructuras
Lee_Estructuras
'Se leen los detalles desde la sub-rutina Lee_Detalles
Lee_Detalles
'Se elije el modo de visualización inicial
VisualizarEn3D
End Sub
_____________________

Private Sub Lee_Bases_Datos()
'Se inicializa Densidades
Data1.Connect = DBI_Connect
Data1.DatabaseName = DBI_Densidad
'Data1.RecordSource = "SELECT * FROM densidad ORDER BY PK"
'Data1.Refresh
'Se inicializa Suelos
Data2.DatabaseName = DBI_Suelos
Data2.RecordSource = "SELECT * FROM [" & DBT_Suelos & "] ORDER BY PK"
Data2.Refresh
'Se inicializan las fotos
Data3.Connect = DBI_Connect
Data3.DatabaseName = DBI_Fotos
Data3.RecordSource = DBT_Fotos
'Se inicializan los firmes
..
estructuras
..
fotos
..
End Sub
_____________________

Private Sub Lee_Ejes()
'Se lee el grupo de ejes
For H = 1 To Grupo_Ejes.ListCount
Archivo = Elemento(H)
Plataforma = Archivo + ".plataforma"
Eje = Archivo + ".eje"
Terreno = Archivo + ".ter"
N = Leo_Uno_A_Uno(Archivo, Terreno, Plataforma, Eje, H)
Next Himno
End Sub

_____________________

Sub Lee_Estructuras()
Data4.RecordSource = "SELECT DISTINCT ESTRUCTRUR FROM BD_Estructuras WHERE { distancia( Xv, CENTROX, Yv, CENTROY)< entorno }
' Esta es el punto más importante Xv, Yv Son las coordenadas del punto de vista y entorno, el máximo campo visible
Data4.Refresh : Data4.Recordset.MoveFirst
Do
Load Nombre_Estructura(Data4.Recordset(0) )
' Previamente se definió Nombre_Estructura como una matriz de objetos botón
Data4.Recordset.MoveNext
Loop Until Data4.Recordset.EOF
End Sub

_____________________

Private Function Leo_Uno_A_Uno(ByVal nom As String, ByVal ter As String, ByVal pla As String, ByVal eje As String, ByVal N As Integer) As Integer
NombreEje(N) = nom
Dim LineaT, LineaP, LineaC As String
'==========================================
' LO PRIMERO SERÁ CALCULAR EL NÚMERO DE PKS
'==========================================
Open Directorio + pla For Input As #2
50: Line Input #2, LineaP: If EOF(2) Then GoTo 60
If LineaP Like "*PS*" Then Line Input #2, LineaP: GoTo 50
If LineaP Like "*[0-9].[0-9][0-9]*" Then
If Left(LineaP, 7) = " ispol" Then ChivatoIstram = 1: z = Zinicio2(nom, ter, pla, eje, N): Exit Function
If ChivatoIstram <> 1 Then
ClipIIIAntiguo = InStr(LineaP, Tablu)
If ClipIIIAntiguo = 0 Then 'diferenciacion entre el clip normal o el de windows
Vol = Val(Left(LineaP, 18))
If Vol = 0 And I <> 0 Then GoTo 50
If Vol <= Vol1 Then GoTo 50
If Vol <> Int(Vol) Then GoTo 50
Vol1 = Vol
indice_pk(N, I) = Vol
Dist_p(N, 0, I) = Val(Mid(LineaP, 27, 10))
Dist_p(N, 1, I) = Val(Mid(LineaP, 37, 10))
Dist_p(N, 2, I) = Val(Mid(LineaP, 47, 10))
Dist_p(N, 3, I) = Val(Mid(LineaP, 67, 10))
Dist_p(N, 4, I) = Val(Mid(LineaP, 77, 10))
Dist_p(N, 5, I) = Val(Mid(LineaP, 97, 10))
Dist_p(N, 6, I) = Val(Mid(LineaP, 107, 10))
Dist_p(N, 7, I) = Val(Mid(LineaP, 117, 10))
Cota_p(N, 0, I) = Val(Mid(LineaP, 27, 10))
Cota_p(N, 1, I) = Val(Mid(LineaP, 37, 10))
Cota_p(N, 2, I) = Val(Mid(LineaP, 47, 10))
Cota_p(N, 3, I) = Val(Mid(LineaP, 67, 10))
Cota_p(N, 4, I) = Val(Mid(LineaP, 77, 10))
Cota_p(N, 5, I) = Val(Mid(LineaP, 97, 10))
Cota_p(N, 6, I) = Val(Mid(LineaP, 107, 10))
Cota_p(N, 7, I) = Val(Mid(LineaP, 117, 10))
Else
indice_pk(N, I) = Vol
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 0, I) = Val(Mid(LineaP, Primeo, 7))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 1, I) = Val(Mid(LineaP, Primeo, 7))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 2, I) = Val(Mid(LineaP, Primeo, 7))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 3, I) = Val(Mid(LineaP, Primeo, 7))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 4, I) = Val(Mid(LineaP, Primeo, 7))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 5, I) = Val(Mid(LineaP, Primeo, 7))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 6, I) = Val(Mid(LineaP, Primeo, 7))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Dist_p(N, 7, I) = Val(Mid(LineaP, Primeo, 7))
If Abs(Dist_p(N, 3, I) - Dist_p(N, 2, I)) > 20 Then Dist_p(N, 3, I) = 0
If Abs(Dist_p(N, 4, I) - Dist_p(N, 5, I)) > 20 Then Dist_p(N, 4, I) = 0
Cota_p(N, 0, I) = Val(Mid(LineaP, Primeo, 8))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Cota_p(N, 1, I) = Val(Mid(LineaP, Primeo, 8))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Cota_p(N, 2, I) = Val(Mid(LineaP, Primeo, 8))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Cota_p(N, 3, I) = Val(Mid(LineaP, Primeo, 8))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Cota_p(N, 4, I) = Val(Mid(LineaP, Primeo, 8))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Cota_p(N, 5, I) = Val(Mid(LineaP, Primeo, 8))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Cota_p(N, 6, I) = Val(Mid(LineaP, Primeo, 8))
Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare): If Primeo + 1 = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare) Then Primeo = InStr(Primeo + 1, LineaP, Tablu, vbBinaryCompare)
Cota_p(N, 7, I) = Val(Mid(LineaP, Primeo, 8))
If Abs(Cota_p(N, 3, I) - Cota_p(N, 2, I)) > 1 Then Cota_p(N, 3, I) = Cota_p(N, 2, I)
If Abs(Cota_p(N, 4, I) - Cota_p(N, 5, I)) > 1 Then Cota_p(N, 4, I) = Cota_p(N, 5, I)
Else

indice_pk(N, I) = Vol
Dist_p(N, 0, I) = Cuanto_es(Mid(LineaP, 41, 9))
Dist_p(N, 1, I) = Cuanto_es(Mid(LineaP, 41, 9))
Dist_p(N, 2, I) = Cuanto_es(Mid(LineaP, 14, 9))
Dist_p(N, 3, I) = Cuanto_es(Mid(LineaP, 14, 9))
Dist_p(N, 4, I) = Cuanto_es(Mid(LineaP, 14, 9))
Dist_p(N, 5, I) = Cuanto_es(Mid(LineaP, 60, 9))
Dist_p(N, 6, I) = Cuanto_es(Mid(LineaP, 60, 9))
Dist_p(N, 7, I) = Cuanto_es(Mid(LineaP, 60, 9))
Dist_p(N, 8, I) = Cuanto_es(Mid(LineaP, 87, 9))
Dist_p(N, 9, I) = Cuanto_es(Mid(LineaP, 87, 9))
Cota_p(N, 0, I) = Cuanto_es(Mid(LineaP, 50, 9))
Cota_p(N, 1, I) = Cuanto_es(Mid(LineaP, 50, 9))
Cota_p(N, 2, I) = Cuanto_es(Mid(LineaP, 23, 9))
Cota_p(N, 3, I) = Cuanto_es(Mid(LineaP, 23, 9))
Cota_p(N, 4, I) = Cuanto_es(Mid(LineaP, 23, 9))
Cota_p(N, 5, I) = Cuanto_es(Mid(LineaP, 69, 9))
Cota_p(N, 6, I) = Cuanto_es(Mid(LineaP, 69, 9))
Cota_p(N, 7, I) = Cuanto_es(Mid(LineaP, 69, 9))
Cota_p(N, 8, I) = Cuanto_es(Mid(LineaP, 96, 9))
Cota_p(N, 9, I) = Cuanto_es(Mid(LineaP, 96, 9))
End If
End If
GoTo 50
60: Close #2
indice_pk(N, I) = -1 'ESTA PAUTA SEÑALA EL FINAL DE LOS DATOS
I = I - 1
'==========================================
' LO SEGUNDO RELLENAR LAS VARIBLES CON I PKS
'==========================================
Open Directorio + ter For Input As #1
' LEEREMOS EL TERRENO
V = indice_pk(N, 0) - 1
Line Input #1, LineaT ' PARA DESHACERNOS DE LA LECTURA DE "*TER"
For j = 0 To I
If V < indice_pk(N, j) Then Line Input #1, LineaT: If EOF(1) Then GoTo 62
V = Val(LineaT)
If V = indice_pk(N, j) Then
VFinal = Val(Right(LineaT, Len(LineaT) - InStr(1, LineaT, ",", 0)))
Line Input #1, LineaT: If EOF(1) Then GoTo 62
Dedo = InStr(1, LineaT, ",", 0)
Cota_t(N, 1, j) = Val(Right(LineaT, Len(LineaT) - Dedo))
Dist_t(N, 1, j) = Val(LineaT)
VInicial = 2
For k = VInicial To VFinal
Line Input #1, LineaT: If EOF(1) Then GoTo 62
Dedo = InStr(1, LineaT, ",", 0)
' Print si; la; Cota; inferior; es; tal; cual
Cota_t(N, k, j) = Val(Right(LineaT, Len(LineaT) - Dedo))
Dist_t(N, k, j) = Val(LineaT)
Next k
If Dist_t(N, VFinal, j) < Dist_p(N, 7, j) Then
Dist_t(N, VFinal + 1, j) = Dist_p(N, 7, j) + 10
Cota_t(N, VFinal + 1, j) = Cota_t(N, VFinal, j)
VInicial = 3 ' Stop
End If
End If
Next j
'----------------------
' TERMINEMOS CON EL EJE
'----------------------
Open Directorio + eje For Input As #3
For j = 0 To I
Do
Line Input #3, LineaC
If Len(LineaC) < 7 Then GoTo 63
If LineaC Like "*P*" Then GoTo 63
If LineaC Like "*===*" Then GoTo 63
Loop Until InStr(1, LineaC, Trim(indice_pk(N, j)), 0) <> 0
If ClipIIIAntiguo = 0 Then
Y_eje(N, j) = Cuanto_es(Mid(LineaC, 33, 11))
If Y_eje(N, j) = 0 Then GoTo 63
X_eje(N, j) = Cuanto_es(Mid(LineaC, 21, 10))
If MinimaX > X_eje(N, j) Then MinimaX = X_eje(N, j)
If MinimaY > Y_eje(N, j) Then MinimaY = Y_eje(N, j)
If MaximaX < X_eje(N, j) Then MaximaX = X_eje(N, j)
If MaximaX < Y_eje(N, j) Then MaximaY = Y_eje(N, j)
Beta(N, j) = Cuanto_es(Mid(LineaC, 47, 8))
Betty = Betty + Beta(N, j) / 100
Else
Y_eje(N, j) = Cuanto_es(Mid(LineaC, 18, 11))
If Y_eje(N, j) = 0 Then GoTo 63
X_eje(N, j) = Cuanto_es(Mid(LineaC, 7, 10))
If MinimaX > X_eje(N, j) Then MinimaX = X_eje(N, j)
If MinimaY > Y_eje(N, j) Then MinimaY = Y_eje(N, j)
If MaximaX < X_eje(N, j) Then MaximaX = X_eje(N, j)
If MaximaX < Y_eje(N, j) Then MaximaY = Y_eje(N, j)
Beta(N, j) = Val(Mid(LineaC, 30, 8))
Betty = Betty + Beta(N, j) / 100
End If
Next j
Close #3
Zinicio = I
End Function
_____________________

Sub Recorrido
'Combo1 Lista desplegable con los nombres del eje
'Combo2 Lista desplegable con los pks del recorrido del eje anterior
Indice = Combo2.ListIndex
ColDat = Combo1.ListIndex

'================================================================
' ======== DEFINICION DEL PLANO DE COMPARACION =======
'================================================================
Cota_Ini = Cota_p(ColDat, 3, Indice) 'Pone a la altura de 6000 el eje central
Xe = X_eje(ColDat, Indice)
Ye = Y_eje(ColDat, Indice)
Ze = Cota_Ini
Alfa = Giro / 200 * 3.14159265358979 + (-Beta(ColDat, Indice)) / 100 * 1.5707963267949

'================================================================
' ======== DEFINICION DEL PUNTO DE VISTA =======
'================================================================

Xv = Xe + Dis * Sin(Alfa)
Yv = Ye - Dis * Cos(Alfa)
Zv = Altura
mm = Tan(-1.5707963267949 + Alfa)
nn = Yv - Xv * mm
M = Tan(Alfa)
N = Ye - Xe * M

'================================================================
' ======== EMPEZANDO A SALTAR ========
'================================================================

For I = Indice To Indice + Saltos * Signal Step Signal
Y = Saltaor(Indice, ColDat, I)
Next I
barra = Val(Combo2) * 1000 + Val(Right(Combo2, 3))
For j = 1 To Saltos
Radio = (10 * Saltos): Pej = 0
For I = 0 To Dimensiones
For k = 0 To Numeral
Equis = X_eje(I, k): If Equis = 0 Then k = Numeral
If Abs(Equis - Xv) + Abs(Y_eje(I, k) - Yv) < Radio Then
Y = Saltaor(Indice, I, k)
' Esta referencia a la función Saltaor es para acceder rápidamente a los datos del entorno al pk)
End If
Next k
End If
End Sub
_____________________

Function Saltaor(ByVal pekfin As Integer, ByVal ColDat As Integer, ByVal I As Integer) As Integer

'***********************************************
' ********* TERRENO ********
'***********************************************
For j = 0 To 20
D = Dist_t(ColDat, j, I)
Bet = 0 * Giro / 200 * 3.14159265358979 + (-Beta(ColDat, I)) / 100 * 1.5707963267949
Oa = D * Cos(Bet) + X_eje(ColDat, I)
Ob = D * Sin(Bet) + Y_eje(ColDat, I)
Oc = Cota_t(ColDat, j, I)
If Oc <> 0 Then
Chato = PuntOstias(Oa, Ob, Oc)
If Chato = 1 Then
If j = 0 Then
Uu = Coor_X: Vv = Coor_Y
Else
Colore = QBColor(2)
Xx = Coor_X: Yy = Coor_Y
l = recta(Uu, Vv, Xx, Yy, Colore)
Uu = Xx: Vv = Yy
End If
End If
End If
Next j
'***********************************************
' ********* PLATAFORMA ********
'***********************************************
For j = 0 To 9
D = Dist_p(ColDat, j, I): If D > 100 Then Exit For
Bet = 0 * Giro / 200 * 3.14159265358979 + (-Beta(ColDat, I)) / 100 * 1.5707963267949
Oa = D * Cos(Bet) + X_eje(ColDat, I)
Ob = D * Sin(Bet) + Y_eje(ColDat, I)
Oc = Cota_p(ColDat, j, I)
If Oc <> 0 Then
Chato = PuntOstias(Oa, Ob, Oc)
If Chato = 1 Then
If j = 0 Then
Uu = Coor_X: Vv = Coor_Y
mimi(0, I - Iluso) = Uu: nini(0, I - Iluso) = Vv
Else
Colore = QBColor(15)
Xx = Coor_X: Yy = Coor_Y
If j = 2 Then mimi(1, I - Iluso) = Xx: nini(1, I - Iluso) = Yy
l = recta(Uu, Vv, Xx, Yy, Colore)
If j = 5 Then mimi(2, I - Iluso) = Xx: nini(2, I - Iluso) = Yy
If j = 7 Then
mimi(3, I - Iluso) = Xx: nini(3, I - Iluso) = Yy
Dedo = Dcia(Oa, Ob, Xv, Yv)
If Planta.Caption = "Ver Planta" Then
If Dedo < 100 Then
Picture1.CurrentX = Xx + 50
Picture1.CurrentY = Yy - 250
Picture1.ForeColor = RGB(255, 120, 120)
Picture1.FontSize = Int(70 / Sqr(Dedo))
Picture1.FontName = "times"
Picture1.Print Format(indice_pk(ColDat, I), "0+000");
Picture1.Print Texto
End If
Else
Funx = (Xx + 50) / Escala_Pitufo
Funy = (Yy - 250) / Escala_Pitufo
Picture1.ForeColor = RGB(255, 120, 120)
If ColDat = Combo1.ListIndex Then
Picture1.ForeColor = QBColor(14): Gordito = 125 / Saltos
If I = Combo2.ListIndex Then Picture1.ForeColor = QBColor(15): Gordito = 200 / Saltos
Else
End If
End If
End If
Uu = Xx: Vv = Yy
End If
End If
End If
Next j
End Function


3.3.2.1.- EL DIBUJO CON SUPERFICIES PLANAS / DRAWING WITH FLAT SURFACES


El dibujo en 3D con líneas es más sencillo que el propio dibujo en 3D con superficies planas (renderizado) la dificultad añadida está en agrupar los puntos de tres en tres (triangulación) a los puntos más cercanos por concepto o una simple triangulación de Delaunay. El problema está en el tiempo de cálculo añadido que se necesita en esta serie de operaciones.

La disminución del tiempo se obtiene de dos maneras, Cambiando el lenguaje y la forma de operar

Todos los lenguajes de alto nivel permiten llamadas a comandos, o, incluso a otros programas externos que actuarán como subrutinas de este. Desde VB se hace a través de la función Shell() y en PHP desde las funciones exec(), system() y alguna más.

Para que esta parte sea lo más rápida posible se realizará en C y el ejecutable se creará con el programa gratuito gcc disponible para Linux y Windows. De esta manera se tendrá un mismo programa que podrá ser compilado para cualquier sistema operativo.

De todas maneras los bucles con demasiado numerosos,: el 1º, 2º y 3º recorre los puntos hasta localizar los puntos más cercanos, el 4º, 5º y 6º compara estos puntos con los anteriores para saber su posición respecto a los anteriores ya calculados para saber si están delante o detrás del resto, total o parcialmente, y un 7º para conocer según su orientación el color iluminado.

Estas operaciones comparativas de posición pueden provocar reiterados anidamientos y éstos lentitud en la respuesta hacia el dibujo final.

Las primeras versiones hicieron el trabajo excesivamente lento hasta que se incluyeron en la programación las “sintegrales”.(Véase apartado 3.6.3) .

Si se analiza alguno de los bucles y dentro de él las operaciones que se realizan son lo suficientemente rutinarias puede extrapolarse el término general y sustituirse éste por el bucle. No se eliminarán todos pero sí una gran parte:


Uniendo ambos criterios se crea el siguiente programa en C (se realiza en C para añadir velocidad en la ejecución del programa una vez compilado):


The 3D drawing lines is simpler than the drawing itself in 3D with flat surfaces (rendering) the added difficulty is to combine the points in threes (triangulation) to the closest for concept or a simple Delaunay triangulation points. The problem is added computation time is needed in this series of operations.

The decrease in time is obtained in two ways, changing the language and how to operate

All high-level languages allow calls to commands, or even to other external programs to act as subroutines of this. From VB is done through the Shell () function in PHP from the exec (), system () and some more.

For this part as fast as possible will be made in C and the executable is created with the free gcc available for Linux and Windows. Thus the same program can be compiled for any operating system will have.

Anyway loops with too many,: the 1st, 2nd and 3rd runs through the points to locate the nearest points, 4th, 5th and 6th compares these points with the above to find your position on the above and calculated to know if they are in front or behind other, wholly or partially, and a 7th to know by color illuminated orientation.

These comparative operations can cause repeated nesting position and these slow response to the final drawing.

Early versions made excessively slow work until the schedule included in the "sintegrales." (See section 3.6.3).

If we analyze some of the loops and within it the operations performed are sufficiently routine can be extrapolated the general term and replaced it by the loop. Not all but eliminated much:


Uniting both criteria the following program is created in C (done in C to add speed program execution once compiled):


Figura 3.3.2.1.a: Resultado del dibujo con triángulos sólidos.
Figure 3.3.2.1.a: Result of the drawing with solid triangles.

3.3.2.2.- EL DIBUJO EN EL NAVEGADOR / DRAWING IN THE BROWSER


La posibilidad de realizar el dibujo gráfico en el navegador sigue siendo demasiado lenta pero para exponer la forma de hacerlo sería a través de javascript con la definición de elementos DIV a sólo píxeles. El hecho de crear todo un objeto del DOM de HTML para dibujar un punto y que este deba ser controlado a través de javascript (lenguaje intérprete) dentro del navegador, y éste, dentro del S.O. Hace que éste sistema se vuelva demasiado lento.  La siguiente visualización (figura 3.3.2.2) tarda unos 3 minutos en renderizarse:

The possibility of graph drawing in the browser is still too slow but to expose the way would be through javascript with the definition of DIV elements just pixels. The fact create an entire HTML DOM object to draw a point and that this should be controlled through javascript (language interpreter) within the browser, and this, in the SO Makes this system becomes too slow. The following display (Figure 3.3.2.2) takes about 3 minutes rendered:


Figura 3.3.2.2: Resultado del dibujo con Javascript
Figure 3.3.2.2: Result of the drawing with Javascript
El código para la obtención del dibujo anterior (figura 3.3.2.2) sería al siguiente. Se ha substituido los elementos redundantes por puntos suspensivos.

(NOTA: HTML y PHP)

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- saved from url=(0046)file://\\oc-proyecto\interno\www\idi\3d\3d.htm -->
<!-- saved from url=(0045)http://www.lutanho.net/svgvml3d/platonic.html --><HTML
xmlns:v = "urn:schemas-microsoft-com:vml"><HEAD><TITLE>SVG-VML-3D-Example - Platonic Solids</TITLE>
<META http-equiv=Content-Type content="text/html; charset=windows-1252">
<STYLE>v\:* {BEHAVIOR: url(#default#VML)}
INPUT {FONT-SIZE: 14pt; WIDTH: 28px; FONT-FAMILY: 'Times New Roman'; HEIGHT: 28px; BACKGROUND-COLOR:#c0c0ff}
</STYLE>
<SCRIPT language=JavaScript src="SVG-VML-3D-Example%20-%20Platonic%20Solids_archivos/svgvml3d.js" type=text/javascript></SCRIPT>
<SCRIPT language=JavaScript src="SVG-VML-3D-Example%20-%20Platonic %20Solids_archivos/platonic.js" type=text/javascript></SCRIPT>
<SCRIPT language=JavaScript type=text/javascript>
var S, T, O, C, I, D;
function Init() { if (useSVG){ if (! SVGObjects[0]){ setTimeout("Init()",100);
return; } S=new Scene3D(SVGObjects[0],0,500,500); }
else S=new Scene3D(document.getElementById("Scene1"),1);

T = new Trian(S,"#A20000"," #00ff00","",1,0,0,0,0,0,0,0,0,0);
T = new Trian(S,"#008400","
#00ff00","",1,-1.21638424538891,-1.87847702892497,3.438995E-02,-1.37859868711326,-1.97480649444275,2.437012ET
= new Trian(S,"#008300","
#00ff00","",1,-1.25176361426362,-1.81815704993904,3.33200073242187E-02,-1.37859868711326,-1.97480649444275,2.

C = new Plano
(S,"#85EEEE","#85EEEE","",1,-1.57154412898468,-1.27294794804417,0.022919921875,-1.61606559153064,-1.197041176
C = new Plano
(S,"#77CACA","#77CACA","",1,-1.61606559153064,-1.19704117608257,-5.25299072265625E-02,-1.64333499144181,-1.15
}
</SCRIPT>
<META content="MSHTML 6.00.5730.13" name=GENERATOR></HEAD>
<BODY bgColor=#0000ff><INPUT title="zoom picture in" onclick=ZoomPicture(1) type=button value=[+]>

<SCRIPT language=JavaScript>
if (useSVG) document.writeln("<embed width='1000' height='800' name='Scene1' src='scene.svg'
wmode='transparent' type='image/svg+xml' />");
else document.writeln("<div id='Scene1' style='position: relative; width:1000; height:800; overflow:
hidden;'></div>");
</SCRIPT>
</TABLE></BODY></HTML>

**** TRATAMIENTO DE LA INFORMACIÓN / INFORMATION PROCESSING ****


3.4.- LA UNIÓN DEL TRAZADO CON LAS BASES DE DATOS / THE UNION OF ROUTE AND DATABASES


El trazado se une a las bases de datos de forma inmediata ya que todas las bases de datos (u hojas de cálculo) contienen dos campos uno dedicado al eje y el otro al pk. Las dos posibilidades de consulta son: BD → trazado, o , Trazado → BD.

En el primer caso,  BD → trazado, sería una selección tipo de punto 3.3
En el segundo caso,  Trazado → BD, se necesitaría una consulta del tipo:

SELECT * FROM BaseDeDatos WHERE PK=[pk buscado, o entorno] AND EJE=[eje buscado o entorno]

y la consulta habría sido realizada,.

The route joins the database immediately because all databases (or spreadsheet) contain two fields one dedicated to the axis and the other to pk. The two possibilities for consultation are: BD → route, or route → BD.

In the first case, BD → path, it would be a kind selection of point 3.3
In the second case, Route → BD, a query would need to type:

SELECT * FROM DATABASE WHERE PK = [pk sought, or environment] AND SHAFT = [axis sought or environment]

and consultation have been made,.



Continuará ...
To be continued ...

No hay comentarios:

Publicar un comentario