generacion automatica del modelo digital del...

Generación automática del Modelo Digital del Terreno.

Hind Taud

Resumen

Para generar el Modelo Digital del Terreno MDT de una manera automática, se investigó las

metodologías reportadas en la literatura. Se eligió la técnica de creación a partir de curvas de

nivel. Las curvas se encuentran en base de datos como los elaborados por INEGI. Se desarrollo

el proyecto según lo establecido en programación de Actividades. Se desarrollo un algoritmo

para la transformación de datos del formato DXF al formato raster o matricial. Se elaboro también

un código para agrupamiento de datos cuado estos provienen de diferentes zonas.

1. Introducción

La generación de la superficie es una herramienta que se usa en diversos campos de

investigación. Esta generación o creación se logra mediante el proceso de interpolación espacial.

La interpolación consiste en la estimación de los valores que alcanza una variable Z en un

conjunto de puntos en un espacio bi-dimensional a partir de una base de datos como medidas

puntuales. El objetivo principal en esta investigación es precisamente la creación del Modelo

Digital del Terreno MDT o de elevación. Existen diferentes definiciones en la literatura sobre el

MDT, la más sencilla, es considerar el modelo como una imagen digital del terreno donde en

cada punto espacial de esta imagen corresponde su altura en el terreno. En cualquier análisis o

estudios geo-espaciales, la importancia de usar estos modelos crece considerablemente y la

información que proporciona enriquece la base de datos.

2. Estudio bibliográfico

Como se ha elaborado en el proyecto, la primera etapa fue un estudio bibliográfico sobre la

generación del modelo digital del terreno. Diferentes datos de diversas fuentes como las curvas

de nivel, fotogrametría y datos del campo pueden ser datos de entrada para la creación del

modelo. Las curvas de nivel en formato digital pueden ser obtenidas a partir de mapas mediante

la digitalización manual, o a partir de técnicas automáticas de escaneo. La hipsometría es

obtenida también mediante fotografía aérea o a partir de imágenes de satélite incluyendo fuente

de radar [1, 2 y 3].

Diferentes estructuras han sido utilizadas. Las más frecuentes estructuras son las de malla

rectangular o la estructura matricial de elevación y la malla triangular. A partir de métodos de

interpolación se pueden generar superficies. Las más conocidas están descritas y explicadas por

Watson [4]. La evaluación de la calidad del modelo generado es profundamente explicada en

diferentes trabajos [5,6,7,8 y 9]. Un metodología de evaluación basada en la visualización se

1

propuso en el trabajo de Taud et al. [10]. La visualización, efectivamente proporciona un

mecanismo poderoso para la identificación de distribuciones espaciales e la incertidumbre en los

modelos. En el trabajo de watson, los métodos de interpolación se pueden clasificar como

métodos de ajuste de función (lagrange, colocación, minimum curvature splines, kriging,

relajación), métodos basados en distancia (inverse-distance weight gradients), métodos de

triangulación, métodos rectangulares (bilinear patches, Hermite patches, Bezier patches, B-spline

patches, etc.) y métodos de vecinos. Generalmente, se pueden clasificar en dos clases. La

primera predetermina parámetros de una función analítica que se evalúa en una posición dada

para obtener la elevación de superficie representativa. La secunda clase se hace una adición de

influencia de datos en cada punto. A pesar de la existencia de múltiples técnicas de

interpolación, la mas usada al nivel mundial para generar un MDT es la que se basa en las

curvas de nivel dado que permiten obtener un modelo con un costo bajo que sea computacional

o económico. Por estas razones se eligió la utilización de este acercamiento. Muy pocos trabajos

se han desarrollado en los últimos años [10, 11, 12, 13, 14 y 15]. Algunas generan contornos de

manera iterativa, aplicando o no técnicas de la morfología matemática (dilatación, erosión,

esqueletización), otros, aplican información en diferentes direcciones alrededor de un punto.

Evidentemente, otros tratan de mejorar técnicas ya existentes. Se propone en esta investigación,

mejorar la metodología desarrollada por los autores [10] mediante cambios en algunas partes de

la metodología e integración de otros datos geomorfológicos.

3. Formato de datos

Las curvas de nivel son datos geo-espaciales que se puede tener en diferentes formatos. Por

ejemplo en formato de texto (*.txt) donde hay los datos de los puntos en X,Y,Z y su altura

correspondiente. El formato usado por algún software de Sistemas de información geográfica es

el formato DXF (Drawing Interchange file format). Los archivos DXF son archivos ASCII simples

con extensión .DXF donde hay toda la información sobre los puntos que forman las curvas, zona

de estudio, proyecciones, etc. De forma general los archivos DXF son una secuencia de valores

ASCII escritos de manera secuencial. Se escriben por parejas de datos correspondientes a un

identificador y en la línea siguiente un valor correspondiente al identificador que lo precede. Esta

secuencia de datos esta dividida en secciones. El conocimiento de la estructura de estos

archivos hace posible la creación de un programa para leer o escribir este tipo de archivos y

poder aprovechar al máximo la posibilidad de generar proceso automático que ahorran tiempo y

dinero. El acceso a estos datos podría ser gratuito como en algunos sitios de Internet o por

