Convertir archivo de ArcGIS (*.mxd) a archivo de QGIS (*.qgs)

Question

Recientemente intenté usar QGIS y me preguntaba si es posible convertir un mapa preliminar de ArcGIS (*.mxd archivo) en un proyecto de QGIS (*.qgs archivo). ¿Hay alguna solución disponible?

Esto evitaría tener que tematizar todo el proyecto.

Answer 1

Esto parece ser lo que estás buscando: https://underdark.wordpress.com/2011/05/27/converting-mxd-to-qgis-project-file/

El miércoles, Allan Maungu anunció MXD2QGS, un convertidor que exporta capas de un documento de Arcmap 10 a un archivo de proyecto Quantum GIS. La herramienta está construida como un ArcToolbox y se puede descargar desde el blog.

El único enlace de descarga que parece funcionar es este https://sites.google.com/site/lumtegis/files/Mxd2Qgs.zip

A partir de agosto de 2017, esta herramienta también parece estar disponible en https://github.com/fitnr/mxd2qgs

Al parecer, también hay uno para archivos de ArcView 3.x: http://gix.sourceforge.net/

Answer 2

GeoCAT ofrece un complemento comercial de ArcMap llamado 'Bridge' que puede convertir toda su simbología de ArcMap a SLD (hay una alternativa de código abierto arcmap2sld). En QGIS puede importar SLD y utilizarlo como estilo para la capa de QGIS. En Bridge, la estructura de árbol del TOC se exporta como WMC, y los datos como shapefiles (incluidos los metadatos .shp.xml) y archivos tiff.

Me gustaría crear una herramienta en QGIS que pueda leer el WMC, los SLD y los datos para crear un proyecto de QGIS a partir de eso.

Answer 3

El plugin SLYR convertirá MXD a QGIS. Desafortunadamente, hasta el 2020, este plugin no es de código abierto y es bastante costoso. Existe una versión comunitaria gratuita, pero tiene una funcionalidad bastante limitada.

Answer 4

Basado en Mxd2Qgs de Allan Maungu desarrollamos una herramienta de ArcMap para convertir MXD de ArcMap (probado con ArcMap 10.7) a proyectos de QGIS. El proyecto es de Código Abierto: https://github.com/WhereGroup/mapqonverter

Answer 5

He descargado el ejecutable MXD2QGS y el archivo python. Tuve algunos problemas con el xml.dom.ext ya que ese módulo no está empaquetado con Python 2.6 o 2.7. Me deshice de esa llamada y reescribí la línea 411 a:

f.write(doc.toprettyxml())

Esto se encargará de escribir la salida en lugar de utilizar xml.dom.ext.

Además, tuve que cambiar la línea 227 por:

if(lyr.isGroupLayer == False and lyr.isRasterLayer == False and lyr.isFeatureLayer == True):

Esto se debe a que el script parecía tener problemas con las capas de anotaciones, así que quería filtrar más añadiendo el lyr.isFeatureLayer == True condición

Entonces, esto me da el archivo de salida .qgs. Abrí Quantum y abrí este archivo. Ahora recibo el diálogo 'Handle Bad layers'. Esto es prometedor, porque el nuevo archivo .qgs realmente reconoce todas las capas que tenía en mi .mxd. Restablezco todas las fuentes de las capas a los shapefiles subyacentes, los enlaces se vuelven verdes, pero cuando presiono OK, recibo un mensaje de que todas las capas siguen sin ser manejadas y que se perderán. Vuelvo a pulsar OK y no aparece nada en Quantum.

Tengo la sospecha de que el análisis del xml desde el archivo .mxd al archivo .qgs puede no estar escribiendo correctamente porque parece que no puedo conseguir xml.dom.ext prettyprint para trabajar, así que tal vez no está escribiendo el xml correctamente con mi solución. No sé mucho acerca de la función prettyprint sin embargo. Eso es todo lo que se me ocurre. Si alguien más tiene alguna idea de por qué el diálogo "Manejar capas malas" está solicitando? He hecho una pequeña búsqueda en la web, pero nada parece ofrecer una explicación.

Ah, y PS, yo hardcoded la ubicación de mi .mxd y la ubicación del archivo de salida y corrió el script de IDLE en lugar de la herramienta. También corrí esto en ambos ArcGIS 10.0 (Python 2.6) y ArcGIS 10.1 (Python 2.7) y ambos parecían funcionar bien con los mismos resultados.

