def testInvalidGeometries(self):
""" Test what happens when SQL Server is a POS and throws an exception on encountering an invalid geometry """
vl = QgsVectorLayer(
'%s srid=4167 type=POLYGON table="qgis_test"."invalid_polys" (ogr_geometry) sql='
% (self.dbconn), "testinvalid", "mssql")
self.assertTrue(vl.isValid())
self.assertEqual(
vl.dataProvider().extent().toString(1),
QgsRectangle(173.953, -41.513, 173.967, -41.502).toString(1))
#burn through features - don't want SQL server to trip up on the invalid ones
count = 0
for f in vl.dataProvider().getFeatures():
count += 1
self.assertEqual(count, 39)
count = 0
for f in vl.dataProvider().getFeatures(
QgsFeatureRequest(QgsRectangle(173, -42, 174, -41))):
count += 1
# two invalid geometry features
self.assertEqual(count, 37)
# sorry... you get NO chance to see these features exist and repair them... because SQL server. Use PostGIS instead and live a happier life!
# with estimated metadata
vl = QgsVectorLayer(
'%s srid=4167 type=POLYGON estimatedmetadata=true table="qgis_test"."invalid_polys" (ogr_geometry) sql='
% (self.dbconn), "testinvalid", "mssql")
self.assertTrue(vl.isValid())
self.assertEqual(
vl.dataProvider().extent().toString(1),
QgsRectangle(173.954, -41.513, 173.967, -41.502).toString(1))
# Now, play on the edge! Let's disable invalid geometry handling and watch things crash and burn
vl = QgsVectorLayer(
'%s srid=4167 type=POLYGON table="qgis_test"."invalid_polys" (ogr_geometry) disableInvalidGeometryHandling="1" sql='
% (self.dbconn), "testinvalid", "mssql")
self.assertTrue(vl.isValid())
self.assertEqual(vl.dataProvider().extent().toString(1),
'Empty') # HAHA - you asked for it
#burn through features - don't expect anything wrong here yet
count = 0
for f in vl.dataProvider().getFeatures():
count += 1
self.assertEqual(count, 39)
count = 0
for f in vl.dataProvider().getFeatures(
QgsFeatureRequest(QgsRectangle(173, -42, 174, -41))):
count += 1
# now you only get 1 feature *sad trumpet*
self.assertEqual(count, 1)
count = 0
# same, with estimated metadata
vl = QgsVectorLayer(
'%s srid=4167 type=POLYGON estimatedmetadata=true table="qgis_test"."invalid_polys" (ogr_geometry) disableInvalidGeometryHandling="1" sql='
% (self.dbconn), "testinvalid", "mssql")
self.assertTrue(vl.isValid())
self.assertEqual(vl.dataProvider().extent().toString(1), 'Empty')
def searchRect(p):
return QgsRectangle(p.x() - proximity, p.y() - proximity, p.x() + proximity, p.y() + proximity)
def testCalculations(self):
rect = QgsRectangle(0.0, 1.0, 20.0, 10.0)
self.assertEqual(rect.area(), 180.0)
self.assertEqual(rect.perimeter(), 58.0)
def testConvertToMapUnits(self):
ms = QgsMapSettings()
ms.setExtent(QgsRectangle(0, 0, 100, 100))
ms.setOutputSize(QSize(100, 50))
ms.setOutputDpi(300)
r = QgsRenderContext.fromMapSettings(ms)
# renderer scale should be about 1:291937841
# start with no min/max scale
c = QgsMapUnitScale()
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMapUnits, c)
self.assertEqual(size, 2.0)
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMillimeters, c)
self.assertAlmostEqual(size, 47.244094, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderPoints, c)
self.assertAlmostEqual(size, 47.2440833, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderInches, c)
self.assertAlmostEqual(size, 3401.574, places=5)
size = r.convertToMapUnits(2, QgsUnitTypes.RenderPixels, c)
self.assertAlmostEqual(size, 4.0, places=5)
# minimum size greater than the calculated size, so size should be limited to minSizeMM
c.minSizeMM = 5
c.minSizeMMEnabled = True
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMapUnits, c)
self.assertAlmostEqual(size, 118.1102362, places=5)
# only conversion from mapunits should be affected
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMillimeters, c)
self.assertAlmostEqual(size, 47.244094, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderPoints, c)
self.assertAlmostEqual(size, 47.2440833, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderInches, c)
self.assertAlmostEqual(size, 3401.574, places=5)
size = r.convertToMapUnits(2, QgsUnitTypes.RenderPixels, c)
self.assertAlmostEqual(size, 4.0, places=5)
c.minSizeMMEnabled = False
# maximum size less than the calculated size, so size should be limited to maxSizeMM
c.maxSizeMM = 0.05
c.maxSizeMMEnabled = True
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMapUnits, c)
self.assertAlmostEqual(size, 1.1811023622047245, places=5)
# only conversion from mapunits should be affected
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMillimeters, c)
self.assertAlmostEqual(size, 47.244094, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderPoints, c)
self.assertAlmostEqual(size, 47.2440833, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderInches, c)
self.assertAlmostEqual(size, 3401.574, places=5)
size = r.convertToMapUnits(2, QgsUnitTypes.RenderPixels, c)
self.assertAlmostEqual(size, 4.0, places=5)
c.maxSizeMMEnabled = False
# test with minimum scale set
c.minScale = 150000000.0
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMapUnits, c)
self.assertAlmostEqual(size, 15.57001821, places=5)
# only conversion from mapunits should be affected
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMillimeters, c)
self.assertAlmostEqual(size, 47.244094, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderPoints, c)
self.assertAlmostEqual(size, 47.2440833, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderInches, c)
self.assertAlmostEqual(size, 3401.574, places=5)
size = r.convertToMapUnits(2, QgsUnitTypes.RenderPixels, c)
self.assertAlmostEqual(size, 4.0, places=5)
c.minScale = 0
# test with maximum scale set
c.maxScale = 1550000000.0
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMapUnits, c)
self.assertAlmostEqual(size, 1.50677595625, places=5)
# only conversion from mapunits should be affected
size = r.convertToMapUnits(2, QgsUnitTypes.RenderMillimeters, c)
self.assertAlmostEqual(size, 47.244094, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderPoints, c)
self.assertAlmostEqual(size, 47.2440833, places=5)
size = r.convertToMapUnits(5.66929, QgsUnitTypes.RenderInches, c)
self.assertAlmostEqual(size, 3401.574, places=5)
size = r.convertToMapUnits(2, QgsUnitTypes.RenderPixels, c)
self.assertAlmostEqual(size, 4.0, places=5)
c.maxScale = 0
def read_settings(self):
"""Restore settings from QSettings.
Do this on init and after changing options in the options dialog.
"""
settings = QSettings()
flag = bool(settings.value('inasafe/showRubberBands', False,
type=bool))
self.extent.show_rubber_bands = flag
try:
extent = settings.value('inasafe/analysis_extent', '', type=str)
crs = settings.value('inasafe/analysis_extent_crs', '', type=str)
except TypeError:
# Any bogus stuff in settings and we just clear them
extent = ''
crs = ''
if extent != '' and crs != '':
extent = extent_string_to_array(extent)
try:
self.extent.user_extent = QgsRectangle(*extent)
self.extent.user_extent_crs = QgsCoordinateReferenceSystem(crs)
self.extent.show_user_analysis_extent()
except TypeError:
self.extent.user_extent = None
self.extent.user_extent_crs = None
flag = settings.value('inasafe/useThreadingFlag', False, type=bool)
self.run_in_thread_flag = flag
flag = settings.value('inasafe/setZoomToImpactFlag', True, type=bool)
self.zoom_to_impact_flag = flag
# whether exposure layer should be hidden after model completes
flag = settings.value('inasafe/setHideExposureFlag', False, type=bool)
self.hide_exposure_flag = flag
# whether to 'hard clip' layers (e.g. cut buildings in half if they
# lie partially in the AOI
self.clip_hard = settings.value('inasafe/clip_hard', False, type=bool)
# whether to show or not postprocessing generated layers
self.show_intermediate_layers = settings.value(
'inasafe/show_intermediate_layers', False, type=bool)
# whether to show or not dev only options
self.developer_mode = settings.value('inasafe/developer_mode',
False,
type=bool)
# whether to show or not a custom Logo
self.organisation_logo_path = settings.value(
'inasafe/organisation_logo_path',
default_organisation_logo_path(),
type=str)
flag = bool(
settings.value('inasafe/showOrganisationLogoInDockFlag',
True,
type=bool))
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(
os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer])
# create composition with composer map
self.mapSettings = QgsMapSettings()
layerStringList = []
layerStringList.append(mVectorLayer.id())
self.mapSettings.setLayers(layerStringList)
self.mapSettings.setCrsTransformEnabled(True)
self.mapSettings.setMapUnits(QgsUnitTypes.DistanceMeters)
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
self.mapSettings.setDestinationCrs(crs)
self.mComposition = QgsComposition(self.mapSettings)
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
mVectorLayer.setRenderer(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
mOverview.setFrameEnabled(True)
mOverview.overview().setFrameMap(self.mAtlasMap.id())
self.mComposition.addComposerMap(mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbol.createSimple(props2)
mOverview.overview().setFrameSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" %
(self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText(
"# [%@atlas_featurenumber || ' / ' || @atlas_totalfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning(
"feature number label font: %s exactMatch:%s" %
(self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
shutil.rmtree(tmppath, True)
def test_signalConnection(self):
# remove all layers
QgsProject.instance().removeAllMapLayers()
# set dependencies and add back layers
self.pointsLayer = QgsVectorLayer(
"dbname='%s' table=\"node\" (geom) sql=" % self.fn, "points",
"spatialite")
assert (self.pointsLayer.isValid())
self.linesLayer = QgsVectorLayer(
"dbname='%s' table=\"section\" (geom) sql=" % self.fn, "lines",
"spatialite")
assert (self.linesLayer.isValid())
self.pointsLayer2 = QgsVectorLayer(
"dbname='%s' table=\"node2\" (geom) sql=" % self.fn, "_points2",
"spatialite")
assert (self.pointsLayer2.isValid())
self.pointsLayer.setDependencies(
[QgsMapLayerDependency(self.linesLayer.id())])
self.pointsLayer2.setDependencies(
[QgsMapLayerDependency(self.pointsLayer.id())])
# this should update connections between layers
QgsProject.instance().addMapLayers([self.pointsLayer])
QgsProject.instance().addMapLayers([self.linesLayer])
QgsProject.instance().addMapLayers([self.pointsLayer2])
ms = QgsMapSettings()
ms.setOutputSize(QSize(100, 100))
ms.setExtent(QgsRectangle(0, 0, 1, 1))
self.assertTrue(ms.hasValidSettings())
u = QgsSnappingUtils()
u.setMapSettings(ms)
cfg = u.config()
cfg.setEnabled(True)
cfg.setMode(QgsSnappingConfig.AdvancedConfiguration)
cfg.setIndividualLayerSettings(
self.pointsLayer,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex,
20, QgsTolerance.Pixels))
cfg.setIndividualLayerSettings(
self.pointsLayer2,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex,
20, QgsTolerance.Pixels))
u.setConfig(cfg)
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setId(4)
geom = QgsGeometry.fromWkt("LINESTRING(0.5 0.2,0.6 0)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the second snapped point is OK
m = u.snapToMap(QPoint(75, 100 - 0))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPointXY(0.8, 0.0))
self.pointsLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
def testQgsRectangleRepr(self):
r = QgsRectangle(1, 2, 3, 4)
self.assertEqual(r.__repr__(), '<QgsRectangle: 1 2, 3 4>')
def qgis_composer_renderer(impact_report, component):
"""Default Map Report Renderer using QGIS Composer.
Render using qgis composer for a given impact_report data and component
context
:param impact_report: ImpactReport contains data about the report that is
going to be generated
:type impact_report: safe.report.impact_report.ImpactReport
:param component: Contains the component metadata and context for
rendering the output
:type component:
safe.report.report_metadata.QgisComposerComponentsMetadata
:return: whatever type of output the component should be
.. versionadded:: 4.0
"""
context = component.context
""":type: safe.report.extractors.composer.QGISComposerContext"""
qgis_composition_context = impact_report.qgis_composition_context
inasafe_context = impact_report.inasafe_context
# load composition object
composition = QgsComposition(qgis_composition_context.map_settings)
# load template
main_template_folder = impact_report.metadata.template_folder
template_path = os.path.join(main_template_folder, component.template)
with open(template_path) as template_file:
template_content = template_file.read()
document = QtXml.QDomDocument()
document.setContent(template_content)
load_status = composition.loadFromTemplate(document,
context.substitution_map)
if not load_status:
raise TemplateLoadingError(
tr('Error loading template: %s') % template_path)
# replace image path
for img in context.image_elements:
item_id = img.get('id')
path = img.get('path')
image = composition.getComposerItemById(item_id)
""":type: qgis.core.QgsComposerPicture"""
if image is not None and path is not None:
try:
image.setPicturePath(path)
except:
pass
# replace html frame
for html_el in context.html_frame_elements:
item_id = html_el.get('id')
mode = html_el.get('mode')
html_element = composition.getComposerItemById(item_id)
""":type: qgis.core.QgsComposerHtml"""
if html_element:
if mode == 'text':
text = html_el.get('text')
text = text if text else ''
html_element.setContentMode(QgsComposerHtml.ManualHtml)
html_element.setHtml(text)
html_element.loadHtml()
elif mode == 'url':
url = html_el.get('url')
html_element.setContentMode(QgsComposerHtml.Url)
qurl = QUrl.fromLocalFile(url)
html_element.setUrl(qurl)
# resize map extent
for map_el in context.map_elements:
item_id = map_el.get('id')
split_count = map_el.get('grid_split_count')
layers = map_el.get('layers')
map_extent_option = map_el.get('extent')
composer_map = composition.getComposerItemById(item_id)
""":type: qgis.core.QgsComposerMap"""
if composer_map:
composer_map.setKeepLayerSet(True)
layer_set = [l.id() for l in layers if isinstance(l, QgsMapLayer)]
composer_map.setLayerSet(layer_set)
if map_extent_option and isinstance(map_extent_option,
QgsRectangle):
# use provided map extent
extent = map_extent_option
else:
# if map extent not provided, try to calculate extent
# from list of given layers. Combine it so all layers were
# shown properly
extent = QgsRectangle()
extent.setMinimal()
for l in layers:
# combine extent if different layer is provided.
extent.combineExtentWith(l.extent())
width = extent.width()
height = extent.height()
longest_width = width if width > height else height
half_length = longest_width / 2
margin = half_length / 5
center = extent.center()
min_x = center.x() - half_length - margin
max_x = center.x() + half_length + margin
min_y = center.y() - half_length - margin
max_y = center.y() + half_length + margin
# noinspection PyCallingNonCallable
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
composer_map.zoomToExtent(square_extent)
composer_map.renderModeUpdateCachedImage()
actual_extent = composer_map.extent()
# calculate intervals for grid
x_interval = actual_extent.width() / split_count
composer_map.grid().setIntervalX(x_interval)
y_interval = actual_extent.height() / split_count
composer_map.grid().setIntervalY(y_interval)
# calculate legend element
for leg_el in context.map_legends:
item_id = leg_el.get('id')
title = leg_el.get('title')
layers = leg_el.get('layers')
symbol_count = leg_el.get('symbol_count')
column_count = leg_el.get('column_count')
legend = composition.getComposerItemById(item_id)
""":type: qgis.core.QgsComposerLegend"""
if legend:
# set column count
if column_count:
legend.setColumnCount(column_count)
elif symbol_count <= 5:
legend.setColumnCount(1)
else:
legend.setColumnCount(symbol_count / 5 + 1)
# set legend title
if title is not None:
legend.setTitle(title)
# set legend
root_group = legend.modelV2().rootGroup()
for l in layers:
# used for customizations
tree_layer = root_group.addLayer(l)
QgsLegendRenderer.setNodeLegendStyle(
tree_layer, QgsComposerLegendStyle.Hidden)
legend.synchronizeWithModel()
# process to output
# in case output folder not specified
if impact_report.output_folder is None:
impact_report.output_folder = mkdtemp(dir=temp_dir())
output_format = component.output_format
component_output_path = impact_report.component_absolute_output_path(
component.key)
component_output = None
doc_format = QgisComposerComponentsMetadata.OutputFormat.DOC_OUTPUT
template_format = QgisComposerComponentsMetadata.OutputFormat.QPT
if isinstance(output_format, list):
component_output = []
for i in range(len(output_format)):
each_format = output_format[i]
each_path = component_output_path[i]
if each_format in doc_format:
result_path = create_qgis_pdf_output(
each_path, composition,
impact_report.qgis_composition_context, each_format,
component)
component_output.append(result_path)
elif each_format == template_format:
result_path = create_qgis_template_output(
each_path, composition)
component_output.append(result_path)
elif isinstance(output_format, dict):
component_output = {}
for key, each_format in output_format.iteritems():
each_path = component_output_path[key]
if each_format in doc_format:
result_path = create_qgis_pdf_output(
each_path, composition,
impact_report.qgis_composition_context, each_format,
component)
component_output[key] = result_path
elif each_format == template_format:
result_path = create_qgis_template_output(
each_path, composition)
component_output[key] = result_path
elif (output_format
in QgisComposerComponentsMetadata.OutputFormat.SUPPORTED_OUTPUT):
component_output = None
if output_format in doc_format:
result_path = create_qgis_pdf_output(
component_output_path, composition,
impact_report.qgis_composition_context, output_format,
component)
component_output = result_path
elif output_format == template_format:
result_path = create_qgis_template_output(component_output_path,
composition)
component_output = result_path
component.output = component_output
return component.output
def runContextMeasure(self, feedback, reference, test, method,
threshold) -> MatchPairManager:
"""
Processing the matching using Context measure.
Return: the MatchPairManager
"""
# 1) Initial calculus
# 1.1) Descobrir quem eh menor, que serve de param
# SearchLength = Diagonal / PointCount * 20 -> distance for 20 points in Diagonal
boxA = reference.extent()
boxB = test.extent()
searchLengthA = math.sqrt(boxA.width()**2 + boxA.height()**2
) / reference.featureCount() * 20.
searchLengthB = math.sqrt(boxB.width()**2 +
boxB.height()**2) / test.featureCount() * 20.
# parameters for context
cttSearchLength = searchLengthA if searchLengthA > searchLengthB else searchLengthB
cttDistanceStep = cttSearchLength / 20.
cttAngleStep = math.pi / 6.
# outros
refIsMulti = QgsWkbTypes.isMultiType(int(reference.wkbType()))
testIsMulti = QgsWkbTypes.isMultiType(int(test.wkbType()))
# 2) Calculate the context
context = ContextMeasure()
shapeContextA = context.calculateShapeContext(reference,
cttSearchLength,
cttAngleStep,
cttDistanceStep)
feedback.setProgress(10)
shapeContextB = context.calculateShapeContext(test, cttSearchLength,
cttAngleStep,
cttDistanceStep)
feedback.setProgress(20)
# 3) Run the processing
ncols = reference.featureCount()
nrows = test.featureCount()
distMatrix = [[1. for x in range(ncols + 1)] for y in range(nrows + 1)]
# 3.1) Compute the number of steps to display within the progress bar and
# get features from source
total = 80.0 / ncols
# 3.2) Itera sobre os ref e procura o equivalente em test
for j, refFeat in enumerate(reference.getFeatures()):
# running chks
if feedback.isCanceled():
break
# Coloque o ID no lugar
distMatrix[0][j + 1] = refFeat.id()
refGeom = refFeat.geometry()
refHist = shapeContextA.get(refFeat.id())
# Chks habituais
if refGeom.isEmpty() or refHist is None:
continue
# obtem a geometria e monta o box de busca - baseado no cttSearchLength
refPoint = refGeom.asPoint(
) if not refIsMulti else refGeom.asMultiPoint()[0].asPoint()
refBox = QgsRectangle(refPoint.x() - cttSearchLength,
refPoint.y() - cttSearchLength,
refPoint.x() + cttSearchLength,
refPoint.y() + cttSearchLength)
for i, testFeat in enumerate(test.getFeatures()):
# Coloque o ID no lugar - repetindo
distMatrix[i + 1][0] = testFeat.id()
testGeom = testFeat.geometry()
testHist = shapeContextB.get(testFeat.id())
# Chks habituais
if testGeom.isEmpty() or testHist is None:
continue
# obtem a geometria
testPoint = testGeom.asPoint(
) if not testIsMulti else testGeom.asMultiPoint()[0].asPoint()
# ignore o disjoint
if not refBox.contains(testPoint):
continue
# agora sim, o que a gente veio fazer aqui: distance
distMatrix[i + 1][j + 1] = context.distanceContext(
refHist, testHist)
feedback.setProgress(20 + int(j * total))
# fim for_feat
# debug
# 4) OK, tenho tudo, faltam os pares
pairMgr = MatchPairManager()
# check o criteria
criteria = pairMgr.CriteriaType.ISMINIMUM if method % 2 == 0 else pairMgr.CriteriaType.BOTHMIN
pairMgr.buildFromMatrix(distMatrix, criteria, threshold)
return pairMgr
def processAlgorithm(self, progress):
extent = self.getParameterValue(self.EXTENT).split(',')
xSpace = self.getParameterValue(self.STEP_X)
ySpace = self.getParameterValue(self.STEP_Y)
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
fields.append(QgsField('coord', QVariant.Double, '', 24, 15))
fieldCount = 2
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.LineString, mapCRS)
feat = QgsFeature()
feat.initAttributes(fieldCount)
feat.setFields(fields)
geom = QgsGeometry()
idVar = 0
count = 0
count_max = (bbox.yMaximum() - bbox.yMinimum()) / ySpace
count_update = count_max * 0.10
y = bbox.yMaximum()
while y >= bbox.yMinimum():
pt1 = QgsPoint(bbox.xMinimum(), y)
pt2 = QgsPoint(bbox.xMaximum(), y)
line = [pt1, pt2]
feat.setGeometry(geom.fromPolyline(line))
feat.setAttribute(0, idVar)
feat.setAttribute(1, y)
writer.addFeature(feat)
y = y - ySpace
idVar += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
progress.setPercentage(int(count / count_max * 50))
progress.setPercentage(50)
# counters for progressbar - update every 5%
count = 0
count_max = (bbox.xMaximum() - bbox.xMinimum()) / xSpace
count_update = count_max * 0.10
x = bbox.xMinimum()
while x <= bbox.xMaximum():
pt1 = QgsPoint(x, bbox.yMaximum())
pt2 = QgsPoint(x, bbox.yMinimum())
line = [pt1, pt2]
feat.setGeometry(geom.fromPolyline(line))
feat.setAttribute(0, idVar)
feat.setAttribute(1, x)
writer.addFeature(feat)
x = x + xSpace
idVar += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
progress.setPercentage(50 + int(count / count_max * 50))
del writer
def runEuclideanDistance(self, feedback, reference, test, method,
threshold) -> MatchPairManager:
"""
Processing the matching using Euclidean distance.
Return: the MatchPairManager
"""
# 2) test parameters
testExtent = test.extent()
maxDistance = testExtent.width(
) if testExtent.width() > testExtent.height() else testExtent.height()
if maxDistance < 2. * threshold:
raise Exception(
self.
tr("Test data with a small bounding box. It should be at least twice the threshold."
), "INVALIDPARAMETERVALUE")
refIsMulti = QgsWkbTypes.isMultiType(int(reference.wkbType()))
testIsMulti = QgsWkbTypes.isMultiType(int(test.wkbType()))
# 3) Run the processing
ncols = reference.featureCount()
nrows = test.featureCount()
distMatrix = [[int(maxDistance) for x in range(ncols + 1)]
for y in range(nrows + 1)]
# 3.1) Compute the number of steps to display within the progress bar and
# get features from source
total = 100.0 / ncols
# 3.2) Itera sobre os ref e procura o equivalente em test
for j, refFeat in enumerate(reference.getFeatures()):
# running chks
if feedback.isCanceled():
break
# Coloque o ID no lugar
distMatrix[0][j + 1] = refFeat.id() #refFeat.id()
refGeom = refFeat.geometry()
# Chks habituais
if refGeom.isEmpty():
continue
# obtem a geometria e monta o box de busca
refPoint = refGeom.asPoint(
) if not refIsMulti else refGeom.asMultiPoint()[0].asPoint()
refBox = QgsRectangle(refPoint.x() - threshold,
refPoint.y() - threshold,
refPoint.x() + threshold,
refPoint.y() + threshold)
for i, testFeat in enumerate(test.getFeatures()):
# Coloque o ID no lugar - repetindo
distMatrix[i + 1][0] = testFeat.id() #testFeat.id()
testGeom = testFeat.geometry()
# Chks habituais
if testGeom.isEmpty():
continue
# obtem a geometria
testPoint = testGeom.asPoint(
) if not testIsMulti else testGeom.asMultiPoint()[0].asPoint()
# ignore o disjoint
if not refBox.contains(testPoint):
continue
# agora sim, o que a gente veio fazer aqui: distance
distMatrix[i + 1][j + 1] = refPoint.distance(testPoint)
feedback.setProgress(int(j * total))
# debug
# 4) OK, tenho tudo, faltam os pares
pairMgr = MatchPairManager()
# check o criteria
criteria = pairMgr.CriteriaType.ISMINIMUM if method % 2 == 0 else pairMgr.CriteriaType.BOTHMIN
pairMgr.buildFromMatrix(distMatrix, criteria, threshold)
return pairMgr
def search_data(self, **kwargs):
"""
Get plot geometries associated with parcels, both collected and supplies, zoom to them, fill comparison table
and activate map swipe tool.
To fill the comparison table we build two search dicts, one for supplies (already given because the alphanumeric
search is on supplies db source), and another one for collected. For the latter, we have 3 cases. We specify
them below (inline).
:param kwargs: key-value (field name-field value) to search in parcel tables, both collected and supplies
Normally, keys are parcel_number, old_parcel_number or FMI, but if duplicates are found, an
additional t_id disambiguates only for the collected source. In the supplies source we assume
we will not find duplicates, if there are, we will choose the first record found an will not deal
with letting the user choose one of the duplicates by hand (as we do for the collected source).
"""
self.chk_show_all_plots.setEnabled(False)
self.chk_show_all_plots.setChecked(True)
self.initialize_tools_and_layers() # Reset any filter on layers
plots_supplies = list()
plots_collected = list()
self.clear_result_table()
search_option = self.cbo_parcel_fields.currentData()
search_field_supplies = get_supplies_search_options(
self.utils._supplies_db.names)[search_option]
search_field_collected = get_collected_search_options(
self.utils._db.names)[search_option]
search_value = list(kwargs.values())[0]
# Build search criterion for both supplies and collected
search_criterion_supplies = {search_field_supplies: search_value}
# Get supplies parcel's t_id and get related plot(s)
expression_supplies = QgsExpression("{}='{}'".format(
search_field_supplies, search_value))
request = QgsFeatureRequest(expression_supplies)
field_idx = self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PARCEL_T].fields().indexFromName(
self.utils._supplies_db.names.T_ID_F)
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes([field_idx
]) # Note: this adds a new flag
supplies_parcels = [
feature for feature in self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PARCEL_T].getFeatures(request)
]
if len(supplies_parcels) > 1:
# We do not expect duplicates in the supplies source!
pass # We'll choose the first one anyways
elif len(supplies_parcels) == 0:
self.logger.info(
__name__, "No supplies parcel found! Search: {}={}".format(
search_field_supplies, search_value))
supplies_plot_t_ids = []
if supplies_parcels:
supplies_plot_t_ids = self.utils.ladm_data.get_plots_related_to_parcels_supplies(
self.utils._supplies_db,
[supplies_parcels[0][self.utils._supplies_db.names.T_ID_F]],
self.utils._supplies_db.names.T_ID_F,
self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T])
if supplies_plot_t_ids:
self._current_supplies_substring = "\"{}\" IN ('{}')".format(
self.utils._supplies_db.names.T_ID_F,
"','".join([str(t_id) for t_id in supplies_plot_t_ids]))
plots_supplies = self.utils.ladm_data.get_features_from_t_ids(
self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T],
self.utils._supplies_db.names.T_ID_F, supplies_plot_t_ids,
True)
# Now get COLLECTED parcel's t_id to build the search dict for collected
collected_parcel_t_id = None
if 'collected_parcel_t_id' in kwargs:
# This is the case when this panel is called and we already know the parcel number is duplicated
collected_parcel_t_id = kwargs['collected_parcel_t_id']
search_criterion_collected = {
self.utils._db.names.T_ID_F: collected_parcel_t_id
} # As there are duplicates, we need to use t_ids
else:
# This is the case when:
# + Either this panel was called and we know the parcel number is not duplicated, or
# + This panel was shown without knowing about duplicates (e.g., individual parcel search) and we still
# need to discover whether we have duplicates for this search criterion
search_criterion_collected = {search_field_collected: search_value}
expression_collected = QgsExpression("{}='{}'".format(
search_field_collected, search_value))
request = QgsFeatureRequest(expression_collected)
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(
[self.utils._db.names.T_ID_F],
self.utils._layers[self.utils._db.names.LC_PARCEL_T].fields(
)) # Note this adds a new flag
collected_parcels = self.utils._layers[
self.utils._db.names.LC_PARCEL_T].getFeatures(request)
collected_parcels_t_ids = [
feature[self.utils._db.names.T_ID_F]
for feature in collected_parcels
]
if collected_parcels_t_ids:
collected_parcel_t_id = collected_parcels_t_ids[0]
if len(collected_parcels_t_ids
) > 1: # Duplicates in collected source after a search
QApplication.restoreOverrideCursor(
) # Make sure cursor is not waiting (it is if on an identify)
QCoreApplication.processEvents()
dlg_select_parcel = SelectDuplicateParcelDialog(
self.utils, collected_parcels_t_ids, self.parent)
dlg_select_parcel.exec_()
if dlg_select_parcel.parcel_t_id: # User selected one of the duplicated parcels
collected_parcel_t_id = dlg_select_parcel.parcel_t_id
search_criterion_collected = {
self.utils._db.names.T_ID_F: collected_parcel_t_id
}
else:
return # User just cancelled the dialog, there is nothing more to do
self.fill_table(search_criterion_supplies, search_criterion_collected)
# Now get related plot(s) for both collected and supplies,
if collected_parcel_t_id is not None:
plot_t_ids = self.utils.ladm_data.get_plots_related_to_parcels(
self.utils._db, [collected_parcel_t_id],
self.utils._db.names.T_ID_F,
plot_layer=self.utils._layers[self.utils._db.names.LC_PLOT_T],
uebaunit_table=self.utils._layers[
self.utils._db.names.COL_UE_BAUNIT_T])
if plot_t_ids:
self._current_substring = "{} IN ('{}')".format(
self.utils._db.names.T_ID_F,
"','".join([str(t_id) for t_id in plot_t_ids]))
plots_collected = self.utils.ladm_data.get_features_from_t_ids(
self.utils._layers[self.utils._db.names.LC_PLOT_T],
self.utils._db.names.T_ID_F, plot_t_ids, True)
# Zoom to combined extent
plot_features = plots_supplies + plots_collected # Feature list
plots_extent = QgsRectangle()
for plot in plot_features:
plots_extent.combineExtentWith(plot.geometry().boundingBox())
if not plots_extent.isEmpty():
self.utils.iface.mapCanvas().zoomToFeatureExtent(plots_extent)
if plots_supplies and plots_collected: # Otherwise the map swipe tool doesn't add any value :)
# Activate Swipe Tool
self.utils.app.gui.activate_layer(self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T])
self.parent.activate_map_swipe_tool()
# Send a custom mouse move on the map to make the map swipe tool's limit appear on the canvas
coord_x = plots_extent.xMaximum() - (plots_extent.xMaximum(
) - plots_extent.xMinimum()) / 9 # 90%
coord_y = plots_extent.yMaximum() - (plots_extent.yMaximum(
) - plots_extent.yMinimum()) / 2 # 50%
coord_transform = self.utils.iface.mapCanvas(
).getCoordinateTransform()
map_point = coord_transform.transform(coord_x, coord_y)
widget_point = map_point.toQPointF().toPoint()
global_point = self.utils.canvas.mapToGlobal(widget_point)
self.utils.canvas.mousePressEvent(
QMouseEvent(QEvent.MouseButtonPress, global_point,
Qt.LeftButton, Qt.LeftButton, Qt.NoModifier))
self.utils.canvas.mouseMoveEvent(
QMouseEvent(QEvent.MouseMove, widget_point + QPoint(1, 0),
Qt.NoButton, Qt.LeftButton, Qt.NoModifier))
self.utils.canvas.mouseReleaseEvent(
QMouseEvent(QEvent.MouseButtonRelease,
widget_point + QPoint(1, 0), Qt.LeftButton,
Qt.LeftButton, Qt.NoModifier))
# Once the query is done, activate the checkbox to alternate all plots/only selected plot
self.chk_show_all_plots.setEnabled(True)
def generate_reports(self):
"""Generate PDF reports for each aggregation unit using map composer.
First the report template is loaded with the renderer from two
impact layers. After it's loaded, if it is not aggregated then
we just use composition to produce report. Since there are two
impact maps here, we need to set a new extent for these impact maps
by a simple calculation.
If it is not aggregated then we use a powerful QGIS atlas generation
on composition. Since we save each report table representing each
aggregated area on self.html_report (which is a dictionary with the
aggregation area name as a key and its path as a value), and we set
the aggregation area name as current filename on atlas generation,
we can match these two so that we have the right report table for
each report.
For those two cases, we use the same template. The report table is
basically an HTML frame. Of course after the merging process is done,
we delete each report table on self.html_reports physically on disk.
"""
# Set the layer set
layer_set = [
self.first_impact['layer'].id(), self.second_impact['layer'].id()
]
# If aggregated, append chosen aggregation layer
if not self.entire_area_mode:
layer_set.append(self.aggregation['layer'].id())
# Instantiate Map Settings for Composition
if qgis_version() < 20400:
map_settings = QgsMapRenderer()
map_settings.setLayerSet(layer_set)
else:
map_settings = QgsMapSettings()
map_settings.setLayers(layer_set)
# Create composition
composition = self.load_template(map_settings)
# Get Map
composer_map = composition.getComposerItemById('impact-map')
# Get HTML Report Frame
html_report_item = \
composition.getComposerItemById('merged-report-table')
html_report_frame = composition.getComposerHtmlByItem(html_report_item)
if self.entire_area_mode:
# Get composer map size
composer_map_width = composer_map.boundingRect().width()
composer_map_height = composer_map.boundingRect().height()
# Set the extent from two impact layers to fit into composer map
composer_size_ratio = float(composer_map_height /
composer_map_width)
# The extent of two impact layers
min_x = min(self.first_impact['layer'].extent().xMinimum(),
self.second_impact['layer'].extent().xMinimum())
min_y = min(self.first_impact['layer'].extent().yMinimum(),
self.second_impact['layer'].extent().yMinimum())
max_x = max(self.first_impact['layer'].extent().xMaximum(),
self.second_impact['layer'].extent().xMaximum())
max_y = max(self.first_impact['layer'].extent().yMaximum(),
self.second_impact['layer'].extent().yMaximum())
max_width = max_x - min_x
max_height = max_y - min_y
layers_size_ratio = float(max_height / max_width)
center_x = min_x + float(max_width / 2.0)
center_y = min_y + float(max_height / 2.0)
# The extent should fit the composer map size
new_width = max_width
new_height = max_height
# QgsComposerMap only overflows to height, so if it overflows,
# the extent of the width should be widened
if layers_size_ratio > composer_size_ratio:
new_width = max_height / composer_size_ratio
# Set new extent
fit_min_x = center_x - (new_width / 2.0)
fit_max_x = center_x + (new_width / 2.0)
fit_min_y = center_y - (new_height / 2.0)
fit_max_y = center_y + (new_height / 2.0)
# Create the extent and set it to the map
# noinspection PyCallingNonCallable
map_extent = QgsRectangle(fit_min_x, fit_min_y, fit_max_x,
fit_max_y)
composer_map.setNewExtent(map_extent)
# Add grid to composer map
split_count = 5
x_interval = new_width / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = new_height / split_count
composer_map.setGridIntervalY(y_interval)
# Self.html_reports must have only 1 key value pair
# Rizky: If layer components were aggregated, html_reports will
# have several key value pairs. So we get the last value because
# it is for the total/entire area
area_title = list(self.html_reports.keys())[-1]
# Set Report Summary
summary_report = composition.getComposerItemById('summary-report')
summary_report.setText(self.summary_report[area_title])
# Set Aggregation Area Label
area_label = composition.getComposerItemById('aggregation-area')
area_label.setText(area_title.title())
# Set merged-report-table
html_report_path = self.html_reports[area_title]
# noinspection PyArgumentList
html_frame_url = QUrl.fromLocalFile(html_report_path)
html_report_frame.setUrl(html_frame_url)
# Export composition to PDF file
file_name = '_'.join(area_title.split())
file_path = '%s.pdf' % file_name
path = os.path.join(self.out_dir, file_path)
composition.exportAsPDF(path)
else:
# Create atlas composition:
# noinspection PyCallingNonCallable
atlas = QgsAtlasComposition(composition)
# Set coverage layer
# Map will be clipped by features from this layer:
atlas.setCoverageLayer(self.aggregation['layer'])
# Add grid to composer map from coverage layer
split_count = 5
map_width = self.aggregation['layer'].extent().width()
map_height = self.aggregation['layer'].extent().height()
x_interval = map_width / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = map_height / split_count
composer_map.setGridIntervalY(y_interval)
# Set composer map that will be used for printing atlas
atlas.setComposerMap(composer_map)
# set output filename pattern
atlas.setFilenamePattern(self.aggregation['aggregation_attribute'])
# Start rendering
atlas.beginRender()
# Iterate all aggregation unit in aggregation layer
for i in range(0, atlas.numFeatures()):
atlas.prepareForFeature(i)
current_filename = atlas.currentFilename()
file_name = '_'.join(current_filename.split())
file_path = '%s.pdf' % file_name
path = os.path.join(self.out_dir, file_path)
# Only print the area that has the report
area_title = current_filename.lower()
if area_title in self.summary_report:
# Set Report Summary
summary_report = composition.getComposerItemById(
'summary-report')
summary_report.setText(self.summary_report[area_title])
# Set Aggregation Area Label
area_label = composition.getComposerItemById(
'aggregation-area')
area_label.setText(area_title.title())
# Set merged-report-table
html_report_path = self.html_reports[area_title]
# noinspection PyArgumentList
html_frame_url = QUrl.fromLocalFile(html_report_path)
html_report_frame.setUrl(html_frame_url)
# Export composition to PDF file
composition.exportAsPDF(path)
# End of rendering
atlas.endRender()
def testStyles(self):
"""Test that styles for rasters and vectors are kept when setDataSource is called"""
options = QgsDataProvider.ProviderOptions()
temp_dir = QTemporaryDir()
p = QgsProject.instance()
for f in (
'bad_layer_raster_test.tfw',
'bad_layer_raster_test.tiff',
'bad_layer_raster_test.tiff.aux.xml',
'bad_layers_test.gpkg',
'good_layers_test.qgs'):
copyfile(os.path.join(TEST_DATA_DIR, 'projects', f), os.path.join(temp_dir.path(), f))
project_path = os.path.join(temp_dir.path(), 'good_layers_test.qgs')
p = QgsProject().instance()
self.assertTrue(p.read(project_path))
self.assertEqual(p.count(), 3)
ms = self.getBaseMapSettings()
point_a = list(p.mapLayersByName('point_a'))[0]
point_b = list(p.mapLayersByName('point_b'))[0]
raster = list(p.mapLayersByName('bad_layer_raster_test'))[0]
self.assertTrue(point_a.isValid())
self.assertTrue(point_b.isValid())
self.assertTrue(raster.isValid())
ms.setExtent(QgsRectangle(2.81861, 41.98138, 2.81952, 41.9816))
ms.setLayers([point_a, point_b, raster])
image = renderMapToImage(ms)
print(os.path.join(temp_dir.path(), 'expected.png'))
self.assertTrue(image.save(os.path.join(temp_dir.path(), 'expected.png'), 'PNG'))
point_a_source = point_a.publicSource()
point_b_source = point_b.publicSource()
raster_source = raster.publicSource()
point_a.setDataSource(point_a_source, point_a.name(), 'ogr', options)
point_b.setDataSource(point_b_source, point_b.name(), 'ogr', options)
raster.setDataSource(raster_source, raster.name(), 'gdal', options)
self.assertTrue(image.save(os.path.join(temp_dir.path(), 'actual.png'), 'PNG'))
self.assertTrue(filecmp.cmp(os.path.join(temp_dir.path(), 'actual.png'), os.path.join(temp_dir.path(), 'expected.png')), False)
# Now build a bad project
bad_project_path = os.path.join(temp_dir.path(), 'bad_layers_test.qgs')
with open(project_path, 'r') as infile:
with open(bad_project_path, 'w+') as outfile:
outfile.write(infile.read().replace('./bad_layers_test.', './bad_layers_test-BAD_SOURCE.').replace('bad_layer_raster_test.tiff', 'bad_layer_raster_test-BAD_SOURCE.tiff'))
self.assertTrue(p.read(bad_project_path))
self.assertEqual(p.count(), 3)
point_a = list(p.mapLayersByName('point_a'))[0]
point_b = list(p.mapLayersByName('point_b'))[0]
raster = list(p.mapLayersByName('bad_layer_raster_test'))[0]
self.assertFalse(point_a.isValid())
self.assertFalse(point_b.isValid())
self.assertFalse(raster.isValid())
point_a.setDataSource(point_a_source, point_a.name(), 'ogr', options)
point_b.setDataSource(point_b_source, point_b.name(), 'ogr', options)
raster.setDataSource(raster_source, raster.name(), 'gdal', options)
self.assertTrue(image.save(os.path.join(temp_dir.path(), 'actual_fixed.png'), 'PNG'))
self.assertTrue(filecmp.cmp(os.path.join(temp_dir.path(), 'actual_fixed.png'), os.path.join(temp_dir.path(), 'expected.png')), False)
def testSetOutputCrs(self):
w = qgis.gui.QgsExtentGroupBox()
w.setCheckable(True)
# ensure setting output crs doesn't change state of group box
w.setChecked(False)
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
self.assertFalse(w.isChecked())
w.setChecked(True)
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
self.assertTrue(w.isChecked())
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
w.setCurrentExtent(QgsRectangle(1, 2, 3, 4), QgsCoordinateReferenceSystem('epsg:4326'))
w.setOutputExtentFromCurrent()
self.assertEqual(w.outputExtent(), QgsRectangle(1, 2, 3, 4))
# with reprojection
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:3785'))
self.assertEqual(w.outputExtent().toString(4), QgsRectangle(111319.4908, 222684.2085, 333958.4724, 445640.1097).toString(4))
# change CRS back
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
# extent should be back to current - not a reprojection of the reprojected bounds
self.assertEqual(w.outputExtent().toString(20), QgsRectangle(1, 2, 3, 4).toString(20))
# repeat, this time using original extents
w = qgis.gui.QgsExtentGroupBox()
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
w.setOriginalExtent(QgsRectangle(1, 2, 3, 4), QgsCoordinateReferenceSystem('epsg:4326'))
w.setOutputExtentFromOriginal()
self.assertEqual(w.outputExtent(), QgsRectangle(1, 2, 3, 4))
# with reprojection
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:3785'))
self.assertEqual(w.outputExtent().toString(4),
QgsRectangle(111319.4908, 222684.2085, 333958.4724, 445640.1097).toString(4))
# change CRS back
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
# extent should be back to original - not a reprojection of the reprojected bounds
self.assertEqual(w.outputExtent().toString(20), QgsRectangle(1, 2, 3, 4).toString(20))
# repeat, this time using layer extent
layer = QgsVectorLayer("Polygon?crs=4326", 'memory', 'memory')
self.assertTrue(layer.isValid())
f = QgsFeature()
f.setGeometry(QgsGeometry.fromWkt('Polygon((1 2, 3 2, 3 4, 1 4, 1 2))'))
layer.dataProvider().addFeatures([f])
QgsProject.instance().addMapLayer(layer)
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
w.setOutputExtentFromLayer(layer)
self.assertEqual(w.outputExtent(), QgsRectangle(1, 2, 3, 4))
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:3785'))
self.assertEqual(w.outputExtent().toString(4),
QgsRectangle(111319.4908, 222684.2085, 333958.4724, 445640.1097).toString(4))
# change CRS back
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
# extent should be back to original - not a reprojection of the reprojected bounds
self.assertEqual(w.outputExtent().toString(20), QgsRectangle(1, 2, 3, 4).toString(20))
# custom extent
w = qgis.gui.QgsExtentGroupBox()
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
w.setOutputExtentFromUser(QgsRectangle(1, 2, 3, 4), QgsCoordinateReferenceSystem('epsg:4326'))
self.assertEqual(w.outputExtent(), QgsRectangle(1, 2, 3, 4))
# with reprojection
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:3785'))
self.assertEqual(w.outputExtent().toString(4),
QgsRectangle(111319.4908, 222684.2085, 333958.4724, 445640.1097).toString(4))
# change CRS back
w.setOutputCrs(QgsCoordinateReferenceSystem('epsg:4326'))
# in this case we can't retrieve the original user extent in 4326, so we have a reprojection of the reprojected bounds
# just test this by restricting the test to 4 decimals
self.assertEqual(w.outputExtent().toString(4), QgsRectangle(1, 2, 3, 4).toString(4))
def findChart(self, point, escala):
alpha = string.ascii_uppercase
alphabet = {i: alpha[i - 1] for i in range(1, len(alpha) + 1)}
self.scaleIndex = {
500: {
0: "V",
1: "X",
2: "Y",
3: "Z"
},
250: {
0: "A",
1: "B",
2: "C",
3: "D"
},
100: {
0: "I",
1: "II",
2: "III",
3: "IV",
4: "V",
5: "VI"
},
50: {
0: "1",
1: "2",
2: "3",
3: "4"
},
25: {
0: "NO",
1: "NE",
2: "SO",
3: "SE"
},
10: {
0: "F",
1: "D",
2: "B",
3: "E",
4: "C",
5: "A"
},
5: {
0: "I",
1: "II",
2: "III",
3: "IV"
},
2: {
0: "1",
1: "2",
2: "3",
3: "4",
4: "5",
5: "6"
},
1: {
0: "A",
1: "B",
2: "C",
3: "D"
}
}
nomeFolha = ""
miFolha = ""
scaleX = 6.0
scaleY = 4.0
# 1:1.000.000
hemisferio = 'S' if point.y() < 0 else 'N'
nomeFolha += hemisferio
linha = math.floor(abs(point.y() / 4)) + 1
linhaAlpha = alphabet[linha]
nomeFolha += linhaAlpha
nomeFolha += '-'
fuso = 30 + int(point.x() / 6)
nomeFolha += str(fuso)
# 1:500.000 init
esqFuso = -180 + (fuso - 1) * 6
infFuso = linha * 4
if hemisferio == 'S':
infFuso *= -1
else:
infFuso -= 4
for scales in [500, 250, 100, 50, 25, 10, 5, 2, 1]:
scaleX, scaleY, esqFuso, infFuso, nomeFolha, miFolha = self.scaleFinder(
point, scaleX, scaleY, esqFuso, infFuso, scales, nomeFolha,
miFolha)
if escala == scales:
rect = QgsRectangle(esqFuso, infFuso, esqFuso + scaleX,
infFuso + scaleY)
return (nomeFolha, miFolha, rect)
def testSubsetString(self):
if not self.source.supportsSubsetString():
print('Provider does not support subset strings')
return
changed_spy = QSignalSpy(self.source.dataChanged)
subset = self.getSubsetString()
self.source.setSubsetString(subset)
self.assertEqual(self.source.subsetString(), subset)
self.assertEqual(len(changed_spy), 1)
# No signal should be emitted if the subset string is not modified
self.source.setSubsetString(subset)
self.assertEqual(len(changed_spy), 1)
result = set([f['pk'] for f in self.source.getFeatures()])
all_valid = (all(f.isValid() for f in self.source.getFeatures()))
self.source.setSubsetString(None)
expected = set([2, 3, 4])
assert set(
expected
) == result, 'Expected {} and got {} when testing subset string {}'.format(
set(expected), result, subset)
self.assertTrue(all_valid)
# Subset string AND filter rect
self.source.setSubsetString(subset)
extent = QgsRectangle(-70, 70, -60, 75)
request = QgsFeatureRequest().setFilterRect(extent)
result = set([f['pk'] for f in self.source.getFeatures(request)])
all_valid = (all(f.isValid()
for f in self.source.getFeatures(request)))
self.source.setSubsetString(None)
expected = set([2])
assert set(
expected
) == result, 'Expected {} and got {} when testing subset string {}'.format(
set(expected), result, subset)
self.assertTrue(all_valid)
# Subset string AND filter rect, version 2
self.source.setSubsetString(subset)
extent = QgsRectangle(-71, 65, -60, 80)
result = set([
f['pk'] for f in self.source.getFeatures(
QgsFeatureRequest().setFilterRect(extent))
])
self.source.setSubsetString(None)
expected = set([2, 4])
assert set(
expected
) == result, 'Expected {} and got {} when testing subset string {}'.format(
set(expected), result, subset)
# Subset string AND expression
self.source.setSubsetString(subset)
request = QgsFeatureRequest().setFilterExpression('length("name")=5')
result = set([f['pk'] for f in self.source.getFeatures(request)])
all_valid = (all(f.isValid()
for f in self.source.getFeatures(request)))
self.source.setSubsetString(None)
expected = set([2, 4])
assert set(
expected
) == result, 'Expected {} and got {} when testing subset string {}'.format(
set(expected), result, subset)
self.assertTrue(all_valid)
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
field_name = self.parameterAsString(parameters, self.FIELD, context)
type = self.parameterAsEnum(parameters, self.TYPE, context)
use_field = bool(field_name)
field_index = -1
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 20))
if use_field:
# keep original field type, name and parameters
field_index = source.fields().lookupField(field_name)
if field_index >= 0:
fields.append(source.fields()[field_index])
if type == 0:
# envelope
fields.append(QgsField('width', QVariant.Double, '', 20, 6))
fields.append(QgsField('height', QVariant.Double, '', 20, 6))
fields.append(QgsField('area', QVariant.Double, '', 20, 6))
fields.append(QgsField('perimeter', QVariant.Double, '', 20, 6))
elif type == 1:
# oriented rect
fields.append(QgsField('width', QVariant.Double, '', 20, 6))
fields.append(QgsField('height', QVariant.Double, '', 20, 6))
fields.append(QgsField('angle', QVariant.Double, '', 20, 6))
fields.append(QgsField('area', QVariant.Double, '', 20, 6))
fields.append(QgsField('perimeter', QVariant.Double, '', 20, 6))
elif type == 2:
# circle
fields.append(QgsField('radius', QVariant.Double, '', 20, 6))
fields.append(QgsField('area', QVariant.Double, '', 20, 6))
elif type == 3:
# convex hull
fields.append(QgsField('area', QVariant.Double, '', 20, 6))
fields.append(QgsField('perimeter', QVariant.Double, '', 20, 6))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Polygon, source.sourceCrs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
if field_index >= 0:
geometry_dict = {}
bounds_dict = {}
total = 50.0 / source.featureCount() if source.featureCount() else 1
features = source.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([field_index]))
for current, f in enumerate(features):
if feedback.isCanceled():
break
if not f.hasGeometry():
continue
if type == 0:
# bounding boxes - calculate on the fly for efficiency
if not f[field_index] in bounds_dict:
bounds_dict[f[field_index]] = f.geometry().boundingBox()
else:
bounds_dict[f[field_index]].combineExtentWith(f.geometry().boundingBox())
else:
if not f[field_index] in geometry_dict:
geometry_dict[f[field_index]] = [f.geometry()]
else:
geometry_dict[f[field_index]].append(f.geometry())
feedback.setProgress(int(current * total))
if type == 0:
# bounding boxes
current = 0
total = 50.0 / len(bounds_dict) if bounds_dict else 1
for group, rect in bounds_dict.items():
if feedback.isCanceled():
break
# envelope
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromRect(rect))
feature.setAttributes([current, group, rect.width(), rect.height(), rect.area(), rect.perimeter()])
sink.addFeature(feature, QgsFeatureSink.FastInsert)
geometry_dict[group] = None
feedback.setProgress(50 + int(current * total))
current += 1
else:
current = 0
total = 50.0 / len(geometry_dict) if geometry_dict else 1
for group, geometries in geometry_dict.items():
if feedback.isCanceled():
break
feature = self.createFeature(feedback, current, type, geometries, group)
sink.addFeature(feature, QgsFeatureSink.FastInsert)
geometry_dict[group] = None
feedback.setProgress(50 + int(current * total))
current += 1
else:
total = 80.0 / source.featureCount() if source.featureCount() else 1
features = source.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([]))
geometry_queue = []
bounds = QgsRectangle()
for current, f in enumerate(features):
if feedback.isCanceled():
break
if not f.hasGeometry():
continue
if type == 0:
# bounding boxes, calculate on the fly for efficiency
bounds.combineExtentWith(f.geometry().boundingBox())
else:
geometry_queue.append(f.geometry())
feedback.setProgress(int(current * total))
if not feedback.isCanceled():
if type == 0:
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromRect(bounds))
feature.setAttributes([0, bounds.width(), bounds.height(), bounds.area(), bounds.perimeter()])
else:
feature = self.createFeature(feedback, 0, type, geometry_queue)
sink.addFeature(feature, QgsFeatureSink.FastInsert)
return {self.OUTPUT: dest_id}
def testToRectangle(self):
box = QgsBox3d(5.0, 6.0, 7.0, 11.0, 13.0, 15.0)
rect = box.toRectangle()
self.assertEqual(rect, QgsRectangle(5, 6, 11, 13))
def processAlgorithm(self, parameters, context, feedback):
raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT_DEM,
context)
target_crs = raster_layer.crs()
rasterPath = raster_layer.source()
source = self.parameterAsSource(parameters, self.BOUNDARY_LAYER,
context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.BOUNDARY_LAYER))
step = self.parameterAsDouble(parameters, self.STEP, context)
percentage = self.parameterAsBoolean(parameters, self.USE_PERCENTAGE,
context)
outputPath = self.parameterAsString(parameters, self.OUTPUT_DIRECTORY,
context)
if not os.path.exists(outputPath):
os.makedirs(outputPath)
rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly)
geoTransform = rasterDS.GetGeoTransform()
rasterBand = rasterDS.GetRasterBand(1)
noData = rasterBand.GetNoDataValue()
cellXSize = abs(geoTransform[1])
cellYSize = abs(geoTransform[5])
rasterXSize = rasterDS.RasterXSize
rasterYSize = rasterDS.RasterYSize
rasterBBox = QgsRectangle(geoTransform[0],
geoTransform[3] - cellYSize * rasterYSize,
geoTransform[0] + cellXSize * rasterXSize,
geoTransform[3])
rasterGeom = QgsGeometry.fromRect(rasterBBox)
crs = osr.SpatialReference()
crs.ImportFromProj4(str(target_crs.toProj4()))
memVectorDriver = ogr.GetDriverByName('Memory')
memRasterDriver = gdal.GetDriverByName('MEM')
features = source.getFeatures(QgsFeatureRequest().setDestinationCrs(
target_crs, context.transformContext()))
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if not f.hasGeometry():
continue
if feedback.isCanceled():
break
geom = f.geometry()
intersectedGeom = rasterGeom.intersection(geom)
if intersectedGeom.isEmpty():
feedback.pushInfo(
self.tr('Feature {0} does not intersect raster or '
'entirely located in NODATA area').format(f.id()))
continue
fName = os.path.join(
outputPath,
'histogram_{}_{}.csv'.format(source.sourceName(), f.id()))
ogrGeom = ogr.CreateGeometryFromWkt(intersectedGeom.asWkt())
bbox = intersectedGeom.boundingBox()
xMin = bbox.xMinimum()
xMax = bbox.xMaximum()
yMin = bbox.yMinimum()
yMax = bbox.yMaximum()
(startColumn,
startRow) = raster.mapToPixel(xMin, yMax, geoTransform)
(endColumn, endRow) = raster.mapToPixel(xMax, yMin, geoTransform)
width = endColumn - startColumn
height = endRow - startRow
srcOffset = (startColumn, startRow, width, height)
srcArray = rasterBand.ReadAsArray(*srcOffset)
if srcOffset[2] == 0 or srcOffset[3] == 0:
feedback.pushInfo(
self.tr('Feature {0} is smaller than raster '
'cell size').format(f.id()))
continue
newGeoTransform = (geoTransform[0] +
srcOffset[0] * geoTransform[1], geoTransform[1],
0.0, geoTransform[3] +
srcOffset[1] * geoTransform[5], 0.0,
geoTransform[5])
memVDS = memVectorDriver.CreateDataSource('out')
memLayer = memVDS.CreateLayer('poly', crs, ogr.wkbPolygon)
ft = ogr.Feature(memLayer.GetLayerDefn())
ft.SetGeometry(ogrGeom)
memLayer.CreateFeature(ft)
ft.Destroy()
rasterizedDS = memRasterDriver.Create('', srcOffset[2],
srcOffset[3], 1,
gdal.GDT_Byte)
rasterizedDS.SetGeoTransform(newGeoTransform)
gdal.RasterizeLayer(rasterizedDS, [1], memLayer, burn_values=[1])
rasterizedArray = rasterizedDS.ReadAsArray()
srcArray = numpy.nan_to_num(srcArray)
masked = numpy.ma.MaskedArray(
srcArray,
mask=numpy.logical_or(srcArray == noData,
numpy.logical_not(rasterizedArray)))
self.calculateHypsometry(f.id(), fName, feedback, masked,
cellXSize, cellYSize, percentage, step)
memVDS = None
rasterizedDS = None
feedback.setProgress(int(current * total))
rasterDS = None
return {self.OUTPUT_DIRECTORY: outputPath}
def testMapTheme(self):
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
# add a polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer.dataProvider().addFeatures([f]))
# create a style
sym1 = QgsFillSymbol.createSimple({'color': '#ffb200'})
renderer = QgsSingleSymbolRenderer(sym1)
layer.setRenderer(renderer)
canvas.setLayers([layer])
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add some styles
layer.styleManager().addStyleFromLayer('style1')
sym2 = QgsFillSymbol.createSimple({'color': '#00b2ff'})
renderer2 = QgsSingleSymbolRenderer(sym2)
layer.setRenderer(renderer2)
layer.styleManager().addStyleFromLayer('style2')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme2', 'theme2', canvas))
layer.styleManager().setCurrentStyle('style1')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# OK, so all good with setting/rendering map styles
# try setting canvas to a particular theme
# make some themes...
theme1 = QgsMapThemeCollection.MapThemeRecord()
record1 = QgsMapThemeCollection.MapThemeLayerRecord(layer)
record1.currentStyle = 'style1'
record1.usingCurrentStyle = True
theme1.setLayerRecords([record1])
theme2 = QgsMapThemeCollection.MapThemeRecord()
record2 = QgsMapThemeCollection.MapThemeLayerRecord(layer)
record2.currentStyle = 'style2'
record2.usingCurrentStyle = True
theme2.setLayerRecords([record2])
QgsProject.instance().mapThemeCollection().insert('theme1', theme1)
QgsProject.instance().mapThemeCollection().insert('theme2', theme2)
canvas.setTheme('theme2')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme2', 'theme2', canvas))
canvas.setTheme('theme1')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add another layer
layer2 = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer2", "memory")
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer2.dataProvider().addFeatures([f]))
# create a style
sym1 = QgsFillSymbol.createSimple({'color': '#b2ff00'})
renderer = QgsSingleSymbolRenderer(sym1)
layer2.setRenderer(renderer)
# rerender canvas - should NOT show new layer
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# test again - this time refresh all layers
canvas.refreshAllLayers()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add layer 2 to theme1
record3 = QgsMapThemeCollection.MapThemeLayerRecord(layer2)
theme1.setLayerRecords([record3])
QgsProject.instance().mapThemeCollection().update('theme1', theme1)
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme3', 'theme3', canvas))
# change the appearance of an active style
layer2.styleManager().addStyleFromLayer('original')
layer2.styleManager().addStyleFromLayer('style4')
record3.currentStyle = 'style4'
record3.usingCurrentStyle = True
theme1.setLayerRecords([record3])
QgsProject.instance().mapThemeCollection().update('theme1', theme1)
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme3', 'theme3', canvas))
layer2.styleManager().setCurrentStyle('style4')
sym3 = QgsFillSymbol.createSimple({'color': '#b200b2'})
layer2.renderer().setSymbol(sym3)
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme4', 'theme4', canvas))
# try setting layers while a theme is in place
canvas.setLayers([layer])
canvas.refresh()
# should be no change... setLayers should be ignored if canvas is following a theme!
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme4', 'theme4', canvas))
# setLayerStyleOverrides while theme is in place
canvas.setLayerStyleOverrides({layer2.id(): 'original'})
# should be no change... setLayerStyleOverrides should be ignored if canvas is following a theme!
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme4', 'theme4', canvas))
# clear theme
canvas.setTheme('')
canvas.refresh()
canvas.waitWhileRendering()
# should be different - we should now render project layers
self.assertFalse(self.canvasImageCheck('theme4', 'theme4', canvas))
def processAlgorithm(self, feedback):
extent = self.getParameterValue(self.EXTENT).split(',')
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
hOverlay = self.getParameterValue(self.HOVERLAY)
vOverlay = self.getParameterValue(self.VOVERLAY)
crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS))
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
width = bbox.width()
height = bbox.height()
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: {0}/{1}').format(
hSpacing, vSpacing))
if hSpacing <= hOverlay or vSpacing <= vOverlay:
raise GeoAlgorithmExecutionException(
self.tr('Invalid overlay: {0}/{1}').format(hOverlay, vOverlay))
if width < hSpacing:
raise GeoAlgorithmExecutionException(
self.tr(
'Horizontal spacing is too small for the covered area'))
if height < vSpacing:
raise GeoAlgorithmExecutionException(
self.tr('Vertical spacing is too small for the covered area'))
fields = [
QgsField('left', QVariant.Double, '', 24, 16),
QgsField('top', QVariant.Double, '', 24, 16),
QgsField('right', QVariant.Double, '', 24, 16),
QgsField('bottom', QVariant.Double, '', 24, 16),
QgsField('id', QVariant.Int, '', 10, 0),
QgsField('coord', QVariant.Double, '', 24, 15)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.LineString, crs)
if hOverlay > 0:
hSpace = [hSpacing - hOverlay, hOverlay]
else:
hSpace = [hSpacing, hSpacing]
if vOverlay > 0:
vSpace = [vSpacing - vOverlay, vOverlay]
else:
vSpace = [vSpacing, vSpacing]
feat = QgsFeature()
feat.initAttributes(len(fields))
count = 0
id = 1
# latitude lines
count_max = height / vSpacing
count_update = count_max * 0.10
y = bbox.yMaximum()
while y >= bbox.yMinimum():
pt1 = QgsPointV2(bbox.xMinimum(), y)
pt2 = QgsPointV2(bbox.xMaximum(), y)
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([bbox.xMinimum(), y, bbox.xMaximum(), y, id, y])
writer.addFeature(feat)
y = y - vSpace[count % 2]
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(int(count / count_max * 50))
feedback.setProgress(50)
# longitude lines
# counters for progressbar - update every 5%
count = 0
count_max = width / hSpacing
count_update = count_max * 0.10
x = bbox.xMinimum()
while x <= bbox.xMaximum():
pt1 = QgsPointV2(x, bbox.yMaximum())
pt2 = QgsPointV2(x, bbox.yMinimum())
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([x, bbox.yMaximum(), x, bbox.yMinimum(), id, x])
writer.addFeature(feat)
x = x + hSpace[count % 2]
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(50 + int(count / count_max * 50))
del writer
def testRefreshOnTimer(self):
""" test that map canvas refreshes with auto refreshing layers """
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
canvas.setLayers([layer])
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('empty_canvas', 'empty_canvas', canvas))
# add polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer.dataProvider().addFeatures([f]))
# set auto refresh on layer
layer.setAutoRefreshInterval(100)
layer.setAutoRefreshEnabled(True)
timeout = time.time() + 1
# expect canvas to auto refresh...
while not canvas.isDrawing():
app.processEvents()
self.assertTrue(time.time() < timeout)
while canvas.isDrawing():
app.processEvents()
self.assertTrue(time.time() < timeout)
# add a polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer.dataProvider().addFeatures([f]))
# wait for canvas auto refresh
while not canvas.isDrawing():
app.processEvents()
self.assertTrue(time.time() < timeout)
while canvas.isDrawing():
app.processEvents()
self.assertTrue(time.time() < timeout)
# now canvas should look different...
self.assertFalse(self.canvasImageCheck('empty_canvas', 'empty_canvas', canvas))
# switch off auto refresh
layer.setAutoRefreshEnabled(False)
timeout = time.time() + 0.5
while time.time() < timeout:
# messy, but only way to check that canvas redraw doesn't occur
self.assertFalse(canvas.isDrawing())
def run_checks():
self.assertEqual([f.name() for f in vl.fields()],
['fid', 'type', 'value'])
# expression
req = QgsFeatureRequest()
req.setFilterExpression("value=16")
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter fid
req = QgsFeatureRequest()
req.setFilterFid(5)
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter fids
req = QgsFeatureRequest()
req.setFilterFids([5])
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# check with subset of attributes
req = QgsFeatureRequest()
req.setFilterFids([5])
req.setSubsetOfAttributes([2])
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes()[2], 16)
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter rect and expression
req = QgsFeatureRequest()
req.setFilterExpression("value=16 or value=14")
req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5))
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter rect and fids
req = QgsFeatureRequest()
req.setFilterFids([3, 5])
req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5))
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed
req = QgsFeatureRequest()
req.setSubsetOfAttributes([])
it = vl.getFeatures(req)
ids = []
geoms = {}
while it.nextFeature(f):
ids.append(f.id())
geoms[f.id()] = f.geometry().asWkt()
self.assertCountEqual(ids, [3, 4, 5])
self.assertEqual(geoms, {
3: 'Point (3 3)',
4: 'Point (4 4)',
5: 'Point (5 5)'
})
def prepare_task(self, items):
"""Prepare scenario for impact function variable.
:param items: Dictionary containing settings for impact function.
:type items: Python dictionary.
:return: A tuple containing True and dictionary containing parameters
if post processor success. Or False and an error message
if something went wrong.
"""
status = True
message = ''
# get hazard
if 'hazard' in items:
hazard_path = items['hazard']
hazard = self.define_layer(hazard_path)
if not hazard:
status = False
message = self.tr(
'Unable to find {hazard_path}').format(
hazard_path=hazard_path)
else:
hazard = None
LOGGER.warning('Scenario does not contain hazard path')
# get exposure
if 'exposure' in items:
exposure_path = items['exposure']
exposure = self.define_layer(exposure_path)
if not exposure:
status = False
if message:
message += '\n'
message += self.tr(
'Unable to find {exposure_path}').format(
exposure_path=exposure_path)
else:
exposure = None
LOGGER.warning('Scenario does not contain hazard path')
# get aggregation
if 'aggregation' in items:
aggregation_path = items['aggregation']
aggregation = self.define_layer(aggregation_path)
else:
aggregation = None
LOGGER.info('Scenario does not contain aggregation path')
# get extent
if 'extent' in items:
LOGGER.info('Extent coordinate is found')
coordinates = items['extent']
array_coord = extent_string_to_array(coordinates)
extent = QgsRectangle(*array_coord)
else:
extent = None
LOGGER.info('Scenario does not contain extent coordinates')
# get extent crs id
if 'extent_crs' in items:
LOGGER.info('Extent CRS is found')
crs = items['extent_crs']
extent_crs = QgsCoordinateReferenceSystem(crs)
else:
LOGGER.info('Extent crs is not found, assuming crs to EPSG:4326')
extent_crs = QgsCoordinateReferenceSystem('EPSG:4326')
# make sure at least hazard and exposure data are available in
# scenario. Aggregation and extent checking will be done when
# assigning layer to impact_function
if status:
parameters = {
layer_purpose_hazard['key']: hazard,
layer_purpose_exposure['key']: exposure,
layer_purpose_aggregation['key']: aggregation,
'extent': extent,
'crs': extent_crs
}
return True, parameters
else:
LOGGER.warning(message)
display_critical_message_box(
title=self.tr('Error while preparing scenario'),
message=message)
return False, None
def load_template(self):
"""Load a QgsComposer map from a template.
:raises: TemplateElementMissingError - when template elements are
missing
"""
template_file = QtCore.QFile(self.template)
template_file.open(QtCore.QIODevice.ReadOnly | QtCore.QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QtXml.QDomDocument()
document.setContent(template_content)
# get information for substitutions
# date, time and plugin version
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
if date_time is None:
date = ''
time = ''
else:
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
title = self.map_title()
if not title:
title = ''
substitution_map = {
'impact-title': title,
'date': date,
'time': time,
'safe-version': version,
'disclaimer': self.disclaimer
}
LOGGER.debug(substitution_map)
load_ok = self.composition.loadFromTemplate(document, substitution_map)
if not load_ok:
raise ReportCreationError(
self.tr('Error loading template %s') % self.template)
self.page_width = self.composition.paperWidth()
self.page_height = self.composition.paperHeight()
# set InaSAFE logo
image = self.composition.getComposerItemById('safe-logo')
if image is not None:
image.setPictureFile(self.safe_logo)
# set north arrow
image = self.composition.getComposerItemById('north-arrow')
if image is not None:
image.setPictureFile(self.north_arrow)
# set organisation logo
image = self.composition.getComposerItemById('organisation-logo')
if image is not None:
image.setPictureFile(self.org_logo)
# set impact report table
table = self.composition.getComposerItemById('impact-report')
if table is not None:
text = self.keyword_io.read_keywords(self.layer, 'impact_summary')
if text is None:
text = ''
table.setText(text)
table.setHtmlState(1)
# Get the main map canvas on the composition and set
# its extents to the event.
composer_map = self.composition.getComposerItemById('impact-map')
if composer_map is not None:
# Recenter the composer map on the center of the extent
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.extent
width = canvas_extent.width()
height = canvas_extent.height()
longest_width = width
if width < height:
longest_width = height
half_length = longest_width / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
composer_map.setNewExtent(square_extent)
# calculate intervals for grid
split_count = 5
x_interval = square_extent.width() / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = square_extent.height() / split_count
composer_map.setGridIntervalY(y_interval)
legend = self.composition.getComposerItemById('impact-legend')
if legend is not None:
legend_attributes = self.map_legend_attributes()
LOGGER.debug(legend_attributes)
# legend_notes = mapLegendAttributes.get('legend_notes', None)
# legend_units = mapLegendAttributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
symbol_count = 1
if self.layer.type() == QgsMapLayer.VectorLayer:
renderer = self.layer.rendererV2()
if renderer.type() in ['', '']:
symbol_count = len(self.layer.legendSymbologyItems())
else:
renderer = self.layer.renderer()
if renderer.type() in ['']:
symbol_count = len(self.layer.legendSymbologyItems())
if symbol_count <= 5:
legend.setColumnCount(1)
else:
legend.setColumnCount(symbol_count / 5 + 1)
if legend_title is None:
legend_title = ""
legend.setTitle(legend_title)
legend.updateLegend()
# Set Legend
# From QGIS 2.6, legend.model() is obsolete
if qgis_version() < 20600:
legend.model().setLayerSet([self.layer.id()])
legend.synchronizeWithModel()
else:
root_group = legend.modelV2().rootGroup()
root_group.addLayer(self.layer)
legend.synchronizeWithModel()
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(
os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsProject.instance().addMapLayers([mVectorLayer])
self.layers = [mVectorLayer]
# create layout with layout map
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
QgsProject.instance().setCrs(crs)
self.layout = QgsPrintLayout(QgsProject.instance())
self.layout.initializeDefaults()
# fix the renderer, fill with green
props = {"color": "0,127,0", 'outline_color': 'black'}
fillSymbol = QgsFillSymbol.createSimple(props)
renderer = QgsSingleSymbolRenderer(fillSymbol)
mVectorLayer.setRenderer(renderer)
# the atlas map
self.atlas_map = QgsLayoutItemMap(self.layout)
self.atlas_map.attemptSetSceneRect(QRectF(20, 20, 130, 130))
self.atlas_map.setFrameEnabled(True)
self.atlas_map.setLayers([mVectorLayer])
self.layout.addLayoutItem(self.atlas_map)
# the atlas
self.atlas = self.layout.atlas()
self.atlas.setCoverageLayer(mVectorLayer)
self.atlas.setEnabled(True)
# an overview
self.overview = QgsLayoutItemMap(self.layout)
self.overview.attemptSetSceneRect(QRectF(180, 20, 50, 50))
self.overview.setFrameEnabled(True)
self.overview.overview().setLinkedMap(self.atlas_map)
self.overview.setLayers([mVectorLayer])
self.layout.addLayoutItem(self.overview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
self.overview.setExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127", 'outline_color': 'black'}
fillSymbol2 = QgsFillSymbol.createSimple(props2)
self.overview.overview().setFrameSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsLayoutItemLabel(self.layout)
self.layout.addLayoutItem(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.attemptSetSceneRect(QRectF(150, 5, 60, 15))
self.mLabel1.setMarginX(1)
self.mLabel1.setMarginY(1)
# feature number label
self.mLabel2 = QgsLayoutItemLabel(self.layout)
self.layout.addLayoutItem(self.mLabel2)
self.mLabel2.setText(
"# [%@atlas_featurenumber || ' / ' || @atlas_totalfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.attemptSetSceneRect(QRectF(150, 200, 60, 15))
self.mLabel2.setMarginX(1)
self.mLabel2.setMarginY(1)
self.filename_test()
self.autoscale_render_test()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
self.rotation_test()
shutil.rmtree(tmppath, True)
def test_resetSnappingIndex(self):
self.pointsLayer.setDependencies([])
self.linesLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
ms = QgsMapSettings()
ms.setOutputSize(QSize(100, 100))
ms.setExtent(QgsRectangle(0, 0, 1, 1))
self.assertTrue(ms.hasValidSettings())
u = QgsSnappingUtils()
u.setMapSettings(ms)
cfg = u.config()
cfg.setEnabled(True)
cfg.setMode(QgsSnappingConfig.AdvancedConfiguration)
cfg.setIndividualLayerSettings(
self.pointsLayer,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex,
20, QgsTolerance.Pixels))
u.setConfig(cfg)
m = u.snapToMap(QPoint(95, 100))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPointXY(1, 0))
f = QgsFeature(self.linesLayer.fields())
f.setId(1)
geom = QgsGeometry.fromWkt("LINESTRING(0 0,1 1)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
l1 = len([f for f in self.pointsLayer.getFeatures()])
self.assertEqual(l1, 4)
m = u.snapToMap(QPoint(95, 0))
# snapping not updated
self.pointsLayer.setDependencies([])
self.assertEqual(m.isValid(), False)
# set layer dependencies
self.pointsLayer.setDependencies(
[QgsMapLayerDependency(self.linesLayer.id())])
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setId(2)
geom = QgsGeometry.fromWkt("LINESTRING(0 0,0.5 0.5)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the snapped point is ok
m = u.snapToMap(QPoint(45, 50))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPointXY(0.5, 0.5))
self.pointsLayer.setDependencies([])
# test chained layer dependencies A -> B -> C
cfg.setIndividualLayerSettings(
self.pointsLayer2,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex,
20, QgsTolerance.Pixels))
u.setConfig(cfg)
self.pointsLayer.setDependencies(
[QgsMapLayerDependency(self.linesLayer.id())])
self.pointsLayer2.setDependencies(
[QgsMapLayerDependency(self.pointsLayer.id())])
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setId(3)
geom = QgsGeometry.fromWkt("LINESTRING(0 0.2,0.5 0.8)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the second snapped point is ok
m = u.snapToMap(QPoint(75, 100 - 80))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPointXY(0.7, 0.8))
self.pointsLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
def testReprojectionErrorsWhileRendering(self):
# WKT of a polygon which causes reprojection errors while rendering
# (apologies for the ridiculously complex wkt, but I can't find a way to reproduce with simplifiction)
wkt = 'MultiPolygon (((16.93392988400009358 42.77094147300012139, 16.88493899800005238 42.72939687700012712, ' \
'16.80298912900011032 42.76349518400014915, 16.85816491000014139 42.78400299700011544, ' \
'16.93392988400009358 42.77094147300012139)),((17.38200931100010393 42.79783763200002511, ' \
'17.65894616000011297 42.74298737200008702, 17.74887129000009622 42.69456614800010641, ' \
'17.32374108200008322 42.79083893400003547, 17.38200931100010393 42.79783763200002511)),' \
'((16.768565300000148 42.97223541900014254, 17.03207441500009622 42.98261139500014849, ' \
'17.13184655000009116 42.96954987200014386, 17.20020592500009116 42.92177969000012183, ' \
'16.85141035200010151 42.90070221600008438, 16.65544681100004709 42.92625560099999404, ' \
'16.70679772200014668 42.96954987200014386, 16.63168379000003938 42.98261139500014849, ' \
'16.768565300000148 42.97223541900014254)),((17.05567467500011958 43.02895742400001211, ' \
'17.24024498800011429 43.02277252800014651, 17.74146569100011561 42.83926015800001608, ' \
'17.70736738400009358 42.88703034100014122, 17.65334906206413734 42.8909283361407887, ' \
'17.70158573400010482 42.91950022500007833, 17.81175988700005064 42.909862570000044, ' \
'17.85847538200005147 42.81697418200012351, 18.22413781700009849 42.62807098500009317, ' \
'18.43735477700010961 42.55921213800017711, 18.4371480710000526 42.4934022020000981, ' \
'18.49642988400009358 42.41632721600008438, 18.23894290500010129 42.55906810100005089, ' \
'18.21753991000014139 42.6201032570001388, 18.07601972700010151 42.65131256700003348, ' \
'18.0432235040000819 42.70205312700007028, 17.90162194100014403 42.75189850500014188, ' \
'17.8928328790000819 42.79083893400003547, 17.72095787900005348 42.8262393250000315, ' \
'17.7618921230000808 42.77871328300012976, 17.74870853000004445 42.77204010600017625, ' \
'17.21387780000011958 42.98261139500014849, 17.04615319100011561 42.9950625670000619, ' \
'17.00163821700004974 43.05149974200010377, 17.05567467500011958 43.02895742400001211)),' \
'((16.19467207100007045 43.07440827000000638, 16.254893425000148 43.06854889500006323, ' \
'16.08716881600014403 43.01146067900008063, 16.04883873800011429 43.06517161700004692, ' \
'16.19467207100007045 43.07440827000000638)),((16.56275475400011032 43.22898997600010773, ' \
'16.65951582100009887 43.21596914300012315, 16.72771243600001867 43.16461823100003414, ' \
'17.19336998800014271 43.12726471600016964, 16.67017662900013875 43.12547435099999404, ' \
'16.37159264400014536 43.19550202000006323, 16.49642988400006516 43.21808502800014651, ' \
'16.58326256600014403 43.18866608300005794, 16.52051842500006273 43.22898997600010773, ' \
'16.56275475400011032 43.22898997600010773)),((16.80681399800010922 43.34247467700005529, ' \
'16.89234459700011826 43.31220123900006058, 16.84620201900008851 43.27338288000005662, ' \
'16.62826582100012729 43.26373932500008834, 16.50074303500014139 43.28424713700003679, ' \
'16.42188561300008587 43.31757233300011478, 16.40577233200011165 43.33270905200011214, ' \
'16.45346113400009358 43.35317617400009738, 16.42628014400008851 43.39411041900011412, ' \
'16.44703209700008983 43.39484284100014122, 16.80681399800010922 43.34247467700005529)),' \
'((16.29818769600012729 43.40363190300011809, 16.30274498800008587 43.38727448100009099, ' \
'16.39144941500012465 43.34638092700005529, 16.348643425000148 43.33869049700003018, ' \
'16.20045006600014403 43.40704987200003018, 16.29818769600012729 43.40363190300011809)),' \
'((16.33415774800010922 43.50153229400014254, 16.3752547540000819 43.49017975500008504, ' \
'16.21143639400008851 43.49005768400009231, 16.26441491000014139 43.51288483300011478, ' \
'16.33415774800010922 43.50153229400014254)),((15.67888431100004709 43.64801666900014254, ' \
'15.74040774800010922 43.62750885600009099, 15.67204837300002396 43.63743724200010377, ' \
'15.60377037900013875 43.67470937700007028, 15.67888431100004709 43.64801666900014254)),' \
'((15.36736087300005238 43.79010651200015047, 15.39568118600007551 43.7724063170000619, ' \
'15.22779381600014403 43.87445709800014981, 15.24073326900014536 43.88076406500009341, ' \
'15.36736087300005238 43.79010651200015047)),((15.44271894600009887 43.89907461100013109, ' \
'15.35865319100014403 43.91937897300014981, 15.26124108200011165 44.01105377800003282, ' \
'15.38404381600008719 43.9701602230000077, 15.44271894600009887 43.89907461100013109)),' \
'((15.22575931100010393 44.06622955900014915, 15.25440514400008851 44.01788971600014122, ' \
'15.12183678500014139 44.09223053600005926, 15.06251061300008587 44.16193268400012073, ' \
'15.22575931100010393 44.06622955900014915)),((14.83545983200014007 44.15102773600013109, ' \
'14.85726972700010151 44.15204498900000374, 14.86915123800014271 44.14052969000006499, ' \
'14.83521569100008719 44.14166901200009363, 14.81983483200014007 44.15302155199999845, ' \
'14.82243899800005238 44.16868724200004692, 14.83545983200014007 44.15102773600013109)),' \
'((14.98511803500011297 44.09096914300012315, 15.21680748800008587 43.91278717700008372, ' \
'15.13331139400011693 43.92121002800003282, 15.19450931100004709 43.87262604400017096, ' \
'15.10661868600007551 43.92544179900015422, 14.84961998800014271 44.17560455900014915, ' \
'14.98511803500011297 44.09096914300012315)),((14.765961134000122 44.26504140800015819, ' \
'14.74854576900014536 44.26166413000014188, 14.73959394600012729 44.28017812700015554, ' \
'14.79167728000007287 44.27252838700003679, 14.765961134000122 44.26504140800015819)),' \
'((14.66138756600011561 44.30866120000014519, 14.6407983730000808 44.31183502800003282, ' \
'14.59506269600007045 44.34711334800006455, 14.643565300000148 44.32575104400011412, ' \
'14.66138756600011561 44.30866120000014519)),((14.81120853000004445 44.35004303600000242, ' \
'14.75619550900009358 44.36399974200004692, 14.76343834700008983 44.41535065300017493, ' \
'14.80323326900008851 44.40550364800004957, 14.81120853000004445 44.35004303600000242)),' \
'((14.27116946700002131 44.61253489800004957, 14.23259524800005238 44.62604401200012205, ' \
'14.2657983730000808 44.67951080900003547, 14.28044681100007551 44.67755768400009231, ' \
'14.27116946700002131 44.61253489800004957)),((14.84522545700008322 44.60053131700011875, ' \
'14.93824303500014139 44.59414297100001079, 15.07553144600007045 44.48407623900006058, ' \
'14.91114342500011958 44.54547760600014783, 15.04802493600004709 44.43943919500001982, ' \
'15.09669030000009116 44.41518789300000947, 15.04151451900014536 44.47662995000008834, ' \
'15.25440514400008851 44.34003327000000638, 15.165049675000148 44.36737702000006323, ' \
'15.22022545700008322 44.3127302100001117, 15.13086998800008587 44.33258698100003414, ' \
'15.17237389400014536 44.29913971600016964, 15.12875410200007309 44.31199778900018771, ' \
'15.08920332100009887 44.37421295800000109, 15.11719811300014271 44.38719310099999404, ' \
'15.04900149800010922 44.39468008000015686, 14.89747155000009116 44.49091217699999845, ' \
'14.91863040500010129 44.50454336100013109, 14.87696373800011429 44.55975983300005794, ' \
'14.73365319100008719 44.70319245000014519, 14.84522545700008322 44.60053131700011875)),' \
'((14.41000410200010151 44.60097890800001608, 14.52662194100011561 44.50372955900012073, ' \
'14.53435306100010393 44.48407623900006058, 14.42261803500008455 44.57387929900009738, ' \
'14.36304772200014668 44.57343170800000109, 14.38257897200014668 44.60325755399999537, ' \
'14.33578535200007309 44.71678294500010509, 14.39747155000009116 44.6856143250000315, ' \
'14.41000410200010151 44.60097890800001608)),((14.75326582100007045 44.84585195500012844, ' \
'14.74048912900011032 44.82050202000000638, 14.82243899800005238 44.77142975500005662, ' \
'14.84961998800014271 44.70319245000014519, 14.65788821700004974 44.79877350500014188, ' \
'14.7268172540000819 44.79877350500014188, 14.6858016290000819 44.8471540390000456, ' \
'14.75326582100007045 44.84585195500012844)),((14.47103925900006516 44.95392487200003018, ' \
'14.45191491000008455 44.79877350500014188, 14.47217858200011165 44.7079531920000619, ' \
'14.53435306100010393 44.63426341400010244, 14.51335696700007816 44.618841864000089, ' \
'14.42790774800005238 44.65656159100014122, 14.29420006600008719 44.9086367860001161, ' \
'14.30152428500011297 44.94342682500014519, 14.38738040500004445 44.90900299700003018, ' \
'14.39031009200004974 44.96039459800012139, 14.41138756600008719 44.95636627800014651, ' \
'14.27849368600004709 45.1133487000000315, 14.29957116000014139 45.16233958499999801, ' \
'14.35621178500014139 45.16925690300008966, 14.387705925000148 45.03904857000013351, ' \
'14.47103925900006516 44.95392487200003018)),((14.56332441500012465 45.24974192900008063, ' \
'14.62378991000011297 45.17548248900006058, 14.59742272200011826 45.16644928600005926, ' \
'14.66529381600011561 45.16181061400011743, 14.66529381600011561 45.08734772300006455, ' \
'14.74048912900011032 45.07306549700014386, 14.81495201900008851 44.97748444200009033, ' \
'14.70639082100009887 44.9467227230000077, 14.62891686300014271 44.97817617400004053, ' \
'14.62086022200008983 45.04559967700011214, 14.61695397200008983 45.02464427300007799, ' \
'14.51050866000014139 45.03217194200011875, 14.43873131600014403 45.07050202000006323, ' \
'14.4670516290000819 45.12409088700015047, 14.53012129000009622 45.13483307500014519, ' \
'14.53435306100010393 45.23753489800002114, 14.56332441500012465 45.24974192900008063)),' \
'((16.36947066200013978 46.54057118800012915, 16.63767134600004738 46.47447703100009164, ' \
'16.75508020000012266 46.38187286400001597, 16.83765913900006694 46.38187286400001597, ' \
'16.88923221800007468 46.29216257800014489, 17.05294315600005461 46.15346303300005104, ' \
'17.20859257000006437 46.11656606000003933, 17.27587528500004055 46.01202463800002818, ' \
'17.31680301900004793 45.99765859000002877, 17.29013798000011093 45.98463612900009423, ' \
'17.40620324700006449 45.94365671800015605, 17.59110152100009827 45.93621531200012953, ' \
'17.65652388500006964 45.84541982000014571, 17.80917606600013414 45.81441396100005647, ' \
'17.85806197100004056 45.77172922800004073, 18.21121870900006456 45.78537180600012846, ' \
'18.40438521300006869 45.74180857400001798, 18.57347049900010916 45.81668772400014689, ' \
'18.6556360270001278 45.90758656800015558, 18.7755253500000947 45.88283355700004051, ' \
'18.90130578600007993 45.93120269800006383, 18.87288374800004931 45.89523590100002082, ' \
'18.90699019400011593 45.86795074500018643, 18.85531376100007606 45.85735707600009903, ' \
'18.84497847500006174 45.8157058720000947, 18.96848514800012708 45.66873809800016204, ' \
'18.90357954900008508 45.57308502200005762, 18.94171675700005153 45.53892689999999277, ' \
'19.01809452300011571 45.56740061400002162, 19.10625451700005328 45.51164174500017623, ' \
'19.00961958800010621 45.49867095900005154, 19.00300500400010151 45.45536611000007099, ' \
'19.03742150900006891 45.42229319300010104, 18.97592655400006834 45.39495636000008005, ' \
'19.09199182100007874 45.34999786400005917, 19.12475467900009107 45.29811472600006539, ' \
'19.36308638500014467 45.24824696900010679, 19.40783817500010855 45.20313344400013023, ' \
'19.39068160000005037 45.16933705700016333, 19.22593713300008744 45.16194732700016345, ' \
'19.12186079900010327 45.195795390000157, 19.13767378700009658 45.14603098600004216, ' \
'19.04486291500009543 45.13724599300006446, 19.08227665200013234 45.08494944300004192, ' \
'19.0872375890000967 44.97710072800013847, 19.13167932100006396 44.95317454000003465, ' \
'19.06667036900009293 44.90568389900012392, 18.99142948400006503 44.9149339800001286, ' \
'19.01582076000008215 44.86563466400004074, 18.88962691200009658 44.86119049100013001, ' \
'18.78338016700013213 44.91374542300012251, 18.79175174900009893 45.00154368100008639, ' \
'18.73831831900008638 45.0159097290000858, 18.68405806500004473 45.08479441400000098, ' \
'18.64871138500012648 45.06267689999999959, 18.61667199700013953 45.09766184500010411, ' \
'18.54959598800010667 45.09476796500011631, 18.51703983500007666 45.05585561200003042, ' \
'18.23788374800011525 45.15745147700012296, 18.15365116400005263 45.0975584930001645, ' \
'18.00347945100011771 45.1493382780000303, 17.83573775200005684 45.0644338990000648, ' \
'17.68473921700012852 45.1639627080000281, 17.48185754400009273 45.11440500900012296, ' \
'17.49622359200009214 45.1416901650001563, 17.44775109900012922 45.13430043600014585, ' \
'17.44330692500011537 45.16205068000009248, 17.38243208800008688 45.1396231090000839, ' \
'17.26895064300006766 45.18954254200015441, 17.24548954300007608 45.15538442000017483, ' \
'17.18709517400012032 45.14856313100001728, 17.0363033440001459 45.23047027600007652, ' \
'17.00829471800011561 45.21615590500009318, 17.00829471800011561 45.24416453100009505, ' \
'16.94731652900014751 45.23568959600000028, 16.9243721930001243 45.28452382500016427, ' \
'16.81171757000004163 45.18122263700009, 16.52894413300009546 45.22225372400005483, ' \
'16.38921106000003647 45.11683380099999852, 16.31624393700010955 45.00123362300008978, ' \
'16.12152714000009723 45.09616322900008356, 16.02044803900011516 45.213933818000001, ' \
'15.79234826700013627 45.18980092400012438, 15.76361617000014803 44.97555043600003444, ' \
'15.7308533120001357 44.92723297200008403, 15.77343469200010873 44.84501576800015243, ' \
'15.71607385200013596 44.80320953400008932, 15.72847619600008784 44.76910308800002269, ' \
'15.80568078600006743 44.69665273000013883, 15.88877648900006534 44.72424794500012979, ' \
'15.96897831200004703 44.63924021400013942, 16.02830285600006732 44.62471913700009907, ' \
'16.04473596200011798 44.58937245700018082, 16.00608199000004106 44.54100331600012908, ' \
'16.11646285000011858 44.52146962500013672, 16.15966434700004584 44.41610138000002905, ' \
'16.13827030500004867 44.37760243800015303, 16.20286584400008678 44.35977406800010669, ' \
'16.18756962000011868 44.28241444999999032, 16.21578495300011014 44.20815541600011045, ' \
'16.32688928200008149 44.08237498000012522, 16.50103885900011846 43.99271637000008184, ' \
'16.67859908100004418 43.8406843060001421, 16.71260217300007866 43.77151540100005889, ' \
'17.03051558500007445 43.54847991900005866, 17.27050093600007585 43.46321380700000248, ' \
'17.28993127500007176 43.3034302780000786, 17.44206669100009321 43.15243174300015028, ' \
'17.6284119050001209 43.04657257100008394, 17.66272505700004558 42.96569895500012137, ' \
'17.63450972400008254 42.950402731000068, 17.51563561300008587 42.95888906500012183, ' \
'17.47087649800005238 43.01341380400010905, 17.50196373800014271 43.03099192900005221, ' \
'17.43360436300014271 43.01740143400009231, 17.46021569100011561 43.03099192900005221, ' \
'17.42611738400009358 43.06517161700004692, 17.4045516290000819 43.05149974200010377, ' \
'17.31625410200012993 43.12726471600016964, 17.11394290500004445 43.21320221600008438, ' \
'16.88062584700011826 43.40595123900006058, 16.62582441500009622 43.44904205900009231, ' \
'16.52466881600011561 43.51080963700009363, 16.39144941500012465 43.51080963700009363, ' \
'16.47339928500008455 43.5381533870001789, 16.43384850400013875 43.54975006700000506, ' \
'16.11768639400008851 43.52448151200003679, 16.17237389400014536 43.4896914730000077, ' \
'16.11312910200004467 43.47890859600009605, 15.95948326900011693 43.50397370000008834, ' \
'15.987315300000148 43.54490794500010509, 15.92530358200011165 43.55857982000004824, ' \
'15.91895592500009116 43.62872955900012073, 15.96631920700011165 43.64118073100003414, ' \
'15.90479576900014536 43.64801666900014254, 15.95297285200010151 43.65086497599999404, ' \
'15.95045006600008719 43.68854401200015047, 15.70630944100008719 43.76341380400005221, ' \
'15.6174422540000819 43.82550690300017493, 15.66309655000009116 43.81297435099999404, ' \
'15.67888431100004709 43.81928131700011875, 15.45508873800014271 43.92804596600014122, ' \
'15.14454186300011429 44.19546133000015686, 15.15219160200012993 44.23529694200014717, ' \
'15.11036217500011958 44.26434967700011214, 15.14063561300011429 44.28245677300013483, ' \
'15.17660566500009622 44.24994538000005662, 15.20777428500008455 44.27277252800014651, ' \
'15.19809004000012465 44.30166250200007028, 15.295258009000122 44.25067780199999845, ' \
'15.30274498800008587 44.29913971600016964, 15.26124108200011165 44.33258698100003414, ' \
'15.42448978000001603 44.26797109600006763, 15.52865644600009887 44.27179596600008438, ' \
'15.30795332100009887 44.35439687700007028, 15.00733483200014007 44.56972890800012976, ' \
'14.883799675000148 44.7236188820001388, 14.883799675000148 44.86147695500012844, 14.92164147200008983 ' \
'44.95880768400009231, 14.85279381600011561 45.09365469000000815, 14.65788821700004974 ' \
'45.19660065300017493, 14.57081139400008851 45.29364655200011214, 14.31153405000009116 ' \
'45.34398021000005485, 14.23259524800005238 45.14935944200000506, 14.17937259200007816 ' \
'45.13450755400005221, 14.19312584700008983 45.10561758000012844, 14.14389082100007045 ' \
'45.05939362200003018, 14.151377800000148 44.97748444200009033, 14.06885826900014536 ' \
'44.94953034100014122, 14.08383222700007309 44.9863955750000315, 14.04029381600014403 ' \
'45.03896719000015025, 14.0756942070000548 44.98371002800003282, 14.02051842500011958 ' \
'44.90110911700004692, 13.97266686300011429 44.90110911700004692, 13.99301191500009622 ' \
'44.88129303600014453, 13.97266686300011429 44.82664622599999404, 14.00001061300008587 ' \
'44.81305573100003414, 13.89014733200011165 44.83348216400010244, 13.91797936300014271 ' \
'44.77826569200009033, 13.90316816500009622 44.77240631700014717, 13.89698326900011693 ' \
'44.81305573100003414, 13.78711998800014271 44.87506745000008834, 13.84229576900008851 ' \
'44.88812897300006455, 13.79460696700010658 44.89496491100008768, 13.77409915500007287 ' \
'44.96381256700014717, 13.6232202480000808 45.07306549700014386, 13.61255944100014403 ' \
'45.11786530199999845, 13.72624759200004974 45.13450755400005221, 13.5959578790000819 ' \
'45.14541250200001343, 13.57545006600011561 45.26487864800007799, 13.60271243600001867 ' \
'45.28534577000012007, 13.57545006600011561 45.30646393400006389, 13.60954837300005238 ' \
'45.32013580900017757, 13.54127037900013875 45.34613678600005926, 13.50709069100014403 ' \
'45.51190827000000638, 13.62901778100007277 45.45898346000016943, 13.75929406800014476 ' \
'45.46316925100011019, 13.88900191200011136 45.42363678000005223, 13.98263960800005634 ' \
'45.47531321200001742, 13.97189091000012695 45.5142255660000643, 14.09291711400010172 ' \
'45.47391794800002174, 14.21869755100007637 45.49717234400004884, 14.37279667100006009 ' \
'45.47784535800009564, 14.4689148350000778 45.52559438100014688, 14.49857710800012001 ' \
'45.59618438800005435, 14.58094934100009255 45.66780792200010808, 14.66848921700008646 ' \
'45.53396596300005683, 14.79716353300005949 45.46518463200006011, 14.88160282300009385 ' \
'45.46978383400001178, 14.9226339110000481 45.51494903600017494, 15.13926151500010064 ' \
'45.43004465799999991, 15.32519331800011742 45.45283396399999276, 15.36136682100004691 ' \
'45.48203114900003641, 15.29666792800006192 45.52295888300012905, 15.2685559480001416 ' \
'45.60166208900012919, 15.37376916500011248 45.64021270800010655, 15.25501672300006817 ' \
'45.72346344000011698, 15.42906294700014769 45.77529490200011253, 15.45128381300008868 ' \
'45.81513743100013869, 15.67607629400006886 45.84169911700014666, 15.65943648300003588 ' \
'45.88882802400014782, 15.69798710100010908 46.0362092080000167, 15.58988000500005455 ' \
'46.11351715100001059, 15.62284956800010605 46.19170359400006021, 16.01920780400010358 ' \
'46.29882883700007312, 16.05961877400008575 46.33231516600015709, 16.0579651280001201 ' \
'46.37753204400003426, 16.2756262620000598 46.37316538500006402, 16.23490523300009158 ' \
'46.4933389280001137, 16.36947066200013978 46.54057118800012915))) '
geom = QgsGeometry.fromWkt(wkt)
f = QgsFeature()
f.setGeometry(geom)
image = QImage(200, 200, QImage.Format_RGB32)
painter = QPainter()
ms = QgsMapSettings()
crs = QgsCoordinateReferenceSystem.fromProj4('+proj=ortho +lat_0=36.5 +lon_0=-118.8 +x_0=0 +y_0=0 +a=6371000 +b=6371000 +units=m +no_defs')
self.assertTrue(crs.isValid())
ms.setDestinationCrs(crs)
ms.setExtent(QgsRectangle(1374999.8, 3912610.7, 4724462.5, 6505499.6))
ms.setOutputSize(image.size())
context = QgsRenderContext.fromMapSettings(ms)
context.setPainter(painter)
context.setScaleFactor(96 / 25.4) # 96 DPI
ct = QgsCoordinateTransform(QgsCoordinateReferenceSystem('epsg:4326'),
crs, QgsProject.instance())
self.assertTrue(ct.isValid())
context.setCoordinateTransform(ct)
context.setExtent(ct.transformBoundingBox(ms.extent(), QgsCoordinateTransform.ReverseTransform))
fill_symbol = QgsFillSymbol.createSimple({'color': '#ffffff', 'outline_color': '#ffffff', 'outline_width': '10'})
painter.begin(image)
try:
image.fill(QColor(0, 0, 0))
fill_symbol.startRender(context)
fill_symbol.renderFeature(f, context)
fill_symbol.stopRender(context)
finally:
painter.end()
assert self.imageCheck('Reprojection errors polygon', 'reprojection_errors_polygon', image)
#also test linestring
linestring = QgsGeometry(geom.constGet().boundary())
f.setGeometry(linestring)
line_symbol = QgsLineSymbol.createSimple({'color': '#ffffff', 'outline_width': '10'})
image = QImage(200, 200, QImage.Format_RGB32)
painter.begin(image)
try:
image.fill(QColor(0, 0, 0))
line_symbol.startRender(context)
line_symbol.renderFeature(f, context)
line_symbol.stopRender(context)
finally:
painter.end()
assert self.imageCheck('Reprojection errors linestring', 'reprojection_errors_linestring', image)