compra de base de datos de las instituciones especializadas. El INEGI, Instituto Nacional de

Estadística Geografía e Informática esta poniendo a los múltiples y diversos usuarios, una base

de datos, digital y vectorial las curvas de nivel en formatos DXF de AutoCad en diferentes

2

escalas de todo México. La información en este formato se presta a edición y manipulación con

mucha facilidad por lo que es relativamente sencillo adaptarla a necesidades particulares con el

uso de software tipo GIS. La información producida por INEGI se proporciona en capas como

altimetría (puntos correspondientes a curvas de nivel), datos de hidrografía (redes hidrológicas),

etc. Una descripción del formato DXF se encuentra en el capitulo 18 del libro escrito por el autor

Ransen [16].

Se eligió el uso de estos dos formatos (txt y DXF) para poder tener una gran apertura a

diferentes usuarios, de diferentes campos, interesados en el uso de la metodología de

generación del modelo digital del terreno que se esta desarrollando en este proyecto.

4. Proyección de vector a Raster (anexo A)

La base de datos vectorial es obtenida a partir de una escala dada. Una aproximación es

necesaria para pasar del espacio real al espacio discreto. Su proyección en el espacio discreto

depende mucho de la resolución requerida. En baja resolución se yuxtaponen las curvas, lo que

implica perdida de información, y también en la interpolación. En alta resolución, se genera una

imagen grande lo que implica el crecimiento del tiempo de la interpolación. En este caso, la

proyección en las zonas montañosas donde las curvas de nivel son muy cercanas proporciona

un resultado satisfactorio mientras en zonas planas donde hay pocas curvas se generan muchos

puntos para interpolar. Se elaboró el código desarrollado en el lenguaje C del algoritmo que

permite tener la imagen de la curvas de nivel a partir del formato de INEGI DXF. Los datos

utilizados corresponden a cartas topográficas con las siguientes características: una escala de

1:50 000, una proyección cartográfica de Universal Transversa de Mercator (U.T.M.) e intervalo

de curvas de nivel de 20 metros.

5. Agrupación de datos (anexo B).

Se elaboró otro código en lenguaje C para responder a otra problemática que puede encontrar

un usuario. Cuando es necesario trabajar en una zona que se encuentra entre dos cartas

topográficas, el código nos permite juntar según el formato DXF dos datos de altimetría

separados para poder generar un mapa de curvas de nivel con el primer código.

6. Conclusión

Se cumplió con el avance programado en la programación de Actividades de Investigación

descrito en el protocolo de proyecto: Revisión del estado del arte- estudio bibliográfico (Junio-

julio 2006), Codificación de los base de datos de INEGI (julio-septiembre 2006). Extracción de la

imagen de contornos: cambio del espacio vectorial al espacio raster (septiembre- diciembre

2006).

3

7. Impacto

Este proyecto, en su fin, permitiría tener un gran impacto en el sector productivo y también un

gran beneficio social y/o educativo. La generación del modelo digital del terreno a partir de datos

vectoriales de INEGI permitiría, a diversos sectores de diversos campos, de integrar el modelo

digital en sus trabajos.

8. Bibliografía

[1] Taud H., Parrot J.-F.,1995. - Quantitative Digital Elevation Model from SAR data, Proceedings

EUROPTO series.''Synthetic aperture radar and passive microwave sensing'', Vol 2584, 226-233.

[2] Kobler A. , Pfeifer N., Ogrinc P., Todorovski L. ,Oštir K., Džeroski, S., 2006, Repetitive

interpolation: A robust algorithm for DTM generation from Aerial Laser Scanner Data in forested

terrain, Remote Sensing of Environment, doi:10.1016/j.rse.2006.10.013.

[3] Mora, O., Arbiol, R., Palà, V., Adell, A., Torre, M., 2006. Generation of accurate DEMs using

DInSAR methodology (TopoDInSAR), IEEE Geoscience and Remote Sensing Letters 3 (4), 551-

54.

[4] Watson, D.F., 1992. Contouring: a Guide to the Analysis and Display of Spatial Data.

Pergamon, Oxford, p. 340.

[5] Burrough, P.A., 1986. Principles of Geographical Information. Systems for Land Resources

Assessment. University Press, Oxford, p. 193.

[6] Aronoff, S. 1991. Geographical Information Systems: a Management Perspective. WDl

Publications, Ottawa, p. 294.

[7] Wood, J.D., Fisher, P.F., 1993. Assessing interpolation accuracy in elevation models. IEEE

Computer Graphics & Applications, 48-56.

[8] Li, Z., 1994. A comparative study of the accuracy of digital terrain models (DTMs) based on

various data models, Journal of Photogrammetry and Remote Sensing, 49, 2-11.

[9] Carrara, A., Bitelli, G., Carla, R., 1997. Comparison of techniques for generating digital terrain

models from contour lines, International Journal of Geographical Information Sciences, 11 (5),

451-473.

[10] Taud H., Parrot J.-F., Alvarez R.,1999. DEM generation by contour line dilation, Computers

and Geosciences, 25 (7), pp. 775-783.

[11] Wang, J.-J., Teng, S.-Q., 2002. The method of making DEM based on contour

line, Computer Applications, 22 (8), pp. 34-35.

