Código Fuente para encontrar aristas paralelas mediante puntos de fuga (PEVP)

Agosto 2014

Estamos interesados en crear herramientas basadas en computador para ayudar a los ingenieros de diseño durante la primera etapa del proceso de diseño, conocida como diseño conceptual. Por tanto, desarrollamos sistemas de modelado basado en bocetos (SBM por sus siglas en inglés). Nuestra aproximación al SBM se basa en encontrar indicios o regularidades, que son aquellas propiedades del boceto que revelan propiedades del objeto tridimensional representado en el boceto. En este contexto, las aristas paralelas son indicios. En concreto, el algoritmo de aristas-paralelas que consideramos aquí (PEVP) está encaminado a agrupar líneas del boceto que representan aristas que se cree que son paralelas en el modelo 3D representado por el boceto, en representaciones de objetos poliédricos.

Se adjunta una implementación en C++ del código del nuevo algoritmo PEVP.

Usted puede descargar el código de FF desde aquí.

Aunque muchos de los indicios están relacionados mutuamente, nosotros intentamos detectar cada indicio usando información mínima. Para que PEVP funcione, el boceto de entrada debe haber sido previamente vectorizado, para convertir los trazos del boceto en líneas del dibujo lineal. Por tanto, la entrada para el código es un dibujo 2D, que incluye una lista de vértices y ejes en el siguiente formato:

· Las coordenadas de cada vértice se guardan en una instancia de la clase POINT2D. El conjunto de todos los vertices se guarda en un vector estándar (std::vector <POINT2D>Vertex)

o VertexCount= número de vertices del dibujo lineal

o VertexX[i]= coordenada X del i-esimo vértice

o VertexY[i]= coordenada Y del i-esimo vértic

· Las aristas se definen mediante sus vértices de cabeza y cola. El conjunto de todas las cabezas de aristas se guarda en un vector estándar (std::vector <long> EdgeHead) y el conjunto de todas las colas de aristas se guarda en otro vector estándar (std::vector <long> EdgeTail):

o EdgeCount= número de aristas del dibujo lineal

o EdgeHead[i]= Vértice de cabeza que define a la i-esima arista

o EdgeTaill[i]= Vértice de cola que define a la i-esima arista

El lector debe notar que la vectorización del boceto requerida para que funcione éste método es mínima, porque los extremos de diferentes líneas que serían percibidas por los humanos como una esquina o unión común no necesitan estar fusionados en un único vértice. Por tanto, puede ocurrir que cada extremo de arista defina un vértice diferente.

La salida es una lista de grupos de líneas del dibujo paralelas entre sí.

· La información se guarda en un vector estándar, (std::vector <std::vector <long>> ParallelEdges), donde ParallelEdges[i][j] contiene el número de la j-esima arista del i-esimo grupo de aristas paralelas.

El método está encapsulado en dos clases:

· La clase CCueParallelEdges está prevista para ser llamada desde la aplicación externa.

· La clase CCueVanishingPoints debe ser llamada desde CCueParallelEdges, aunque también puede ser llamada directamente desde la aplicación externa, en el caso de que sólo se use el método de puntos de fuga.

La primera clase incluye dos métodos diferentes para detector aristas paralelas. La primera es nuestra propia implementación del Grafo de Distribución Angular (ADG) propuesto por Lipson y Shpitalni en la siguiente referencia:

H Lipson, M Shpitalni. (1996). Optimization-based reconstruction of a 3D object from a single freehand line drawing. Computer-Aided Design, 28(8) 651-663.

El segundo es nuestro propio método para encontrar puntos de fuga, descrito en:

P. Company, P.A.C. Varley, R. Plumed (2014). An algorithm for grouping lines which converge to vanishing points in perspective sketches of polyhedral. Lecture Notes in Computer Science LNCS 8746, pp. 77-95.

El tercer método es automático, y utiliza ADG para objetos normalones (también conocidos como objetos o escenas “Manhattan like”) dibujados en proyección paralela, y utiliza Puntos de Fuga en el resto de casos. El método automático considera que el dibujo representa una forma normalon si (a) existen tres y solo tres ángulos prevalentes, y (b) todas las aristas encajan en alguna de las tres direcciones principales.

Para funcionar, el método requiere otros dos ficheros que contiene clases y operaciones auxiliares:

· Tools_Geometry.cpp, y su correspondiente encabezamiento Tools_Geometry.h.

· Tools_Vector.cpp, y su correspondiente encabezamiento Tools_Vector.h.

Para ayudar a entender cómo funciona el código, y para ofrecer un entorno de prueba, se suministra también el siguiente fichero:

· MainParallelEdges.cpp, y su fichero de encabezamiento MainParallelEdges.h.

Finalmente, queremos remarcar que el código fue escrito para hacerlo legible. La eficiencia nunca fue un objetivo.

**********************************************************************************************************************************************************

El código PEVP es software libre. Pero si usted lo encuentra útil para su propia investigación, por favor cite nuestro artículo:

**********************************************************************************************************************************************************