¿Cómo convertir DXF 3D a PostGIS 2.0?

Question

Yo no soy muy experto en el uso de postgis, pero me enfrento a un problema que debo resolver, es decir, crear tablas para carga de datos geográficos almacenados como dxf.

Tengo mil archivos dxf (3d) con polilíneas, puntos y polígonos, y quiero convertir a un postgis/postgres db.

Estoy en windows xp utilizando postgres 9 postgis 2.0.

Gdal/OGR se instalan mediante Osgeo4Win instalador. Puedo escribir básicos de secuencia de comandos de python para manejar datos en lote.

Puede usted por favor me dirija a algunas útil tutorial/sugerencia sobre cómo hacer frente a este problema. Gracias de antemano

Answer 1

Estoy un poco tarde, pero espero que ayude.

Tuts y libros

Si quieres aprender algo acerca de la ogr, gdal, python y postGIS usted puede mirar la primera de estas páginas y el libro.

Geoprocesamiento con Python usando Open Source GIS

http://www.gis.usu.edu/~chrisg/python/

ogr

http://www.gdal.org/ogr/

ogr2ogr - cheatsheet

http://www.bostongis.com/?content_name=ogr_cheatsheet#41

para un ejemplo de programación no es un apitutorial para C++, C y Python

http://www.gdal.org/ogr/ogr_apitut.html

también puedes empezar por aquí:

http://wiki.osgeo.org/wiki/OSGeo_Python_Library

http://trac.osgeo.org/gdal/wiki/GdalOgrInPython

PostGIS

http://www.bostongis.com/ es siempre un buen punto de partida. Y también la libro "PostGIS en Acción" por ellos, es una gran guid a PostGIS.

Otra buena visión general se puede encontrar en el siguiente libro:

Erik Westra, Python Geoespacial De Desarrollo.

http://www.packtpub.com/python-geospatial-development/book

Ahora a su problema específico.

Primer Problema De Geometría

La GEOMETRÍA en formato dxf vs GEOMETRÍA en el SIG

Uno de los problemas es la definición de las geometrías en dxf y en SIG

Geometrías en dxf:

Los puntos son siempre puntos, no hay ningún problema aquí.

Linestrings son linestrings, theres ningún problema hasta ahora.

Pero cuando se trata de los polígonos que hay un problema con el archivo dxf. Los polígonos que siempre representado como LINESTRING!!! Siempre que usted elija polígono o 3dpoly como opción, para crear un polígono, que será un linestring.

Si su lectura de las características de una ficheros dxf con ogr la representación de polígonos es siempre una representación de una cadena de línea.

Ejemplo:

WKT-cadena: cadena de línea(1 1 1,2 1 1,2 2 1,1 2 1,1 1 1)

Pero debe ser:

WKT: POLÍGONO(1 1 1,2 1 1,2 2 1,1 2 1,1 1 1)

Ver Wikipedia para WKT-notación

ogr2ogr no cambia esto. Tienes que hacerlo tú mismo. Cubrimos esta tarde.

El segundo Problema - ogr2ogr

El gran problema con ogr2ogr es saber cuál de todas estas opciones son para y donde aprender acerca de. No hay mucho ayudar con ogr2ogr --help o ogr2ogr - mucho-uso en la línea de comandos. Así que por ensayo y error, he descubierto la siguiente.

ogr2ogr -dsco INIT_WITH_EPSG=yes -lco LAUNDER=yes -lco SPATIAL_INDEX=yes \
    -append -skipfailures -f PostgreSQL \
    PG:"dbname={dbname} user={user} password={password} schemas={schema}" \
    -nln {yourtable} \
    -nlt {geometry}25D \
    -a_srs EPSG:{EPSG-Code}
    {srs-file}.dxf

Aquí están las opciones (para la Versión 1.9):

• dsco INIT_WITH_EPSG -- no seguros de que vamos a necesitar para PostgreSQL, obras de Spatialite
• lco -- capa de opción de creación; LAVE=sí todas las cadenas para bajar y algunos especiales charackters será presentado como subrayado
• lco SPATIAL_INDEX=sí; crea un índice espacial
• append (y/o de actualización) -- anexar a la tabla existente
• skipfailures -- el uso de esta opción, de lo contrario ogr2ogr se detendrá en caso de encontrar un la geometría que no está definido en la tabla
• f PostgreSQL : escribir en PostgreSQL
• nln -- yourtablename
  • crear una tabla con este nombre en el db, sin! columnas, esto se ogr2ogr hacer, toma el dxf-estructura (capa, subclases, extendedentity, tipo de línea, entityhandle, texto)
  • si usted desea que su propio columnas, usted tiene que averiguar por ti mismo
  • sin nln crea una tabla de "entidades"