[12] Ardiansyah, P.O.D., Yokoyama, R., 2002. DEM generation method from contour lines based

on the steepest slope segment chain and a monotone interpolation function,

ISPRS Journal of Photogrammetry and Remote Sensing, 57 (1-2), pp. 86-101.

4

[13] Gold, C., Dakowicz, M., 2003. Digital elevation models from contour lines: Improving

Accuracy by incorporating skeleton points and slope information, GIM International, 17 (2), pp.

56-59.

[14] Gousie, M.B., Franklin, Wm.R., 2003. Constructing a DEM from grid-based data by

computing intermediate contours, GIS: Proceedings of the ACM International Symposium on

Advances in Geographic Information Systems, pp. 71-77.

[15] Liu, P.-J., Zhao, R.-L., Zhu, J.-Z., Zhu, Q.-K., Tang, X.-M. 2006. Method for generating DEM

Geomorphologic feature, Journal of China University of Mining and Technology 35 (4), pp. 521-

525.

[16] Ransen O., 1997. AutoCad programming in C and C++, Chichester; New York: Wiley, 492p.

Anexo A

/*======================================================*/ /* version 1 noviembre 2006 */ /*======================================================*/ #include <stdio.h> #include <string.h> #include <errno.h> #include <math.h> #include <time.h> #include <stdlib.h> #include <values.h> #include <limits.h> #include <io.h> #include <conio.h> #include "c:\prog\lib\nrutil.cpp" #include "c:\prog\lib\nrutil.h" #define ival -999.0 void opening(); void treatment(); void rotation(double angle,int sentido,double i_in,double j_in); void save(); void extraction(); void trace_droite(int ideb,int jdeb,int ifin,int jfin,double alti); unsigned char **tab,**tab2,**tab3; int nb_lig,nb_col; int nb_lig3,nb_col3; int val_minimo,val_maximo; double min_x,min_y,min_alt; double max_x,max_y,max_alt; double pix_size,id2,jd2,size_pix; double **dtab; FILE *f1,*f2,*f2d,*f3d; /***************************************************/ /* main */

5