Aquí está mi código para cualquiera que quiera recoger esto y ayudar a solucionar problemas:

#-----------------------------------------------------------
#
# Mxd2Qgs ver 1.0
# Copyright (C) 2011 Allan Maungu 
# EMAIL: lumtegis (at) gmail.com
# WEB  : http://geoscripting.blogspot.com
# Usage : Exporting current ArcMap document layers to Quantum GIS file
# The resulting file can be opened in Quantum GIS
# Tested on ArcMap 10, Python 2.6.5 and Quantum GIS 1.6.0
#-----------------------------------------------------------
#
# licensed under the terms of GNU GPL 2
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
#---------------------------------------------------------------------

# Import system modules
from xml.dom.minidom import Document
import xml.dom.ext
import string
import os
import arcpy

#Read input parameters from GP dialog
#output = arcpy.GetParameterAsText(0)
output = r"C:\Projects\Test.qgs"

#Create an output qgs file
f = open(output, "w")

# Create the minidom
doc = Document()

# Create the <qgis> base element
qgis = doc.createElement("qgis")
qgis.setAttribute("projectname", " ")
qgis.setAttribute("version", "1.6.0-Capiapo")
doc.appendChild(qgis)

# Create the <title> element
title = doc.createElement("title")
qgis.appendChild(title)

# Assign current document
mxd = arcpy.mapping.MapDocument(r"C:\Projects\Test.mxd")

print 'Converting mxd........'

# Dataframe elements

df = arcpy.mapping.ListDataFrames(mxd)[0]
unit = doc.createTextNode(df.mapUnits)
xmin1 = doc.createTextNode(str(df.extent.XMin))
ymin1 = doc.createTextNode(str(df.extent.YMin))
xmax1 = doc.createTextNode(str(df.extent.XMax))
ymax1 = doc.createTextNode(str(df.extent.YMax))
# srsid = doc.createTextNode
srid1 = doc.createTextNode(str(df.spatialReference.factoryCode))
srid2 = doc.createTextNode(str(df.spatialReference.factoryCode))
epsg1 = doc.createTextNode(str(df.spatialReference.factoryCode))
epsg2 = doc.createTextNode(str(df.spatialReference.factoryCode))
description1 = doc.createTextNode(str(df.spatialReference.name))
description2 = doc.createTextNode(str(df.spatialReference.name))
ellipsoidacronym1 = doc.createTextNode(str(df.spatialReference.name))
ellipsoidacronym2 = doc.createTextNode(str(df.spatialReference.name))
geographicflag1 = doc.createTextNode("true")
geographicflag2 = doc.createTextNode("true")

authid2 = doc.createTextNode("EPSG:"+str(df.spatialReference.factoryCode))
authid3 = doc.createTextNode("EPSG:"+str(df.spatialReference.factoryCode))

# Layerlist elements
lyrlist = arcpy.mapping.ListLayers(df)
count1 = str(len(lyrlist))

# mapcanvas
def map_canvas():
    # Create the <mapcanvas> element
    mapcanvas = doc.createElement("mapcanvas")
    qgis.appendChild(mapcanvas)

    # Create the <units> element
    units = doc.createElement("units")
    units.appendChild(unit)
    mapcanvas.appendChild(units)

    # Create the <extent> element
    extent = doc.createElement("extent")
    mapcanvas.appendChild(extent)

    # Create the <xmin> element
    xmin = doc.createElement("xmin")
    xmin.appendChild(xmin1)
    extent.appendChild(xmin)

    # Create the <ymin> element
    ymin = doc.createElement("ymin")
    ymin.appendChild(ymin1)
    extent.appendChild(ymin)

    # Create the <xmax> element
    xmax = doc.createElement("xmax")
    xmax.appendChild(xmax1)
    extent.appendChild(xmax)

    # Create the <ymax> element
    ymax = doc.createElement("ymax")
    ymax.appendChild(ymax1)
    extent.appendChild(ymax)

    # Create the <projections> element
    projections = doc.createElement("projections")
    mapcanvas.appendChild(projections)

    # Create the <destinationsrs> element
    destinationsrs = doc.createElement("destinationsrs")
    mapcanvas.appendChild(destinationsrs)

    # Create the <spatialrefsys> element
    spatialrefsys = doc.createElement("spatialrefsys")
    destinationsrs.appendChild(spatialrefsys)

    # Create the <proj4> element
    proj4 = doc.createElement("proj4")
    spatialrefsys.appendChild(proj4)

    # Create the <srsid> element
    srsid = doc.createElement("srsid")
    spatialrefsys.appendChild(srsid)

    # Create the <srid> element
    srid = doc.createElement("srid")
    srid.appendChild(srid1)
    spatialrefsys.appendChild(srid)

    # Create the <authid> element
    authid = doc.createElement("authid")
    authid.appendChild(authid2)
    spatialrefsys.appendChild(authid)

    # Create the <description> element
    description = doc.createElement("description")
    description.appendChild(description1)
    spatialrefsys.appendChild(description)

    # Create the <projectionacronym> element
    projectionacronym = doc.createElement("projectionacronym")
    spatialrefsys.appendChild(projectionacronym)

    # Create the <ellipsoidacronym element
    ellipsoidacronym = doc.createElement("ellipsoidacronym")
    ellipsoidacronym.appendChild(ellipsoidacronym1)
    spatialrefsys.appendChild(ellipsoidacronym)

    # Create the <geographicflag> element
    geographicflag = doc.createElement("geographicflag")
    geographicflag.appendChild(geographicflag1)
    spatialrefsys.appendChild(geographicflag)

