mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-10 00:04:23 -04:00
1863 lines
69 KiB
Python
1863 lines
69 KiB
Python
"""
|
|
***************************************************************************
|
|
GdalAlgorithmVectorTest.py
|
|
---------------------
|
|
Date : January 2016
|
|
Copyright : (C) 2016 by Matthias Kuhn
|
|
Email : matthias@opengis.ch
|
|
***************************************************************************
|
|
* *
|
|
* 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__ = "Matthias Kuhn"
|
|
__date__ = "January 2016"
|
|
__copyright__ = "(C) 2016, Matthias Kuhn"
|
|
|
|
import nose2
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
|
|
from qgis.core import (
|
|
QgsProcessingContext,
|
|
QgsProcessingFeedback,
|
|
QgsCoordinateReferenceSystem,
|
|
QgsRectangle,
|
|
)
|
|
|
|
from qgis.testing import QgisTestCase, start_app
|
|
|
|
import AlgorithmsTestBase
|
|
from processing.algs.gdal.ogr2ogr import ogr2ogr
|
|
from processing.algs.gdal.ogrinfo import ogrinfo, ogrinfojson
|
|
from processing.algs.gdal.Buffer import Buffer
|
|
from processing.algs.gdal.Dissolve import Dissolve
|
|
from processing.algs.gdal.OffsetCurve import OffsetCurve
|
|
from processing.algs.gdal.OgrToPostGis import OgrToPostGis
|
|
from processing.algs.gdal.OneSideBuffer import OneSideBuffer
|
|
from processing.algs.gdal.PointsAlongLines import PointsAlongLines
|
|
|
|
testDataPath = os.path.join(os.path.dirname(__file__), "testdata")
|
|
|
|
|
|
class TestGdalVectorAlgorithms(QgisTestCase, AlgorithmsTestBase.AlgorithmsTest):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
start_app()
|
|
from processing.core.Processing import Processing
|
|
|
|
Processing.initialize()
|
|
cls.cleanup_paths = []
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
for path in cls.cleanup_paths:
|
|
shutil.rmtree(path)
|
|
|
|
def definition_file(self):
|
|
return "gdal_algorithm_vector_tests.yaml"
|
|
|
|
def testOgr2Ogr(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
multi_source = os.path.join(testDataPath, "multi_layers.gml")
|
|
alg = ogr2ogr()
|
|
alg.initAlgorithm()
|
|
|
|
with tempfile.TemporaryDirectory() as outdir:
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OUTPUT": outdir + "/check.shp"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-f "ESRI Shapefile" '
|
|
+ outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " polys2",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OUTPUT": outdir + "/check.kml"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-f "LIBKML" ' + outdir + "/check.kml " + source + " polys2",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OUTPUT": outdir + "/my out/check.kml"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-f "LIBKML" "'
|
|
+ outdir
|
|
+ '/my out/check.kml" '
|
|
+ source
|
|
+ " polys2",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OUTPUT": outdir + "/check.gpkg"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-f "GPKG" ' + outdir + "/check.gpkg " + source + " polys2",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": multi_source + "|layername=lines",
|
|
"CONVERT_ALL_LAYERS": False,
|
|
"OUTPUT": outdir + "/check.gpkg",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-f "GPKG" ' + outdir + "/check.gpkg " + multi_source + " lines",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": multi_source + "|layername=lines",
|
|
"CONVERT_ALL_LAYERS": True,
|
|
"OUTPUT": outdir + "/check.gpkg",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogr2ogr", '-f "GPKG" ' + outdir + "/check.gpkg " + multi_source],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"CONVERT_ALL_LAYERS": True,
|
|
"OUTPUT": outdir + "/check.gpkg",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-f "GPKG" -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y '
|
|
+ outdir
|
|
+ "/check.gpkg "
|
|
+ source,
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"CONVERT_ALL_LAYERS": True,
|
|
"OUTPUT": outdir + "/check.gpkg",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-f "GPKG" --config X Y --config Z A '
|
|
+ outdir
|
|
+ "/check.gpkg "
|
|
+ source,
|
|
],
|
|
)
|
|
|
|
def testOgrInfo(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
alg = ogrinfo()
|
|
alg.initAlgorithm()
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SUMMARY_ONLY": True, "NO_METADATA": False},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", "-al -so " + source + " polys2"],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"ALL_LAYERS": True,
|
|
"SUMMARY_ONLY": True,
|
|
"NO_METADATA": False,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", "-al -so " + source],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"ALL_LAYERS": True,
|
|
"SUMMARY_ONLY": True,
|
|
"EXTRA": "-nocount",
|
|
"NO_METADATA": False,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", "-al -so -nocount " + source],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SUMMARY_ONLY": True, "NO_METADATA": False},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", '-al -so "' + source + '" filename_with_spaces'],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SUMMARY_ONLY": False, "NO_METADATA": False},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", '-al "' + source + '" filename_with_spaces'],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SUMMARY_ONLY": True, "NO_METADATA": True},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", '-al -so -nomd "' + source + '" filename_with_spaces'],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"SUMMARY_ONLY": True,
|
|
"NO_METADATA": True,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogrinfo",
|
|
'-al -so -nomd "'
|
|
+ source
|
|
+ '" filename_with_spaces -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y',
|
|
],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"SUMMARY_ONLY": True,
|
|
"NO_METADATA": True,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogrinfo",
|
|
'-al -so -nomd "'
|
|
+ source
|
|
+ '" filename_with_spaces --config X Y --config Z A',
|
|
],
|
|
)
|
|
|
|
def testOgrInfoJson(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
alg = ogrinfojson()
|
|
alg.initAlgorithm()
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "FEATURES": True, "NO_METADATA": False},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", "-json -features " + source + " polys2"],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"ALL_LAYERS": True,
|
|
"FEATURES": True,
|
|
"NO_METADATA": False,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", "-json -features " + source],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"ALL_LAYERS": True,
|
|
"FEATURES": True,
|
|
"EXTRA": "-nocount",
|
|
"NO_METADATA": False,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", "-json -features -nocount " + source],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "FEATURES": True, "NO_METADATA": False},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", '-json -features "' + source + '" filename_with_spaces'],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "FEATURES": False, "NO_METADATA": False},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", '-json "' + source + '" filename_with_spaces'],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "FEATURES": True, "NO_METADATA": True},
|
|
context,
|
|
feedback,
|
|
),
|
|
["ogrinfo", '-json -features -nomd "' + source + '" filename_with_spaces'],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"FEATURES": True,
|
|
"NO_METADATA": True,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogrinfo",
|
|
'-json -features -nomd "'
|
|
+ source
|
|
+ '" filename_with_spaces -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y',
|
|
],
|
|
)
|
|
|
|
source = os.path.join(testDataPath, "filename with spaces.gml")
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"FEATURES": True,
|
|
"NO_METADATA": True,
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogrinfo",
|
|
'-json -features -nomd "'
|
|
+ source
|
|
+ '" filename_with_spaces --config X Y --config Z A',
|
|
],
|
|
)
|
|
|
|
def testBuffer(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
source_with_space = os.path.join(testDataPath, "filename with spaces.gml")
|
|
alg = Buffer()
|
|
alg.initAlgorithm()
|
|
|
|
with tempfile.TemporaryDirectory() as outdir:
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "DISTANCE": 5, "OUTPUT": outdir + "/check.shp"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Buffer(geometry, 5.0) AS geometry,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "DISTANCE": -5, "OUTPUT": outdir + "/check.shp"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Buffer(geometry, -5.0) AS geometry,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"DISTANCE": 5,
|
|
"DISSOLVE": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Union(ST_Buffer(geometry, 5.0)) AS geometry,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"DISTANCE": 1,
|
|
"DISSOLVE": True,
|
|
"EXPLODE_COLLECTIONS": False,
|
|
"GEOMETRY": "geom",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Union(ST_Buffer(geom, 1.0)) AS geom,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"DISTANCE": 5,
|
|
"EXPLODE_COLLECTIONS": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Buffer(geometry, 5.0) AS geometry,* FROM """polys2"""" '
|
|
+ '-explodecollections -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"DISTANCE": 5,
|
|
"FIELD": "total population",
|
|
"EXPLODE_COLLECTIONS": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Union(ST_Buffer(geometry, 5.0)) AS geometry,* FROM """polys2""" GROUP BY """total population"""" '
|
|
+ '-explodecollections -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"DISTANCE": 5,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Buffer(geometry, 5.0) AS geometry,* FROM """polys2"""" '
|
|
+ '-oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"DISTANCE": 5,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Buffer(geometry, 5.0) AS geometry,* FROM """polys2"""" '
|
|
+ '--config X Y --config Z A -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
def testDissolve(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
source_with_space = os.path.join(testDataPath, "filename with spaces.gml")
|
|
alg = Dissolve()
|
|
alg.initAlgorithm()
|
|
|
|
with tempfile.TemporaryDirectory() as outdir:
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OUTPUT": outdir + "/check.shp"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "total population",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """total population""" FROM """polys2""" '
|
|
+ 'GROUP BY """total population"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source_with_space,
|
|
"FIELD": "my_field",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ '"'
|
|
+ source_with_space
|
|
+ '" '
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """filename_with_spaces""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"GEOMETRY": "the_geom",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(the_geom) AS the_geom, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"KEEP_ATTRIBUTES": False,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"KEEP_ATTRIBUTES": False,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"EXPLODE_COLLECTIONS": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -explodecollections -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"COUNT_FEATURES": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""", COUNT(geometry) AS count FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"COUNT_FEATURES": True,
|
|
"GEOMETRY": "the_geom",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(the_geom) AS the_geom, """my_field""", COUNT(the_geom) AS count FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"COMPUTE_AREA": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""", SUM(ST_Area(geometry)) AS area, '
|
|
+ 'ST_Perimeter(ST_Union(geometry)) AS perimeter FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"COMPUTE_AREA": True,
|
|
"GEOMETRY": "the_geom",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(the_geom) AS the_geom, """my_field""", SUM(ST_Area(the_geom)) AS area, '
|
|
+ 'ST_Perimeter(ST_Union(the_geom)) AS perimeter FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"COMPUTE_STATISTICS": True,
|
|
"STATISTICS_ATTRIBUTE": "my_val",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""", '
|
|
+ 'SUM("""my_val""") AS sum, MIN("""my_val""") AS min, MAX("""my_val""") AS max, AVG("""my_val""") AS avg FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "test field",
|
|
"COMPUTE_STATISTICS": True,
|
|
"STATISTICS_ATTRIBUTE": "total population",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """test field""", '
|
|
+ 'SUM("""total population""") AS sum, MIN("""total population""") AS min, MAX("""total population""") AS max, '
|
|
+ 'AVG("""total population""") AS avg FROM """polys2""" '
|
|
+ 'GROUP BY """test field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
# compute stats without stats attribute, and vice versa (should be ignored)
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"COMPUTE_STATISTICS": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"STATISTICS_ATTRIBUTE": "my_val",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"FIELD": "my_field",
|
|
"OPTIONS": "my opts",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" "my opts" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"FIELD": "my_field",
|
|
"OPTIONS": "my opts",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y "my opts" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"FIELD": "my_field",
|
|
"OPTIONS": "my opts",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-nlt PROMOTE_TO_MULTI -dialect sqlite -sql "SELECT ST_Union(geometry) AS geometry, """my_field""" FROM """polys2""" '
|
|
+ 'GROUP BY """my_field"""" --config X Y --config Z A "my opts" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
def testOgr2PostGis(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
source_line = os.path.join(testDataPath, "multilines.gml")
|
|
source_with_space = os.path.join(testDataPath, "filename with spaces.gml")
|
|
alg = OgrToPostGis()
|
|
alg.initAlgorithm()
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source_with_space}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
'-lco DIM=2 "' + source_with_space + '" filename_with_spaces '
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.filename_with_spaces -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "HOST": "google.com"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=google.com port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source, "PORT": 3333}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=3333 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "USER": "kevin_bacon"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public user=kevin_bacon" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "DBNAME": "secret_stuff"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 dbname=secret_stuff active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "PASSWORD": "passw0rd"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 password=passw0rd active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SCHEMA": "desktop"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=desktop" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln desktop.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "TABLE": "out_table"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.out_table -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source, "PK": ""}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "PK": "new_fid"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=new_fid -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "PK": "", "PRIMARY_KEY": "objectid"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=objectid -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "PK": "new_id", "PRIMARY_KEY": "objectid"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=new_id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "GEOCOLUMN": "my_geom"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=my_geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source, "DIM": 1}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=3 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source, "SIMPLIFY": 5}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -simplify 5 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SEGMENTIZE": 4}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -segmentize 4 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SPAT": QgsRectangle(1, 2, 3, 4)}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -spat 1.0 2.0 3.0 4.0 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "FIELDS": ["f1", "f2"]}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + ' polys2 -select "f1,f2" '
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "WHERE": "0=1"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
'-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -where "0=1" -nlt PROMOTE_TO_MULTI',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source, "GT": 2}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -gt 2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OVERWRITE": False}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OVERWRITE": False, "APPEND": True}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-append -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "ADDFIELDS": True}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-addfields -overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "LAUNDER": True}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-lco LAUNDER=NO -overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands({"INPUT": source, "INDEX": True}, context, feedback),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-lco SPATIAL_INDEX=OFF -overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SKIPFAILURES": True}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -skipfailures -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "PROMOTETOMULTI": False}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "PRECISION": False}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI -lco PRECISION=NO",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "OPTIONS": "blah"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI blah",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "SHAPE_ENCODING": "blah"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES --config SHAPE_ENCODING blah -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "PROMOTETOMULTI": False, "GTYPE": 4},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -nlt LINESTRING -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source_line, "GTYPE": 15}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source_line + " multilines "
|
|
"-overwrite -nlt CONVERT_TO_LINEAR -lco GEOMETRY_NAME=geom -lco FID=id -nln public.multilines -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "A_SRS": "EPSG:3111"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -a_srs EPSG:3111 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "A_SRS": QgsCoordinateReferenceSystem("EPSG:3111")},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -a_srs EPSG:3111 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
custom_crs = "proj4: +proj=utm +zone=36 +south +a=6378249.145 +b=6356514.966398753 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs"
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "A_SRS": custom_crs}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -a_srs EPSG:20936 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "T_SRS": "EPSG:3111"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -t_srs EPSG:3111 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "T_SRS": QgsCoordinateReferenceSystem("EPSG:3111")},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -t_srs EPSG:3111 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
custom_crs = "proj4: +proj=utm +zone=36 +south +a=6378249.145 +b=6356514.966398753 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs"
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "T_SRS": custom_crs}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -t_srs EPSG:20936 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "S_SRS": "EPSG:3111"}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -s_srs EPSG:3111 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "S_SRS": QgsCoordinateReferenceSystem("EPSG:3111")},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -s_srs EPSG:3111 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
custom_crs = "proj4: +proj=utm +zone=36 +south +a=6378249.145 +b=6356514.966398753 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs"
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "S_SRS": custom_crs}, context, feedback
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -s_srs EPSG:20936 -nlt PROMOTE_TO_MULTI",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"A_SRS": QgsCoordinateReferenceSystem("EPSG:3111"),
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -a_srs EPSG:3111 -nlt PROMOTE_TO_MULTI -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y",
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"A_SRS": QgsCoordinateReferenceSystem("EPSG:3111"),
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
'-progress --config PG_USE_COPY YES -f PostgreSQL "PG:host=localhost port=5432 active_schema=public" '
|
|
"-lco DIM=2 " + source + " polys2 "
|
|
"-overwrite -lco GEOMETRY_NAME=geom -lco FID=id -nln public.polys2 -a_srs EPSG:3111 -nlt PROMOTE_TO_MULTI --config X Y --config Z A",
|
|
],
|
|
)
|
|
|
|
def testOffsetCurve(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
source_with_space = os.path.join(testDataPath, "filename with spaces.gml")
|
|
alg = OffsetCurve()
|
|
alg.initAlgorithm()
|
|
|
|
with tempfile.TemporaryDirectory() as outdir:
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "DISTANCE": 5, "OUTPUT": outdir + "/check.shp"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_OffsetCurve(geometry, 5.0) AS geometry,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"DISTANCE": 5,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_OffsetCurve(geometry, 5.0) AS geometry,* FROM """polys2"""" -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"DISTANCE": 5,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_OffsetCurve(geometry, 5.0) AS geometry,* FROM """polys2"""" --config X Y --config Z A '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
def testOneSidedBuffer(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
source_with_space = os.path.join(testDataPath, "filename with spaces.gml")
|
|
alg = OneSideBuffer()
|
|
alg.initAlgorithm()
|
|
|
|
with tempfile.TemporaryDirectory() as outdir:
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "DISTANCE": 5, "OUTPUT": outdir + "/check.shp"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_SingleSidedBuffer(geometry, 5.0, 0) AS geometry,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"DISTANCE": 5,
|
|
"DISSOLVE": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Union(ST_SingleSidedBuffer(geometry, 5.0, 0)) AS geometry,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"DISTANCE": 5,
|
|
"EXPLODE_COLLECTIONS": True,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_SingleSidedBuffer(geometry, 5.0, 0) AS geometry,* FROM """polys2"""" '
|
|
+ '-explodecollections -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source,
|
|
"DISTANCE": 5,
|
|
"FIELD": "total population",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Union(ST_SingleSidedBuffer(geometry, 5.0, 0)) AS geometry,* '
|
|
+ 'FROM """polys2""" GROUP BY """total population"""" -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"DISTANCE": 5,
|
|
"FIELD": "total population",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Union(ST_SingleSidedBuffer(geometry, 5.0, 0)) AS geometry,* '
|
|
+ 'FROM """polys2""" GROUP BY """total population"""" -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"DISTANCE": 5,
|
|
"FIELD": "total population",
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Union(ST_SingleSidedBuffer(geometry, 5.0, 0)) AS geometry,* '
|
|
+ 'FROM """polys2""" GROUP BY """total population"""" --config X Y --config Z A -f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
def testPointsAlongLines(self):
|
|
context = QgsProcessingContext()
|
|
feedback = QgsProcessingFeedback()
|
|
source = os.path.join(testDataPath, "polys.gml")
|
|
source_with_space = os.path.join(testDataPath, "filename with spaces.gml")
|
|
alg = PointsAlongLines()
|
|
alg.initAlgorithm()
|
|
|
|
with tempfile.TemporaryDirectory() as outdir:
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{"INPUT": source, "DISTANCE": 0.2, "OUTPUT": outdir + "/check.shp"},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Line_Interpolate_Point(geometry, 0.2) AS geometry,* FROM """polys2"""" '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source
|
|
+ "|option:X_POSSIBLE_NAMES=geom_x|option:Y_POSSIBLE_NAMES=geom_y",
|
|
"DISTANCE": 0.2,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Line_Interpolate_Point(geometry, 0.2) AS geometry,* FROM """polys2"""" -oo X_POSSIBLE_NAMES=geom_x -oo Y_POSSIBLE_NAMES=geom_y '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
alg.getConsoleCommands(
|
|
{
|
|
"INPUT": source + "|credential:X=Y|credential:Z=A",
|
|
"DISTANCE": 0.2,
|
|
"OUTPUT": outdir + "/check.shp",
|
|
},
|
|
context,
|
|
feedback,
|
|
),
|
|
[
|
|
"ogr2ogr",
|
|
outdir
|
|
+ "/check.shp "
|
|
+ source
|
|
+ " "
|
|
+ '-dialect sqlite -sql "SELECT ST_Line_Interpolate_Point(geometry, 0.2) AS geometry,* FROM """polys2"""" --config X Y --config Z A '
|
|
+ '-f "ESRI Shapefile"',
|
|
],
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
nose2.main()
|