/***************************************************/ main() { opening(); printf("\n\n tamano del pixel ? "); scanf("%lf",&pix_size); size_pix=pix_size; treatment(); extraction(); save(); } /***************************************************/ /* trace droite */ /***************************************************/ void trace_droite(int ideb,int jdeb,int ifin,int jfin,double alti) { double a,b,rmax,icrrnt_d,jcrrnt_d,dinext,djnext; int icrrnt,jcrrnt,ilast,jlast; int ico=1; a=(double)(jfin-jdeb); b=(double)(ifin-ideb); icrrnt=ideb; jcrrnt=jdeb; icrrnt_d=(double)icrrnt; jcrrnt_d=(double)jcrrnt; ilast=icrrnt; jlast=jcrrnt; dtab[ideb][jdeb]=alti; rmax=max(fabs(a),fabs(b)); if(rmax == 0.) return; dinext=b/rmax; djnext=a/rmax; while (ilast!=ifin || jlast!=jfin) { icrrnt_d=icrrnt_d+dinext;jcrrnt_d=jcrrnt_d+djnext; icrrnt=(int)(icrrnt_d+.5); jcrrnt=(int)(jcrrnt_d+.5); dtab[icrrnt][jcrrnt]=alti; ilast=icrrnt; jlast=jcrrnt; } } /***************************************************/ /* treatment */ /***************************************************/ void treatment() { int i,j,k,val,jval,check; int segm=0,point,ico,rep; int reg; int intervalo,val_deb,num_segment; int flag,ideb,jdeb,ifin,jfin; int flag_sect,line; int jco,lco,n,valprov,difmin;

6

int tabval[260],tabord[260]; int sentido; double angulo; double f_ideb,f_jdeb,f_ideb2,f_jdeb2; double f_ifin,f_jfin,f_ifin2,f_jfin2; double min_dyn=10000.,max_dyn=0.; double miny=4000000.,maxy=0.,minx=4000000.,maxx=0.; double dif_x,dif_y,hypo; double dval1,dval2,dval3; double pix_size_def,dif_j; double S,C,T,CT,TA,TA2; double cote,d_col,angle; double pi=4*atan(1.),api=pi/180.; char texte[80]; char *SECTION="SECTION",*POLYLINE="POLYLINE",*VERTEX="VERTEX",*ENDSEC="ENDSEC"; // enter = 0 char *TABLE="TABLE"; char *AC1006="AC1006"; // enter = 1 char *HEADER="HEADER",*ENTITIES="ENTITIES",*TABLES="TABLES"; // enter = 2 char *INSBASE="$INSBASE",*EXTMIN="$EXTMIN",*EXTMAX="$EXTMAX",*ACADVER="$ACADVER"; // enter = 9 char *CECOLOR="$CECOLOR",*CELTYPE="$CELTYPE"; // enter = 9 for(i=0; i<260; i++) tabval[i]=0; printf("\n treatment\n"); printf("\n numero de registros anteriores en Vertex ? "); scanf("%d",&reg); flag_sect=0; while (!feof(f1)) { fscanf(f1,"%s",texte); check=strcoll(SECTION,texte); if(check == 0) { flag_sect++; } check=strcoll(ENDSEC,texte); if(check == 0) { } check=strcoll(HEADER,texte); if(check == 0) { } check=strcoll(TABLES,texte); if(check == 0) { } check=strcoll(EXTMIN,texte); if(check == 0) { fscanf(f1,"%d",&val); label2:

7

if(val == 10) { fscanf(f1,"%lf",&min_x); fscanf(f1,"%d",&val); goto label2; } if(val == 20) { fscanf(f1,"%lf",&min_y); fscanf(f1,"%d",&val); goto label2; } if(val == 30) { fscanf(f1,"%lf",&min_alt); fscanf(f1,"%d",&val); goto label2; } } check=strcoll(EXTMAX,texte); if(check == 0) { fscanf(f1,"%d",&val); label3: if(val == 10) { fscanf(f1,"%lf",&max_x); fscanf(f1,"%d",&val); goto label3; } if(val == 20) { fscanf(f1,"%lf",&max_y); fscanf(f1,"%d",&val); dif_x=max_x-min_x; nb_col=(int)((dif_x/pix_size)+0.5); dif_y=max_y-min_y; nb_lig=(int)((dif_y/pix_size)+0.5); ///////////////////////////////////// printf("\n\n Primera aproximacion : "); printf("\n\n lineas = %d columnas = %d \n\n",nb_lig,nb_col); goto label3; } if(val == 30) { fscanf(f1,"%lf",&max_alt); fscanf(f1,"%d",&val); goto label3; } } check=strcoll(POLYLINE,texte); if(check == 0) { segm++; printf("\tsegment %d \r ",segm); flag=0; } check=strcoll(VERTEX,texte);

8

if(check == 0) { for(j=1; j<=reg; j++) { fscanf(f1,"%s",texte); } fscanf(f1,"%d",&val); fscanf(f1,"%lf",&dval1); // columnas = x fscanf(f1,"%d",&val); fscanf(f1,"%lf",&dval2); // lineas = y fscanf(f1,"%d",&val); fscanf(f1,"%lf",&dval3); // altitudes fscanf(f1,"%d",&val); if(min_dyn > dval3) min_dyn=dval3; if(max_dyn < dval3) max_dyn=dval3; if(dval2 == max_y) { if(minx > dval1) minx=dval1; } if(dval1 == max_x) { if(maxy < dval2) maxy=dval2; } } } ///////////////////////////////////////////// printf("\n\n angulo de rotacion (decimal) ? "); scanf("%lf",&angle); do { printf("\n rotacion: sentido :\n\t0 ====> izquierdo\n\t1 ====> derecho\n\t"); scanf("%d",&sentido); } while(sentido != 0 && sentido != 1); T=angle*api; S=sin(T); C=cos(T); cote=(double)nb_col*S; d_col=(double)nb_col-cote; hypo=sqrt((cote*cote)+(d_col*d_col)); pix_size_def=(pix_size*hypo)/(double)nb_col; label36: printf("\n Numero total de segmentos = %d ",segm); printf("\n\n Dyn. Min = %lf Max = %lf ",min_dyn,max_dyn); printf("\n\n Min Y = %lf Max Y = %lf ",min_y,max_y); printf("\n Min X = %lf Max X = %lf ",min_x,max_x); rewind(f1); flag_sect=0; segm=0; pix_size=pix_size_def; while (!feof(f1)) { fscanf(f1,"%s",texte); check=strcoll(SECTION,texte); if(check == 0) {

9

flag_sect++; } check=strcoll(ENDSEC,texte); if(check == 0) { } check=strcoll(HEADER,texte); if(check == 0) { } check=strcoll(TABLES,texte); if(check == 0) { } check=strcoll(EXTMIN,texte); if(check == 0) { fscanf(f1,"%d",&val); label21: if(val == 10) { fscanf(f1,"%lf",&min_x); fscanf(f1,"%d",&val); goto label21; } if(val == 20) { fscanf(f1,"%lf",&min_y); fscanf(f1,"%d",&val); goto label21; } if(val == 30) { fscanf(f1,"%lf",&min_alt); fscanf(f1,"%d",&val); goto label21; } } check=strcoll(EXTMAX,texte); if(check == 0) { fscanf(f1,"%d",&val); label31: if(val == 10) { fscanf(f1,"%lf",&max_x); fscanf(f1,"%d",&val); goto label31; } if(val == 20) { fscanf(f1,"%lf",&max_y); fscanf(f1,"%d",&val); dif_x=max_x-min_x; nb_col=(int)((dif_x/pix_size)+0.5); dif_y=max_y-min_y; nb_lig=(int)((dif_y/pix_size)+0.5); printf("\n\n Segunda aproximacion : "); printf("\n\n pix_size %lf lineas = %d columnas = %d \n\n",pix_size,nb_lig,nb_col);

10

// getch(); /* fprintf(f2d,"%d\n%d\n%d\n%d\n",nb_lig,nb_col,1,(int)min_alt); */ dtab=dmatrice(nb_col+2,nb_lig+2); tab=ucmatrice(nb_col,nb_lig); tab2=ucmatrice(nb_col,nb_lig); for(i=0; i<nb_lig+1; i++) for(j=0; j<nb_col+1; j++) dtab[i][j]=ival; for(i=0; i<nb_lig; i++) for(j=0; j<nb_col; j++) tab[i][j]=(unsigned char)255; goto label31; } if(val == 30) { fscanf(f1,"%lf",&max_alt); fscanf(f1,"%d",&val); // fprintf(f2d,"%d\n%lf\n",(int)max_alt,pix_size); goto label31; } } check=strcoll(POLYLINE,texte); if(check == 0) { segm++; printf("\tsegment %d \r ",segm); flag=0; ico=0; } check=strcoll(VERTEX,texte); if(check == 0) { ico++; for(j=1; j<=reg; j++) { fscanf(f1,"%s",texte); } fscanf(f1,"%d",&val); fscanf(f1,"%lf",&dval1); // columnas = x fscanf(f1,"%d",&val); fscanf(f1,"%lf",&dval2); // lineas = y fscanf(f1,"%d",&val); fscanf(f1,"%lf",&dval3); // altitudes fscanf(f1,"%d",&val); /* if(segm > 400) { printf("\n vertex %d dval1 %lf dval2 %lf dval3 %lf ",ico,dval1,dval2,dval3); } */ if(min_dyn > dval3) min_dyn=dval3; if(max_dyn < dval3) max_dyn=dval3; if(dval2 == max_y) { if(minx > dval1) minx=dval1; } if(dval1 == max_x) { if(maxy < dval2) maxy=dval2; } /* if(miny > dval2) miny=dval2;

11

if(maxy < dval2) maxy=dval2; if(minx > dval1) minx=dval1; if(maxx < dval1) maxx=dval1; */ if(flag == 0) { f_ideb=(dval2-min_y)/pix_size; f_ideb=(double)nb_lig-f_ideb; f_jdeb=(dval1-min_x)/pix_size; // printf("\n rotation angle %lf sentido %d ideb %lf jdeb %lf ",angle,sentido,f_ideb,f_jdeb); rotation(angle,sentido,f_ideb,f_jdeb); // printf("\n sortie rota f_ideb %lf f_jdeb %lf id2 %lf jd2 %lf ",f_ideb,f_jdeb,id2,jd2); getch(); ideb=(int)(id2+.5); jdeb=(int)(jd2+.5); flag++; point=1; } else { f_ifin=(dval2-min_y)/pix_size; f_ifin=(double)nb_lig-f_ifin; f_jfin=(dval1-min_x)/pix_size; rotation(angle,sentido,f_ifin,f_jfin); // printf("\n f_ifin %lf f_jfin %lf id2 %lf jd2 %lf ",f_ifin,f_jfin,id2,jd2); getch(); ifin=(int)(id2+.5); jfin=(int)(jd2+.5); trace_droite(ideb,jdeb,ifin,jfin,dval3); ideb=ifin; jdeb=jfin; } } } /////////////////////////////////////////////////////// // fprintf(f2d,"%d\n%d\n%d\n%d\n",nb_lig,nb_col,1,(int)min_alt); ico=jco=0; flag=0; for(i=0; i<nb_lig; i++) { for(j=0; j<nb_col; j++) { val=(int)dtab[i][j]; ico++; if(val != (int)ival) { if(flag == 0) { flag=1; jco++; tabval[jco]=val; } else { lco=0; for(n=1; n<=jco; n++) { if(val == tabval[n])

12

{ lco++; } } if(lco == 0) { jco++; tabval[jco]=val; } } } } } valprov=(int)min_dyn; tabord[1]=(int)min_dyn; intervalo=tabval[10]-tabval[9]; intervalo=abs(intervalo); printf("\n\n Intervalo altimetrico = %d ",intervalo); do { printf("\n\n 0 ====> tomar en cuenta este intervalo\n 1 ====> elegir otro\n "); scanf("%d",&rep); } while(rep != 0 && rep != 1); if(rep == 1) { printf("\n valor del intervalo ? "); scanf("%d",&intervalo); } printf("\n\n Definicion de los valores de la tabla de correspondencia :"); printf("\n\n\tValor minimo ? "); scanf("%d",&val_minimo); printf("\n\tValor maximo ? "); scanf("%d",&val_maximo); num_segment=((val_maximo-val_minimo)/intervalo); if(num_segment > 253) { printf("\n\n El numero total de intervalos (%d) es demasiado grande ",num_segment+1); getch(); exit(0); } val_deb=val_minimo-intervalo; for(i=1; i<=num_segment+1; i++) { val_deb=val_deb+intervalo; tabord[i]=val_deb; } for(k=1; k<=num_segment+1; k++) { fprintf(f3d," %d %d \n",k,tabord[k]); } // fprintf(f2d,"%d\n%d\n%d\n%d\n%lf\n\n",nb_lig,nb_col,1,val_minimo,val_maximo,pix_size); printf("\n\n Guardando \n\n"); for(i=0; i<nb_lig; i++) { if (((i+1)%200)==0) printf("\tlinea %d \r ",i+1); for(j=0; j<nb_col; j++)