# Legend
def legend_func():

    # Create the <legend> element
    legend = doc.createElement("legend")
    qgis.appendChild(legend)

    for lyr in lyrlist:
        if(lyr.isGroupLayer == False):

            # Create the <legendlayer> element
            legendlayer = doc.createElement("legendlayer")
            legendlayer.setAttribute("open", "true")
            legendlayer.setAttribute("checked", "Qt::Checked")
            legendlayer.setAttribute("name",str(lyr.name))

            legend.appendChild(legendlayer)

            # Create the <filegroup> element
            filegroup = doc.createElement("filegroup")
            filegroup.setAttribute("open", "true")
            filegroup.setAttribute("hidden", "false")
            legendlayer.appendChild(filegroup)

            # Create the <legendlayerfile> element
            legendlayerfile = doc.createElement("legendlayerfile")
            legendlayerfile.setAttribute("isInOverview", "0")
            legendlayerfile.setAttribute("layerid", str(lyr.name)+str(20110427170816078))
            legendlayerfile.setAttribute("visible", "1")
            filegroup.appendChild(legendlayerfile)

# Project Layers
def project_layers():

    # Create the <projectlayers> element
    projectlayers = doc.createElement("projectlayers")
    projectlayers.setAttribute("layercount", count1)
    qgis.appendChild(projectlayers)

    for lyr in lyrlist:

        if(lyr.isGroupLayer == False and lyr.isRasterLayer == False and lyr.isFeatureLayer == True):
            geometry1 = arcpy.Describe(lyr)
            geometry2 = str(geometry1.shapeType)
            ds = doc.createTextNode(str(lyr.dataSource))

            name1 = doc.createTextNode(str(lyr.name)+str(20110427170816078))
            name2 = doc.createTextNode(str(lyr.name))

           # Create the <maplayer> element
            maplayer = doc.createElement("maplayer")
            maplayer.setAttribute("minimumScale", "0")
            maplayer.setAttribute("maximumScale", "1e+08")
            maplayer.setAttribute("minLabelScale", "0")
            maplayer.setAttribute("maxLabelScale", "1e+08")
            maplayer.setAttribute("geometry", geometry2)
            if(lyr.isRasterLayer == True):
                maplayer.setAttribute("type", "raster")
            else:
                maplayer.setAttribute("type", "vector")
            maplayer.setAttribute("hasScaleBasedVisibilityFlag", "0")
            maplayer.setAttribute("scaleBasedLabelVisibilityFlag", "0")
            projectlayers.appendChild(maplayer)

            # Create the <id> element
            id = doc.createElement("id")
            id.appendChild(name1)
            maplayer.appendChild(id)

            # Create the <datasource> element
            datasource = doc.createElement("datasource")
            datasource.appendChild(ds)
            maplayer.appendChild(datasource)

            # Create the <layername> element
            layername = doc.createElement("layername")
            layername.appendChild(name2)
            maplayer.appendChild(layername)

            # Create the <srs> element
            srs = doc.createElement("srs")
            maplayer.appendChild(srs)

            # Create the <spatialrefsys> element
            spatialrefsys = doc.createElement("spatialrefsys")
            srs.appendChild(spatialrefsys)

            # Create the <proj4> element
            proj4 = doc.createElement("proj4")
            spatialrefsys.appendChild(proj4)

            # Create the <srsid> element
            srsid = doc.createElement("srsid")
            spatialrefsys.appendChild(srsid)

            # Create the <srid> element
            srid = doc.createElement("srid")
            srid.appendChild(srid2)
            spatialrefsys.appendChild(srid)

            # Create the <authid> element
            authid = doc.createElement("authid")
            authid.appendChild(authid3)
            spatialrefsys.appendChild(authid)

            # Create the <description> element
            description = doc.createElement("description")
            description.appendChild(description2)
            spatialrefsys.appendChild(description)

            # Create the <projectionacronym> element
            projectionacronym = doc.createElement("projectionacronym")
            spatialrefsys.appendChild(projectionacronym)

            # Create the <ellipsoidacronym element
            ellipsoidacronym = doc.createElement("ellipsoidacronym")
            ellipsoidacronym.appendChild(ellipsoidacronym2)
            spatialrefsys.appendChild(ellipsoidacronym)

            # Create the <geographicflag> element
            geographicflag = doc.createElement("geographicflag")
            geographicflag.appendChild(geographicflag2)
            spatialrefsys.appendChild(geographicflag)

            # Create the <transparencyLevelInt> element
            transparencyLevelInt = doc.createElement("transparencyLevelInt")
            transparency2 = doc.createTextNode("255")
            transparencyLevelInt.appendChild(transparency2)
            maplayer.appendChild(transparencyLevelInt)

            # Create the <customproperties> element
            customproperties = doc.createElement("customproperties")
            maplayer.appendChild(customproperties)

            # Create the <provider> element
            provider = doc.createElement("provider")
            provider.setAttribute("encoding", "System")
            ogr = doc.createTextNode("ogr")
            provider.appendChild(ogr)
            maplayer.appendChild(provider)

            # Create the <singlesymbol> element
            singlesymbol = doc.createElement("singlesymbol")
            maplayer.appendChild(singlesymbol)

            # Create the <symbol> element
            symbol = doc.createElement("symbol")
            singlesymbol.appendChild(symbol)

            # Create the <lowervalue> element
            lowervalue = doc.createElement("lowervalue")
            symbol.appendChild(lowervalue)

            # Create the <uppervalue> element
            uppervalue = doc.createElement("uppervalue")
            symbol.appendChild(uppervalue)

            # Create the <label> element
            label = doc.createElement("label")
            symbol.appendChild(label)

            # Create the <rotationclassificationfieldname> element
            rotationclassificationfieldname = doc.createElement("rotationclassificationfieldname")
            symbol.appendChild(rotationclassificationfieldname)

            # Create the <scaleclassificationfieldname> element
            scaleclassificationfieldname = doc.createElement("scaleclassificationfieldname")
            symbol.appendChild(scaleclassificationfieldname)

            # Create the <symbolfieldname> element
            symbolfieldname = doc.createElement("symbolfieldname")
            symbol.appendChild(symbolfieldname)

             # Create the <outlinecolor> element
            outlinecolor = doc.createElement("outlinecolor")
            outlinecolor.setAttribute("red", "88")
            outlinecolor.setAttribute("blue", "99")
            outlinecolor.setAttribute("green", "37")
            symbol.appendChild(outlinecolor)

             # Create the <outlinestyle> element
            outlinestyle = doc.createElement("outlinestyle")
            outline = doc.createTextNode("SolidLine")
            outlinestyle.appendChild(outline)
            symbol.appendChild(outlinestyle)

             # Create the <outlinewidth> element
            outlinewidth = doc.createElement("outlinewidth")
            width = doc.createTextNode("0.26")
            outlinewidth.appendChild(width)
            symbol.appendChild(outlinewidth)

             # Create the <fillcolor> element
            fillcolor = doc.createElement("fillcolor")
            fillcolor.setAttribute("red", "90")
            fillcolor.setAttribute("blue", "210")
            fillcolor.setAttribute("green", "229")
            symbol.appendChild(fillcolor)

             # Create the <fillpattern> element
            fillpattern = doc.createElement("fillpattern")
            fill = doc.createTextNode("SolidPattern")
            fillpattern.appendChild(fill)
            symbol.appendChild(fillpattern)

             # Create the <texturepath> element
            texturepath = doc.createElement("texturepath")
            texturepath.setAttribute("null", "1")
            symbol.appendChild(texturepath)

map_canvas()
legend_func()
project_layers()

#  Write to qgis file

try:
    f.write(doc.toprettyxml())

finally:
    f.close()

print 'Done'