• nvi - nueva capa de tipo; aquí se puede elegir entre un 2D o 3D de la geometría
  • de ogr2ogr-mucho-uso de la
  • nlt tipo: la Fuerza de un tipo de geometría para la nueva capa. Uno de NINGUNO, GEOMETRÍA, PUNTO, CADENA DE LÍNEA, POLÍGONO, GEOMETRYCOLLECTION, MULTIPUNTO, MULTIPOLYGON, o MULTILINESTRING. Añadir "25D" para las capas 3D Por defecto es el tipo de capa de origen.
  • por defecto representación de dxf-características es en 2D!, pero con tres coordenadas, por lo que ogr2ogr conjuntos de valores Z siempre a cero
• a_srs EPSG: -- asignar una salida EPSG-código

Tienes que hacer esto por los puntos, linestrings y geometrycollections.

A continuación, puede escribir una secuencia de comandos de shell como este (creado por underdark)

for f in `ls *dxf` do
ogr2ogr -dsco INIT_WITH_EPSG=yes -lco LAUNDER=yes -lco SPATIAL_INDEX=yes \
  -append -skipfailures -f PostgreSQL \
  PG:"dbname={dbname} user={user} password={password} schemas={schema}" \
  -nln $f \
  -nlt {geometry}25D \
  -a_srs EPSG:{EPSG-Code}
  $f
done

Así, entonces usted tiene una tabla con los puntos, una tabla con linestrings y una tabla de con geometrycollections. Ahora usted tiene que averiguar dónde está su polígonos son. Usted puede encontrar con la siguiente expresión SQL. Devuelve todos linestrings donde el primer punto y el último punto son iguales. Usted puede poner esta en un SELECT INTO-instrucción y crear una nueva tabla. Después de que usted también puede limpiar su cadena de línea de la tabla con esta declaración. También es posible crear un trigger así que será un poco más cómodo ;-).

SELECT ogc_fid, layer,
       ST_Polygon(ST_GeomFromEWKT(ST_asText(wkb_geometry)), {EPSG-Code}) as the_geom
INTO {your-polygon-table} 
FROM {your-linestring-table}
WHERE ST_StartPoint(wkb_geometry) = ST_EndPoint(wkb_geometry);

Answer 2

Hice un script en Python, no soy un guru de Python, pero funciona. Pide a todos los parámetros para conectar a postgis y una carpeta para procesar. Enumera todos los archivos de dxf en una carpeta (y subcarpetas) y crea una tabla postgis con el primero, luego añadir todas las geometrías de los otros dxf. Registra todos los archivos y secuencias de procesamiento en un archivo txt. Aquí está:

#

    # Script che processa tutti i dxf in una cartella e nelle sottocartelle         #
    # da lanciare da una shell python con il comando execfile('dxftopostgis.py')    #
    # al lancio chiede la cartella da processare, i parametri per connettersi al db #
    # ed il numero del sistema di ccordinate secondo EPSG.                          #
    # Made by Pietro Rossin                                                         #
    #################################################################################
    import os, glob

    try:
        from osgeo import ogr
    except:
        import ogr

    import gdal
    from gdalconst import *

    in_workspace = str(raw_input("Dammi il percorso per la cartella coi dxf: "))
    host = str(raw_input("Server con postgis: "))
    dbname = str(raw_input("Nome db: "))
    user = str(raw_input("Username: "))
    pword = str(raw_input("Password: "))
    epsg = str(raw_input("Numero EPSG?: "))

    #entra nella cartella da processare e crea una lista di folders
    os.chdir(in_workspace)
    listafolders= os.listdir(in_workspace)

    #apre un file su cui loggare le stringhe di processamento
    outfile = open(in_workspace + '\Log_processamento.txt','w')

    #ciclo per processare tutti i file delle sottodirectory
    primo = 1
    for folder in listafolders:
        currentfolder = in_workspace + folder
        #modulo glob per espandere i percorsi con caratteri jolly
        filelist = glob.glob(currentfolder + '\*.dxf')
        for file in filelist:
            #print file
            if primo == 1:
                stringaprocessare = 'ogr2ogr --config DXF_INLINE_BLOCKS FALSE --config DXF_MERGE_BLOCK_GEOMETRIES FALSE -f "PostgreSQL" PG:"host= '\
                + host + " user=" + user + " dbname=" + dbname + " password="+ pword + "\" " +" -lco DIM=3 " + file + " -where \"Layer NOT LIKE 'X%'\"" +" -overwrite -a_srs EPSG:" + epsg + " entities"

            else:
                    stringaprocessare = 'ogr2ogr --config DXF_INLINE_BLOCKS FALSE --config DXF_MERGE_BLOCK_GEOMETRIES FALSE -f "PostgreSQL" PG:"host= '\
                + host + " user=" + user + " dbname=" + dbname + " password="+ pword + "\" " + file + " -where \"Layer NOT LIKE 'X%'\"" +" -append " +  "entities"

            primo = -1
            print 'Sto processando il file '+ file
            os.system(stringaprocessare)
            outfile.write(stringaprocessare + "\n")

    else: 
        outfile.close()