13

{ // for(k=1; k<jco; k++) for(k=1; k<num_segment+1; k++) { if((int)dtab[i][j] == tabord[k]) tab[i][j]=(unsigned char)k; } } } for(i=1; i<nb_lig-1; i++) { for(j=1; j<nb_col-1; j++) { if((int)tab[i][j] != 255) { val=(int)tab[i][j]; jval=0; if((int)tab[i-1][j-1] == val) jval=1; if((int)tab[i-1][j] == val) jval=jval+2; if((int)tab[i-1][j+1] == val) jval=jval+4; if((int)tab[i][j+1] == val) jval=jval+8; if((int)tab[i+1][j+1] == val) jval=jval+16; if((int)tab[i+1][j] == val) jval=jval+32; if((int)tab[i+1][j-1] == val) jval=jval+64; if((int)tab[i][j-1] == val) jval=jval+128; if(jval == 130 || jval == 10 || jval == 40 || jval == 160) { tab[i][j]=(unsigned char)255; } } } } } /***************************************************/ /* extraction */ /***************************************************/ void extraction() { int i,j; int i3,j3; int min_i=10000,max_i=0; int min_j=10000,max_j=0; for(i=0; i<nb_lig; i++) { for(j=0; j<nb_col; j++) { if((int)tab[i][j] != 255) { if(min_i > i) min_i=i; if(max_i < i) max_i=i; if(min_j > j) min_j=j; if(max_j < j) max_j=j; } } } /* printf("\n min_i %d max_i %d ",min_i,max_i);

14

printf("\n min_j %d max_j %d ",min_j,max_j); getch(); */ nb_lig3=(max_i-min_i)+1; nb_col3=(max_j-min_j)+1; tab3=ucmatrice(nb_col3,nb_lig3); i3=0; for(i=min_i; i<=max_i; i++) { j3=0; for(j=min_j; j<=max_j; j++) { tab3[i3][j3]=tab[i][j]; j3++; } i3++; } fprintf(f2d,"%d\n%d\n%d\n%d\n%d\n%lf\n\n",nb_lig3,nb_col3,1,val_minimo,val_maximo,size_pix); fprintf(f2d,"\n\n\n Coordenadas UTM :"); fprintf(f2d,"\n\tX min : %lf Y min : %lf ",min_x,min_y); fprintf(f2d,"\n\tX max : %lf Y max : %lf ",max_x,max_y); fprintf(f2d,"\n\n\t\t\t\tCopyright J.F. Parrot"); fclose(f2d); } /***************************************************/ /* rotation */ /***************************************************/ void rotation(double angle,int sens,double i_in,double j_in) { int i,j,val; int i2,j2; int sentido; double desv,ic,jc; double dif_i,dif_j; double hypo,base,altura; double id,jd,T; double S,C; double pi=4*atan(1.),api=pi/180.; desv=angle; sentido=sens; /* printf("\n\n angulo de convergencia de cuadricula : %lf ",desv); if(sentido == 0) printf("\n sentido de la desviacion : izquierda"); else printf("\n sentido de la desviacion : derecha\n"); */ ic=(double)nb_lig/2.; jc=(double)nb_col/2.; // printf("\n ic %lf jc %lf ",ic,jc); id=i_in; jd=j_in; dif_i=ic-id; dif_j=jd-jc; hypo=sqrt((dif_i*dif_i)+(dif_j*dif_j)); S=(double)dif_i/hypo; C=(double)dif_j/hypo;

15

T=atan2(S,C); T=T/api; if(T < 0.) T=T+360; // printf("\n angle entree = %lf desv %lf ",T,desv); if(sentido == 0) { T=T+desv; if(T > 360.) T=T-360.; } else { T=T-desv; if(T < 0.) T=T+360.; } // printf("\n angle sortie = %lf desv %lf ",T,desv); T=T*api; S=sin(T); C=cos(T); dif_i=S*hypo; dif_j=C*hypo; id2=ic-dif_i; jd2=jc+dif_j; // printf("\n id %lf jd %lf id2 %lf jd2 %lf \n\n",id,jd,id2,jd2); // getch(); } /***************************************************/ /* save */ /***************************************************/ void save() { int i; for(i=0; i<nb_lig3; i++) fwrite(tab3[i],nb_col3,sizeof(unsigned char),f2); fclose(f2); } /***************************************************/ /* opening */ /***************************************************/ void opening() { char nomim1[128],nomim2[128],nomdir[128],nomfic1[128]; char nomdescr2[128],nomdescr3[128]; printf("\n\t***********************************************************"); printf("\n\t* *"); printf("\n\t* DXF_V2 *"); printf("\n\t* Proyección de vector a Raster *"); printf("\n\t* *"); printf("\n\t* *"); printf("\n\t* HIND TAUD *"); printf("\n\t* (noviembre de 2006) *"); printf("\n\t***********************************************************");

16

strcpy(nomim1,"c:\\images\\"); printf("\n\n Nombre del archivo : "); scanf("%s",nomdir); strcat(nomim1,nomdir); strcat(nomim1,"\\"); strcpy(nomim2,nomim1); printf("\n\n Nombre de la Fila .dxf (sin extension .dxf) ? "); scanf("%s",nomfic1); strcat(nomim1,nomfic1); strcat(nomim1,".dxf"); if ((f1=fopen(nomim1,"r")) == NULL) { printf("\n No hay Fila %s \n",nomim1); getch(); exit(0); } printf("\n\n Nombre de la imagen resultante (sin extension _trdxf.raw) ? "); scanf("%s",nomfic1); strcat(nomim2,nomfic1); strcpy(nomdescr2,nomim2); strcpy(nomdescr3,nomim2); strcat(nomim2,"_trdxf.raw"); strcat(nomdescr2,"_trdxf.txt"); strcat(nomdescr3,"_trdxf_tab.txt"); f2=fopen(nomim2,"wb"); f2d=fopen(nomdescr2,"w"); f3d=fopen(nomdescr3,"w"); }

