mirror of
https://github.com/qgis/QGIS.git
synced 2025-03-06 00:05:02 -05:00
268 lines
10 KiB
Python
268 lines
10 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
***************************************************************************
|
|
__init__.py
|
|
---------------------
|
|
Date : May 2015
|
|
Copyright : (C) 2015 by Luigi Pirelli
|
|
Email : luipir at gmail dot com
|
|
***************************************************************************
|
|
* *
|
|
* 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. *
|
|
* *
|
|
***************************************************************************
|
|
"""
|
|
|
|
__author__ = 'Luigi Pirelli'
|
|
__date__ = 'May 2015'
|
|
__copyright__ = '(C) 2015, Luigi Pirelli'
|
|
|
|
# This will get replaced with a git SHA1 when you do a git archive
|
|
|
|
__revision__ = '$Format:%H$'
|
|
|
|
import os
|
|
|
|
from processing.core.GeoAlgorithm import GeoAlgorithm
|
|
from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
|
|
from processing.core.parameters import ParameterMultipleInput, ParameterBoolean
|
|
from processing.core.outputs import OutputFile, OutputString
|
|
|
|
# algorithm specific imports
|
|
from osgeo import ogr, gdal
|
|
from string import Template
|
|
import tempfile
|
|
import logging
|
|
import os
|
|
import xml.sax.saxutils
|
|
|
|
|
|
class Datasources2Vrt(GeoAlgorithm):
|
|
|
|
""" This algorithm merge the layers of different data sources in
|
|
a single vrt file
|
|
|
|
This algo is especially useful in case an algo need multiple layers
|
|
but accept only one vrt in which the layers are specified
|
|
"""
|
|
|
|
# Constants used to refer to parameters and outputs.
|
|
OUTPUT_VRT_FILE = 'OUTPUT_VRT_FILE'
|
|
OUTPUT_VRT_STRING = 'OUTPUT_VRT_STRING'
|
|
INPUT_DATASOURCES = 'INPUT_DATASOURCES'
|
|
INPUT_OVERWRITE_FLAG = 'INPUT_OVERWRITE_FLAG'
|
|
|
|
def defineCharacteristics(self):
|
|
"""Here we define the inputs and output of the algorithm, along
|
|
with some other properties.
|
|
"""
|
|
|
|
# The name that the user will see in the toolbox
|
|
self.name, self.i18n_name = self.trAlgorithm('Build virtual vector')
|
|
|
|
# The branch of the toolbox under which the algorithm will appear
|
|
self.group, self.i18n_group = self.trAlgorithm('Vector general tools')
|
|
|
|
# We add the inputs
|
|
self.addParameter(ParameterMultipleInput(name=self.INPUT_DATASOURCES,
|
|
description=self.tr('Input datasources'),
|
|
datatype=ParameterMultipleInput.TYPE_VECTOR_ANY,
|
|
optional=False))
|
|
|
|
self.addParameter(ParameterBoolean(name=self.INPUT_OVERWRITE_FLAG,
|
|
description=self.tr('Overwrite output vrt'),
|
|
default=False))
|
|
|
|
# We add outputs
|
|
self.addOutput(OutputFile(self.OUTPUT_VRT_FILE,
|
|
self.tr('Virtual vector')))
|
|
self.addOutput(OutputString(self.OUTPUT_VRT_STRING,
|
|
self.tr('Virtual string')))
|
|
|
|
def processAlgorithm(self, progress):
|
|
"""Here is where the processing itself takes place."""
|
|
|
|
# The first thing to do is retrieve the values of the parameters
|
|
# entered by the user
|
|
input_layers = self.getParameterValue(self.INPUT_DATASOURCES)
|
|
overwrite = self.getParameterValue(self.INPUT_OVERWRITE_FLAG)
|
|
outVrtPath = self.getOutputValue(self.OUTPUT_VRT_FILE)
|
|
outVrtString = self.getOutputValue(self.OUTPUT_VRT_STRING)
|
|
|
|
# split list of input data sources to have a python list
|
|
# inputDataSources is a string with path separated by ";"
|
|
ds = input_layers.split(";")
|
|
if not isinstance(ds, list):
|
|
msg = "Input datasources would be a ';' separated list of path strings"
|
|
raise GeoAlgorithmExecutionException(msg)
|
|
|
|
# check empty list
|
|
if not ds:
|
|
msg = "Input data sources is empty"
|
|
raise GeoAlgorithmExecutionException(msg)
|
|
|
|
# check if outVrt exist
|
|
if not overwrite and os.path.exists(outVrtPath):
|
|
msg = "Output vrt: %s already exist and choosed to avoid overwrite it" % outVrtPath
|
|
raise GeoAlgorithmExecutionException(msg)
|
|
|
|
# now process
|
|
outVrtString = mergeDataSources2Vrt(data_sources=ds,
|
|
outfile=outVrtPath,
|
|
relative=False,
|
|
schema=False,
|
|
progress=progress)
|
|
|
|
# setting out values
|
|
self.setOutputValue(self.OUTPUT_VRT_STRING, outVrtString)
|
|
|
|
#######################################################
|
|
# function to do the work
|
|
# function so it can be included in other code
|
|
# IT NOT POSSIBILE TO ADD THIS FUNCTION AS Datasources2Vrt
|
|
# CLASS METHOD => SET AS SIMPLE FUNCTION
|
|
#######################################################
|
|
|
|
|
|
def mergeDataSources2Vrt(data_sources=[],
|
|
outfile=None,
|
|
relative=False,
|
|
schema=False,
|
|
progress=None): # progress is passed because of avoid interferences with GeoAlgorithm
|
|
'''Function to do the work of merging datasources in a single vrt format
|
|
|
|
@param data_sources: Array of path strings
|
|
@param outfile: the output vrt file to generate
|
|
@param relative: Write relative flag. DOES NOT relativise paths. They have to be already relative
|
|
@param schema: Schema flag
|
|
@return: vrt in string format
|
|
'''
|
|
if not data_sources or len(data_sources) == 0:
|
|
return None
|
|
|
|
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
# Start the VRT file.
|
|
|
|
vrt = '<OGRVRTDataSource>\n'
|
|
|
|
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
# for each file Open the datasource to read.
|
|
for i, infile in enumerate(data_sources):
|
|
progress.setPercentage(int(100 * i / len(data_sources)))
|
|
|
|
src_ds = ogr.Open(infile, update=0)
|
|
|
|
if src_ds is None:
|
|
msg = "Invalid datasource: %s" % infile
|
|
raise GeoAlgorithmExecutionException(msg)
|
|
|
|
if schema:
|
|
infile = '@dummy@'
|
|
|
|
layer_list = []
|
|
for layer in src_ds:
|
|
layer_list.append(layer.GetLayerDefn().GetName())
|
|
|
|
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
# Process each source layer.
|
|
for name in layer_list:
|
|
layer = src_ds.GetLayerByName(name)
|
|
layerdef = layer.GetLayerDefn()
|
|
|
|
vrt += ' <OGRVRTLayer name="%s">\n' % XmlEsc(name)
|
|
vrt += ' <SrcDataSource relativeToVRT="%s" shared="%d">%s</SrcDataSource>\n' \
|
|
% ('1' if relative else '0', not schema, XmlEsc(infile))
|
|
if schema:
|
|
vrt += ' <SrcLayer>@dummy@</SrcLayer>\n'
|
|
else:
|
|
vrt += ' <SrcLayer>%s</SrcLayer>\n' % XmlEsc(name)
|
|
vrt += ' <GeometryType>%s</GeometryType>\n' \
|
|
% GeomType2Name(layerdef.GetGeomType())
|
|
srs = layer.GetSpatialRef()
|
|
if srs is not None:
|
|
vrt += ' <LayerSRS>%s</LayerSRS>\n' \
|
|
% (XmlEsc(srs.ExportToWkt()))
|
|
|
|
# Process all the fields.
|
|
for fld_index in range(layerdef.GetFieldCount()):
|
|
src_fd = layerdef.GetFieldDefn(fld_index)
|
|
if src_fd.GetType() == ogr.OFTInteger:
|
|
type = 'Integer'
|
|
elif src_fd.GetType() == ogr.OFTString:
|
|
type = 'String'
|
|
elif src_fd.GetType() == ogr.OFTReal:
|
|
type = 'Real'
|
|
elif src_fd.GetType() == ogr.OFTStringList:
|
|
type = 'StringList'
|
|
elif src_fd.GetType() == ogr.OFTIntegerList:
|
|
type = 'IntegerList'
|
|
elif src_fd.GetType() == ogr.OFTRealList:
|
|
type = 'RealList'
|
|
elif src_fd.GetType() == ogr.OFTBinary:
|
|
type = 'Binary'
|
|
elif src_fd.GetType() == ogr.OFTDate:
|
|
type = 'Date'
|
|
elif src_fd.GetType() == ogr.OFTTime:
|
|
type = 'Time'
|
|
elif src_fd.GetType() == ogr.OFTDateTime:
|
|
type = 'DateTime'
|
|
else:
|
|
type = 'String'
|
|
|
|
vrt += ' <Field name="%s" type="%s"' \
|
|
% (XmlEsc(src_fd.GetName()), type)
|
|
if not schema:
|
|
vrt += ' src="%s"' % XmlEsc(src_fd.GetName())
|
|
if src_fd.GetWidth() > 0:
|
|
vrt += ' width="%d"' % src_fd.GetWidth()
|
|
if src_fd.GetPrecision() > 0:
|
|
vrt += ' precision="%d"' % src_fd.GetPrecision()
|
|
vrt += '/>\n'
|
|
|
|
vrt += ' </OGRVRTLayer>\n'
|
|
|
|
# close data source
|
|
src_ds.Destroy()
|
|
|
|
vrt += '</OGRVRTDataSource>\n'
|
|
|
|
if outfile is not None:
|
|
f = open(outfile, "w")
|
|
f.write(vrt)
|
|
f.close()
|
|
|
|
return vrt
|
|
|
|
|
|
def GeomType2Name(type):
|
|
if type == ogr.wkbUnknown:
|
|
return 'wkbUnknown'
|
|
elif type == ogr.wkbPoint:
|
|
return 'wkbPoint'
|
|
elif type == ogr.wkbLineString:
|
|
return 'wkbLineString'
|
|
elif type == ogr.wkbPolygon:
|
|
return 'wkbPolygon'
|
|
elif type == ogr.wkbMultiPoint:
|
|
return 'wkbMultiPoint'
|
|
elif type == ogr.wkbMultiLineString:
|
|
return 'wkbMultiLineString'
|
|
elif type == ogr.wkbMultiPolygon:
|
|
return 'wkbMultiPolygon'
|
|
elif type == ogr.wkbGeometryCollection:
|
|
return 'wkbGeometryCollection'
|
|
elif type == ogr.wkbNone:
|
|
return 'wkbNone'
|
|
elif type == ogr.wkbLinearRing:
|
|
return 'wkbLinearRing'
|
|
else:
|
|
return 'wkbUnknown'
|
|
|
|
|
|
def XmlEsc(x):
|
|
return xml.sax.saxutils.escape(x)
|