本文整理汇总了Python中qgis.core.QgsRectangle.width方法的典型用法代码示例。如果您正苦于以下问题:Python QgsRectangle.width方法的具体用法?Python QgsRectangle.width怎么用?Python QgsRectangle.width使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qgis.core.QgsRectangle
的用法示例。
在下文中一共展示了QgsRectangle.width方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: processAlgorithm
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def processAlgorithm(self, progress):
idx = self.getParameterValue(self.TYPE)
extent = self.getParameterValue(self.EXTENT).split(',')
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
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()
centerX = bbox.center().x()
centerY = bbox.center().y()
#~ originX = centerX - width / 2.0
#~ originY = centerY - height / 2.0
originX = bbox.xMinimum()
originY = bbox.yMaximum()
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: %s/%s' % (hSpacing, vSpacing)))
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'))
#if self.types[idx].find(self.tr('polygon')) >= 0:
if idx != 0:
geometryType = QGis.WKBPolygon
else:
geometryType = QGis.WKBLineString
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)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
geometryType, crs)
if idx == 0:
self._rectangleGridLine(
writer, width, height, originX, originY, hSpacing, vSpacing)
elif idx == 1:
self._rectangleGridPoly(
writer, width, height, originX, originY, hSpacing, vSpacing)
elif idx == 2:
self._diamondGrid(
writer, width, height, originX, originY, hSpacing, vSpacing)
elif idx == 3:
self._hexagonGrid(
writer, width, height, originX, originY, hSpacing, vSpacing)
del writer
示例2: processAlgorithm
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def processAlgorithm(self, feedback):
extent = str(self.getParameterValue(self.EXTENT)).split(',')
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
extent = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(extent_geom.geometry())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(QgsPoint(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if extent_engine.intersects(geom.geometry()):
f.setAttribute('id', count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
del writer
示例3: rotation_test
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def rotation_test(self):
# We will create a polygon layer with a rotated rectangle.
# Then we will make it the object layer for the atlas,
# rotate the map and test that the bounding rectangle
# is smaller than the bounds without rotation.
polygonLayer = QgsVectorLayer('Polygon', 'test_polygon', 'memory')
poly = QgsFeature(polygonLayer.fields())
points = [(10, 15), (15, 10), (45, 40), (40, 45)]
poly.setGeometry(QgsGeometry.fromPolygonXY([[QgsPointXY(x[0], x[1]) for x in points]]))
polygonLayer.dataProvider().addFeatures([poly])
QgsProject.instance().addMapLayer(polygonLayer)
# Recreating the layout locally
composition = QgsPrintLayout(QgsProject.instance())
composition.initializeDefaults()
# the atlas map
atlasMap = QgsLayoutItemMap(composition)
atlasMap.attemptSetSceneRect(QRectF(20, 20, 130, 130))
atlasMap.setFrameEnabled(True)
atlasMap.setLayers([polygonLayer])
atlasMap.setExtent(QgsRectangle(0, 0, 100, 50))
composition.addLayoutItem(atlasMap)
# the atlas
atlas = composition.atlas()
atlas.setCoverageLayer(polygonLayer)
atlas.setEnabled(True)
atlasMap.setAtlasDriven(True)
atlasMap.setAtlasScalingMode(QgsLayoutItemMap.Auto)
atlasMap.setAtlasMargin(0.0)
# Testing
atlasMap.setMapRotation(0.0)
atlas.beginRender()
atlas.first()
nonRotatedExtent = QgsRectangle(atlasMap.extent())
atlasMap.setMapRotation(45.0)
atlas.first()
rotatedExtent = QgsRectangle(atlasMap.extent())
self.assertLess(rotatedExtent.width(), nonRotatedExtent.width() * 0.9)
self.assertLess(rotatedExtent.height(), nonRotatedExtent.height() * 0.9)
QgsProject.instance().removeMapLayer(polygonLayer)
示例4: rotation_test
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def rotation_test(self):
# We will create a polygon layer with a rotated rectangle.
# Then we will make it the object layer for the atlas,
# rotate the map and test that the bounding rectangle
# is smaller than the bounds without rotation.
polygonLayer = QgsVectorLayer('Polygon', 'test_polygon', 'memory')
poly = QgsFeature(polygonLayer.pendingFields())
points = [(10, 15), (15, 10), (45, 40), (40, 45)]
poly.setGeometry(QgsGeometry.fromPolygon([[QgsPointXY(x[0], x[1]) for x in points]]))
polygonLayer.dataProvider().addFeatures([poly])
QgsProject.instance().addMapLayer(polygonLayer)
# Recreating the composer locally
composition = QgsComposition(QgsProject.instance())
composition.setPaperSize(297, 210)
# the atlas map
atlasMap = QgsComposerMap(composition, 20, 20, 130, 130)
atlasMap.setFrameEnabled(True)
atlasMap.setLayers([polygonLayer])
atlasMap.setNewExtent(QgsRectangle(0, 0, 100, 50))
composition.addComposerMap(atlasMap)
# the atlas
atlas = composition.atlasComposition()
atlas.setCoverageLayer(polygonLayer)
atlas.setEnabled(True)
composition.setAtlasMode(QgsComposition.ExportAtlas)
atlasMap.setAtlasDriven(True)
atlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
atlasMap.setAtlasMargin(0.0)
# Testing
atlasMap.setMapRotation(0.0)
atlas.firstFeature()
nonRotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
atlasMap.setMapRotation(45.0)
atlas.firstFeature()
rotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
assert rotatedExtent.width() < nonRotatedExtent.width() * 0.9
assert rotatedExtent.height() < nonRotatedExtent.height() * 0.9
QgsProject.instance().removeMapLayer(polygonLayer)
示例5: _rect
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def _rect(self, startPoint, endPoint):
if startPoint is None or endPoint is None:
return None
p0 = self.toCanvasCoordinates(startPoint)
p1 = self.toCanvasCoordinates(endPoint)
canvas_rect = QgsRectangle(QgsPoint(p0.x(), p0.y()), QgsPoint(p1.x(), p1.y()))
center = QgsPoint((startPoint.x() + endPoint.x()) / 2, (startPoint.y() + endPoint.y()) / 2)
return RotatedRect(center, self.mupp * canvas_rect.width(), self.mupp * canvas_rect.height()).rotate(self.rotation, center)
示例6: testDimensions
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def testDimensions(self):
rect = QgsRectangle(0.0, 0.0, 10.0, 10.0)
myMessage = "Expected: %s\nGot: %s\n" % (10.0, rect.width())
assert rect.width() == 10.0, myMessage
myMessage = "Expected: %s\nGot: %s\n" % (10.0, rect.height())
assert rect.height() == 10.0, myMessage
myMessage = "Expected: %s\nGot: %s\n" % ("5.0, 5.0", rect.center().toString())
assert rect.center() == QgsPoint(5.0, 5.0), myMessage
rect.scale(2.0)
myMessage = "Expected: %s\nGot: %s\n" % (20.0, rect.width())
assert rect.width() == 20.0, myMessage
myMessage = "Expected: %s\nGot: %s\n" % (20.0, rect.height())
assert rect.height() == 20.0, myMessage
示例7: processAlgorithm
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def processAlgorithm(self, feedback):
idx = self.getParameterValue(self.TYPE)
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()
originX = bbox.xMinimum()
originY = bbox.yMaximum()
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: %s/%s' % (hSpacing, vSpacing)))
if width < hSpacing:
raise GeoAlgorithmExecutionException(
self.tr('Horizontal spacing is too small for the covered area'))
if hSpacing <= hOverlay or vSpacing <= vOverlay:
raise GeoAlgorithmExecutionException(
self.tr('Invalid overlay: %s/%s' % (hOverlay, vOverlay)))
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)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
QgsWkbTypes.Polygon, crs)
if idx == 0:
self._rectangleGrid(
writer, width, height, originX, originY, hSpacing, vSpacing, hOverlay, vOverlay, feedback)
elif idx == 1:
self._diamondGrid(
writer, width, height, originX, originY, hSpacing, vSpacing, hOverlay, vOverlay, feedback)
elif idx == 2:
self._hexagonGrid(
writer, width, height, originX, originY, hSpacing, vSpacing, hOverlay, vOverlay, feedback)
del writer
示例8: processAlgorithm
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def processAlgorithm(self, progress):
extent = str(self.getParameterValue(self.EXTENT)).split(",")
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
extent = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField("id", QVariant.Int, "", 10, 0))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QGis.WKBPoint, mapCRS)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.00 / (area / pSpacing)
y = extent.yMaximum() - inset
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(
QgsPoint(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)),
)
)
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if geom.intersects(extent):
f.setAttribute("id", count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
progress.setPercentage(int(count * total))
y = y - pSpacing
del writer
示例9: subrectangle
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def subrectangle(self, norm_rect, y_inverted=False):
"""
args:
norm_rect -- QgsRectangle (0 <= xmin, 0 <= ymin, xmax <= 1, ymax <= 1)
y_inverted -- If True, lower-left is (0, 1) and upper-right is (1, 0).
Or else lower-left is (0, 0) and upper-right is (1, 1).
"""
ur_rect = self._unrotated_rect
xmin = ur_rect.xMinimum() + norm_rect.xMinimum() * ur_rect.width()
xmax = ur_rect.xMinimum() + norm_rect.xMaximum() * ur_rect.width()
if y_inverted:
ymin = ur_rect.yMaximum() - norm_rect.yMaximum() * ur_rect.height()
ymax = ur_rect.yMaximum() - norm_rect.yMinimum() * ur_rect.height()
else:
ymin = ur_rect.yMinimum() + norm_rect.yMinimum() * ur_rect.height()
ymax = ur_rect.yMinimum() + norm_rect.yMaximum() * ur_rect.height()
rect = QgsRectangle(xmin, ymin, xmax, ymax)
return RotatedRect(rect.center(), rect.width(), rect.height()).rotate(self._rotation, self._center)
示例10: processAlgorithm
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def processAlgorithm(self, progress):
extent = self.getParameterValue(self.EXTENT).split(',')
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
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()
originX = bbox.xMinimum()
originY = bbox.yMaximum()
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: %s/%s' % (hSpacing, vSpacing)))
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)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
QgsWkbTypes.LineString, crs)
self._rectangleGridLine(
writer, width, height, originX, originY, hSpacing, vSpacing)
示例11: draw_composition
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def draw_composition(self):
"""Draw all the components in the composition."""
safe_logo = self.composition.getComposerItemById('safe-logo')
north_arrow = self.composition.getComposerItemById('north-arrow')
organisation_logo = self.composition.getComposerItemById(
'organisation-logo')
if qgis_version() < 20600:
if safe_logo is not None:
safe_logo.setPictureFile(self.safe_logo)
if north_arrow is not None:
north_arrow.setPictureFile(self.north_arrow)
if organisation_logo is not None:
organisation_logo.setPictureFile(self.organisation_logo)
else:
if safe_logo is not None:
safe_logo.setPicturePath(self.safe_logo)
if north_arrow is not None:
north_arrow.setPicturePath(self.north_arrow)
if organisation_logo is not None:
organisation_logo.setPicturePath(self.organisation_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
# noinspection PyCallingNonCallable
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
legend_title = legend_attributes.get('legend_title', None)
symbol_count = 1
# noinspection PyUnresolvedReferences
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)
# Set Legend
# Since 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()
示例12: processAlgorithm
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def processAlgorithm(self, progress):
extent = self.getParameterValue(self.EXTENT).split(",")
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
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: %s/%s" % (hSpacing, vSpacing)))
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)
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 - vSpacing
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
progress.setPercentage(int(count / count_max * 50))
progress.setPercentage(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 + hSpacing
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
progress.setPercentage(50 + int(count / count_max * 50))
del writer
示例13: qgis_composer_renderer
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
#.........这里部分代码省略.........
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 isinstance(composer_map, QgsComposerMap):
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')
示例14: processAlgorithm
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
def processAlgorithm(self, parameters, context, feedback):
feedback.setProgress(1)
extent = self.parameterAsExtent(parameters, self.EXTENT, context)
min_zoom = self.parameterAsInt(parameters, self.ZOOM_MIN, context)
max_zoom = self.parameterAsInt(parameters, self.ZOOM_MAX, context)
dpi = self.parameterAsInt(parameters, self.DPI, context)
tile_format = self.formats[self.parameterAsEnum(parameters, self.TILE_FORMAT, context)]
output_format = self.outputs[self.parameterAsEnum(parameters, self.OUTPUT_FORMAT, context)]
if output_format == 'Directory':
output_dir = self.parameterAsString(parameters, self.OUTPUT_DIRECTORY, context)
if not output_dir:
raise QgsProcessingException(self.tr('You need to specify output directory.'))
else: # MBTiles
output_file = self.parameterAsString(parameters, self.OUTPUT_FILE, context)
if not output_file:
raise QgsProcessingException(self.tr('You need to specify output filename.'))
tile_width = 256
tile_height = 256
wgs_crs = QgsCoordinateReferenceSystem('EPSG:4326')
dest_crs = QgsCoordinateReferenceSystem('EPSG:3857')
project = context.project()
src_to_wgs = QgsCoordinateTransform(project.crs(), wgs_crs, context.transformContext())
wgs_to_dest = QgsCoordinateTransform(wgs_crs, dest_crs, context.transformContext())
settings = QgsMapSettings()
settings.setOutputImageFormat(QImage.Format_ARGB32_Premultiplied)
settings.setDestinationCrs(dest_crs)
settings.setLayers(self.layers)
settings.setOutputDpi(dpi)
wgs_extent = src_to_wgs.transformBoundingBox(extent)
wgs_extent = [wgs_extent.xMinimum(), wgs_extent.yMinimum(), wgs_extent.xMaximum(), wgs_extent.yMaximum()]
metatiles_by_zoom = {}
metatiles_count = 0
for zoom in range(min_zoom, max_zoom + 1):
metatiles = get_metatiles(wgs_extent, zoom, 4)
metatiles_by_zoom[zoom] = metatiles
metatiles_count += len(metatiles)
lab_buffer_px = 100
progress = 0
tile_params = {
'format': tile_format,
'quality': 75,
'width': tile_width,
'height': tile_height
}
if output_format == 'Directory':
writer = DirectoryWriter(output_dir, tile_params)
else:
writer = MBTilesWriter(output_file, tile_params, wgs_extent, min_zoom, max_zoom)
for zoom in range(min_zoom, max_zoom + 1):
feedback.pushConsoleInfo('Generating tiles for zoom level: %s' % zoom)
for i, metatile in enumerate(metatiles_by_zoom[zoom]):
size = QSize(tile_width * metatile.rows(), tile_height * metatile.columns())
extent = QgsRectangle(*metatile.extent())
settings.setExtent(wgs_to_dest.transformBoundingBox(extent))
settings.setOutputSize(size)
label_area = QgsRectangle(settings.extent())
lab_buffer = label_area.width() * (lab_buffer_px / size.width())
label_area.set(
label_area.xMinimum() + lab_buffer,
label_area.yMinimum() + lab_buffer,
label_area.xMaximum() - lab_buffer,
label_area.yMaximum() - lab_buffer
)
settings.setLabelBoundaryGeometry(QgsGeometry.fromRect(label_area))
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
dpm = settings.outputDpi() / 25.4 * 1000
image.setDotsPerMeterX(dpm)
image.setDotsPerMeterY(dpm)
painter = QPainter(image)
job = QgsMapRendererCustomPainterJob(settings, painter)
job.renderSynchronously()
painter.end()
# For analysing metatiles (labels, etc.)
# metatile_dir = os.path.join(output_dir, str(zoom))
# os.makedirs(metatile_dir, exist_ok=True)
# image.save(os.path.join(metatile_dir, 'metatile_%s.png' % i))
for r, c, tile in metatile.tiles:
tile_img = image.copy(tile_width * r, tile_height * c, tile_width, tile_height)
writer.writeTile(tile, tile_img)
progress += 1
feedback.setProgress(100 * (progress / metatiles_count))
writer.close()
#.........这里部分代码省略.........
示例15: __init__
# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import width [as 别名]
class DEMBlock:
def __init__(self, dem_width, dem_height, dem_values, plane_width, plane_height, offsetX, offsetY):
self.dem_width = dem_width
self.dem_height = dem_height
self.dem_values = dem_values
self.plane_width = plane_width
self.plane_height = plane_height
self.offsetX = offsetX
self.offsetY = offsetY
self.orig_stats = {"max": max(dem_values), "min": min(dem_values)}
self.rect = QgsRectangle(offsetX - plane_width * 0.5, offsetY - plane_height * 0.5,
offsetX + plane_width * 0.5, offsetY + plane_height * 0.5)
self.properties = {"width": dem_width, "height": dem_height}
self.properties["plane"] = {"width": plane_width, "height": plane_height,
"offsetX": offsetX, "offsetY": offsetY}
self.clip_geometry = None
def set(self, key, value):
"""set property"""
self.properties[key] = value
def setClipGeometry(self, geometry):
self.clip_geometry = geometry
def zShift(self, shift):
if shift != 0:
self.dem_values = map(lambda x: x + shift, self.dem_values)
def zScale(self, scale):
if scale != 1:
self.dem_values = map(lambda x: x * scale, self.dem_values)
def write(self, writer):
mapTo3d = writer.settings.mapTo3d
writer.write("bl = lyr.addBlock({0}, {1});\n".format(pyobj2js(self.properties), pyobj2js(bool(self.clip_geometry))))
writer.write("bl.data = [{0}];\n".format(",".join(map(gdal2threejs.formatValue, self.dem_values))))
# clipped with polygon layer
if self.clip_geometry:
z_func = lambda x, y: 0
transform_func = lambda x, y, z: mapTo3d.transform(x, y, z)
geom = PolygonGeometry.fromQgsGeometry(self.clip_geometry, z_func, transform_func)
geom.splitPolygon(writer.triangleMesh(self.dem_width, self.dem_height))
polygons = []
for polygon in geom.polygons:
bnds = []
for boundary in polygon:
bnds.append(map(lambda pt: [pt.x, pt.y], boundary))
polygons.append(bnds)
writer.write("bl.clip = {};\n")
writer.write("bl.clip.polygons = {0};\n".format(pyobj2js(polygons)))
triangles = Triangles()
polygons = []
for polygon in geom.split_polygons:
boundary = polygon[0]
if len(polygon) == 1 and len(boundary) == 4:
triangles.addTriangle(boundary[0], boundary[2], boundary[1]) # vertex order should be counter-clockwise
else:
bnds = [map(lambda pt: [pt.x, pt.y], bnd) for bnd in polygon]
polygons.append(bnds)
vf = {"v": map(lambda pt: [pt.x, pt.y], triangles.vertices), "f": triangles.faces}
writer.write("bl.clip.triangles = {0};\n".format(pyobj2js(vf)))
writer.write("bl.clip.split_polygons = {0};\n".format(pyobj2js(polygons)))
def getValue(self, x, y):
def _getValue(gx, gy):
return self.dem_values[gx + self.dem_width * gy]
if 0 <= x and x <= self.dem_width - 1 and 0 <= y and y <= self.dem_height - 1:
ix, iy = int(x), int(y)
sx, sy = x - ix, y - iy
z11 = _getValue(ix, iy)
z21 = 0 if x == self.dem_width - 1 else _getValue(ix + 1, iy)
z12 = 0 if y == self.dem_height - 1 else _getValue(ix, iy + 1)
z22 = 0 if x == self.dem_width - 1 or y == self.dem_height - 1 else _getValue(ix + 1, iy + 1)
return (1 - sx) * ((1 - sy) * z11 + sy * z12) + sx * ((1 - sy) * z21 + sy * z22) # bilinear interpolation
return 0 # as safe null value
def gridPointToPoint(self, x, y):
x = self.rect.xMinimum() + self.rect.width() / (self.dem_width - 1) * x
y = self.rect.yMaximum() - self.rect.height() / (self.dem_height - 1) * y
return x, y
def pointToGridPoint(self, x, y):
x = (x - self.rect.xMinimum()) / self.rect.width() * (self.dem_width - 1)
y = (self.rect.yMaximum() - y) / self.rect.height() * (self.dem_height - 1)
#.........这里部分代码省略.........