Anexo B

/*======================================================*/

/* programa agrupacion version 1 noviembre 2006 */

/*======================================================*/

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <math.h>

#include <time.h>

#include <stdlib.h>

#include <values.h>

#include <limits.h>

#include <io.h>

#include <conio.h>

#include "c:\prog\lib\nrutil.cpp"

#include "c:\prog\lib\nrutil.h"

17

#define ival -999.0

void opening();

void treatment();

struct imagen

{

unsigned char nombre[128];

unsigned char tipodato[64];

int min_etiq[100];

double media_etiq[100];

double mediana_etiq[100];

int max_etiq[100];

double desv[100];

}capas[100];

char nomgen[128];

unsigned char **tab,**tab2,**tab3;

int nb_lig,nb_col;

int nb_lig3,nb_col3;

int val_minimo,val_maximo;

int num_arch;

double min_x,min_y,min_alt;

double max_x,max_y,max_alt;

double pix_size,id2,jd2,size_pix;

double **dtab;

FILE *f1,*f2,*f2d,*f3d;

/***************************************************/

/* main */

/***************************************************/

main()

{

opening();

treatment();

}

/***************************************************/

/* treatment */

/***************************************************/

void treatment()

{

int i,j,k,val,jval,check;

int segm=0,point,ico,rep;

int intervalo,val_deb,num_segment;

18

int flag,ideb,jdeb,ifin,jfin;

int flag_sect,line;

int jco,lco,n,valprov,difmin;

int tabval[260],tabord[260];

int sentido;

char nomim3[128],Buff[128];

double angulo;

double f_ideb,f_jdeb,f_ideb2,f_jdeb2;

double f_ifin,f_jfin,f_ifin2,f_jfin2;

double min_dyn=10000.,max_dyn=0.;

double miny=4000000.,maxy=0.,minx=4000000.,maxx=0.;

double minalt=100000.,maxalt=0.;

double dif_x,dif_y,hypo;

double dval,dval1,dval2,dval3;

double pix_size_def,dif_j;

double S,C,T,CT,TA,TA2;

double cote,d_col,angle;

double pi=4*atan(1.),api=pi/180.;

char texte[80];

char *SECTION="SECTION",*POLYLINE="POLYLINE",*VERTEX="VERTEX",*ENDSEC="ENDSEC"; //

enter = 0

char *TABLE="TABLE",*SEQEND="SEQEND",*TEXTSTYLE="$TEXTSTYLE";

char *AC1006="AC1006"; // enter = 1

char *HEADER="HEADER",*ENTITIES="ENTITIES",*TABLES="TABLES"; // enter = 2

char *INSBASE="$INSBASE",*EXTMIN="$EXTMIN",*EXTMAX="$EXTMAX",*ACADVER="$ACADVER"; // enter

= 9

char *CECOLOR="$CECOLOR",*CELTYPE="$CELTYPE"; // enter = 9

// char *EOF="EOF";

for(i=0; i<260; i++)

tabval[i]=0;

printf("\n treatment\n");

for(i=1; i<=num_arch; i++)

{

strcpy(nomim3,capas[i].nombre);

printf("\n\n Archivo %d Nombre : %s \n\n",i,nomim3);

f1=fopen(nomim3,"r");

// printf("\n open OK ");

flag_sect=0;

segm=0;

while (!feof(f1))

19

{

fscanf(f1,"%s",texte);

check=strcoll(SECTION,texte);

if(check == 0)

{

flag_sect++;

}

check=strcoll(ENDSEC,texte);

if(check == 0)

{

}

check=strcoll(HEADER,texte);

if(check == 0)

{

}

check=strcoll(TABLES,texte);

if(check == 0)

{

}

check=strcoll(EXTMIN,texte);

if(check == 0)

{

fscanf(f1,"%d",&val);

label2:

if(val == 10)

{

fscanf(f1,"%lf",&min_x);


// printf("\n min_x %lf ",min_x);

if(minx > min_x) minx=min_x;

goto label2;

}

if(val == 20)

{

fscanf(f1,"%lf",&min_y);


// printf("\n min_y %lf ",min_y);

if(miny > min_y) miny=min_y;

goto label2;

}

if(val == 30)

{

fscanf(f1,"%lf",&min_alt);


20

// printf("\n min_alt %lf ",min_alt);

if(minalt > min_alt) minalt=min_alt;

goto label2;

}

}

check=strcoll(EXTMAX,texte);

if(check == 0)

{


label3:

if(val == 10)

{

fscanf(f1,"%lf",&max_x);


// printf("\n max_x %lf ",max_x);

if(maxx < max_x) maxx=max_x;

goto label3;

}

if(val == 20)

{

fscanf(f1,"%lf",&max_y);


// printf("\n max_y %lf ",max_y);

if(maxy < max_y) maxy=max_y;

goto label3;

}

if(val == 30)

{

fscanf(f1,"%lf",&max_alt);


// printf("\n max_alt %lf ",max_alt);

if(maxalt < max_alt) maxalt=max_alt;

goto label3;

}

}

check=strcoll(POLYLINE,texte);

if(check == 0)

{

segm++;

printf("\tsegment %d \r ",segm);

flag=0;

}

check=strcoll(VERTEX,texte);

if(check == 0)

21

{

for(j=1; j<=4; j++)

{


}


fscanf(f1,"%lf",&dval1); // columnas = x


fscanf(f1,"%lf",&dval2); // lineas = y


fscanf(f1,"%lf",&dval3); // altitudes


if(min_dyn > dval3) min_dyn=dval3;

if(max_dyn < dval3) max_dyn=dval3;

}

label4:

}

fclose(f1);

}

printf("\n\n min x = %lf min y = %lf ",minx,miny);

printf("\n max x = %lf max y = %lf ",maxx,maxy);

printf("\n min a = %lf max a = %lf \n\n",minalt,maxalt);

// rewind(f1);

fprintf(f2," 0\n");

fprintf(f2,"SECTION\n");

fprintf(f2," 2\n");

fprintf(f2,"HEADER\n");

fprintf(f2," 9\n");

fprintf(f2,"$EXTMIN\n");

fprintf(f2," 10\n");

fprintf(f2,"%d\n %d\n",(int)minx,20);

fprintf(f2,"%d\n %d\n",(int)miny,30);

fprintf(f2,"%d\n %d\n",(int)minalt,9);

fprintf(f2,"$EXTMAX\n");

fprintf(f2," 10\n");

fprintf(f2,"%d\n %d\n",(int)maxx,20);

fprintf(f2,"%d\n %d\n",(int)maxy,30);

fprintf(f2,"%d\n %d\n",(int)maxalt,0); // copier hasta polyline

fprintf(f2,"ENDSEC\n %d\n",0); //

fprintf(f2,"SECTION\n %d\n",2); //

fprintf(f2,"ENTITIES\n %d\n",0); //


{

22

strcpy(nomim3,capas[i].nombre);

printf("\n\n Archivo %d Nombre : %s ",i,nomim3);

f1=fopen(nomim3,"r");

// printf("\n open OK ");

flag=0;

segm=0;

printf("\n\n");

while (!feof(f1))

{


check=strcoll(POLYLINE,texte);

if(check == 0)

{

flag=1;

segm++;

printf("\t segmento %d \r ",segm);

fprintf(f2,"POLYLINE\n");


fprintf(f2," %d\n",val);


fprintf(f2,"%s\n",texte);






fprintf(f2,"% d\n",val);










fprintf(f2,"%d\n",val);



}

check=strcoll(VERTEX,texte);

if(check == 0)

{

23

fprintf(f2,"VERTEX\n");



fscanf(f1,"%s",texte); // CN_3301


fscanf(f1,"%d",&val); // 62






fscanf(f1,"%lf",&dval); // 338959

fprintf(f2,"%d\n",(int)(dval+0.5));



fscanf(f1,"%lf",&dval); // 2793430




fscanf(f1,"%lf",&dval); // 2090




}

check=strcoll(SEQEND,texte);

if(check == 0)

{

fprintf(f2,"SEQEND\n");

fprintf(f2,"%d\n",0);

}

check=strcoll(ENDSEC,texte);

if(check == 0)

{

if(flag == 1)

{

fprintf(f2,"ENDSEC\n");

fprintf(f2,"%d\n",0);

}

}

}

fclose(f1);

}

fprintf(f2,"EOF\n");

fclose(f2);

24

}

