Conversión de Archivos KML a Shapefile mediante procesamiento en Python y R

En este tutorial explicare el proceso de importar archivos KML a shapefile mediante dos códigos, el primero escrito en el lenguaje de programación Python, y el segundo en el lenguaje R; en el primer proceso se exportan cada archivo Kml a una geodatabase, y luego en R importamos los archivos de la geodatadase y los exportamos como un archivo shapefile. Para llevar a cabo el presente tutorial es necesario tener instalado cualquier versión de ArcMAP superior a 10, y RStudio versión 3 o superior.

La ventaja que nos brinda hacer el proceso mediante línea de código es que si tenemos, por ejemplo, 100 archivos KML no sería necesario hacer el proceso 100 veces con la función ‘Import KML to Layer’ de ArcGIS, sino de una manera mucho más eficiente con un ciclo en ambos lenguajes de programación.

Los archivos para realizar el presente tutorial están disponibles en este enlace web. Estos archivos corresponden a polígonos dibujados aleatoriamente en Google Earth, no corresponden a ningún tipo de cobertura, uso de la tierra, o elemento geográfico; fueron realizados en Google Earth solamente para fines de hacer este tutorial.

Aquí los pasos a seguir:

Sección Python

1. En un compilador de texto, escribimos las siguientes líneas de código, el compilador que yo utilizare será notepad (clic aquí para descargar). Las primeras líneas son las siguientes:

import arcpy, os
arcpy.env.workspace = r'path\_kmz'
outLocation = r'path\_gdb'
MasterGDB = 'AllKMLLayers.gdb'
MasterGDBLocation = os.path.join(outLocation, MasterGDB)

En la segunda línea indicamos cuál será nuestro espacio de trabajo, en este espacio de trabajo es donde se encuentra el listado de archivos KMZ. En la tercer linea va la ruta donde quedaran guardadas las geodatabases. Y por último, en la cuarta línea escribimos el nombre de cómo queremos que llame la geodatabase donde guardaremos los layers.

2.      Ahora escribiremos estas líneas, aquí lo que haremos es hacer un for para leer los archivos .KM que contiene la carpeta de nuestro espacio de trabajo, y establecemos el ambiente de trabajo donde se encontraran nuestros archivos de salida.

print 'Master'

for kmz in arcpy.ListFiles('*.KM*'):
  print ("CONVERTING: {0}".format(os.path.join(arcpy.env.workspace, kmz)))
  arcpy.KMLToLayer_conversion(kmz, outLocation)

arcpy.env.workspace = outLocation
wks = arcpy.ListWorkspaces('*', 'FileGDB')
wks.remove(MasterGDBLocation)

1.   3.   El siguiente paso será escribir el último grupo de líneas, en donde se ejecuta la conversión de los archivos kmz a geodatabase mediante un for, este permite iterar en caso dado que se tengan muchos archivos a convertir

for fdgb in wks:

 arcpy.env.workspace = fdgb
 featureClasses = arcpy.ListFeatureClasses('*', '', 'Placemarks')
 
 for fc in featureClasses:
  print ("COPYING: {0} FROM: {1}".format(fc, fgdb))    
  fcCopy = os.path.join(fgdb, 'Placemarks', fc)
  arcpy.FeatureClassToFeatureClass_conversion(fcCopy, MasterGDBLocation, fgdb[fgdb.rfind(os.sep)+1:-4])
  

# Clean up
del kmz, wks, fc, featureClasses, fgdb

Estas líneas de código fueron escritas a partir de la ayuda que ofrece ArcMap (sí desea visitar la página web aquí el enlace).

Sección R

Ahora pasaremos a abrir RStudio y escribiremos las siguientes líneas.

1.   1. El primer pasos será escribir, de igual manera como en Python, la carpeta de trabajo en donde se encuentran las geodatabases creadas mediante el punto anterior. Antes de ello es importante cargar las librerías a utilizar, en caso dado que usted no tenga las librerías las puede instalar mediante el comando install.packages (‘nameLibrary’).

require(raster)
require(rgdal)
require(plotKML)
require(maptools)
require(XML)

files <- list.files('_data/_gdb', full.names = T, pattern = '.gdb')
list  <- lapply(files, FUN = ogrListLayers)

En la línea del lapply aplicamos la función ogrListLayers a las geodatabases, esto con la finalidad de conocer cuál es el nombre de cada shapefile dentro de la geodatabase.

2. Luego creamos un objetos tipo lista que es donde guardaremos los archivos con los shapefiles

poly  <- list()

1.  
      3. Seguido de ello pasamos a escribir un ciclo for, mediante el cuál leemos los archivos shapefiles dentro de la geodatabase, y escribimos estos archivos en una carpeta distinta a la que contiene las geodatabases. Dentro del for hay un condicional, este sirve para conocer si el archivo que vamos a escribir ya existe dentro de nuestro espacio de trabajo, en caso dado que ya exista el archivo no lo escribe de nuevo. 

for(i in 1:length(files)){
  
  poly[[i]] <- readOGR(dsn = files[[i]], layer = as.character(list[[i]][1]))
  
  if(!file.exists(paste0('/_data/_shp/', gsub(' ', '', as.character(poly[[i]]@data[1,1])), '.shp'))){
    
    writeOGR(obj = poly[[i]], dsn = '_data/_shp', layer = gsub(' ', '', as.character(poly[[i]]@data[1,1])), driver = 'ESRI Shapefile')
    print('Written Shapefiles')
    
  } 
  
}

Los códigos los puedes encontrar, además, en mi cuenta de Github, disponible en este enlace.