/***************************************************/

/* opening */

/*************************************************/

void opening()

{

char nomim1[128],nomim2[128],nomdir[128],nomfic1[128];

char nomdescr2[128],nomdescr3[128],nomfic[128];

int i;

printf("\n\t***********************************************************");

printf("\n\t* *");

printf("\n\t* SUM_DXF *");

printf("\n\t* *");

printf("\n\t* Hind Taud *");

printf("\n\t* (noviembre de 2006) *");

printf("\n\t* *");

printf("\n\t***********************************************************");

strcpy(nomim1,"c:\\images\\");

printf("\n\n Nombre del archivo : ");

scanf("%s",nomdir);

strcat(nomim1,nomdir);

strcat(nomim1,"\\");

strcpy(nomgen,nomim1);

printf("\n\n Numero de archivos a pegar ? ");

scanf("%d",&num_arch);


{

printf("\n\n Name of the file .dxf numero %d (sin extension .dxf) ? ",i);

scanf("%s",nomfic);

strcpy(nomim2,nomgen);

strcat(nomim2,nomfic);

strcat(nomim2,".dxf");

strcpy(capas[i].nombre,nomim2);

} printf("\n\n Nombre del archivo .dxf (sin extension .dxf) ? ");

scanf("%s",nomfic1);

strcat(nomim1,nomfic1);

strcat(nomim1,".dxf");

f2=fopen(nomim1,"w"); }

/*-----------------------------------------*/

25

generacion automatica del modelo digital del...

Documents