本文整理汇总了Python中qgis.core.QgsRasterLayer.extent方法的典型用法代码示例。如果您正苦于以下问题:Python QgsRasterLayer.extent方法的具体用法?Python QgsRasterLayer.extent怎么用?Python QgsRasterLayer.extent使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qgis.core.QgsRasterLayer
的用法示例。
在下文中一共展示了QgsRasterLayer.extent方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_run_without_population_field
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def test_run_without_population_field(self):
impact_function = AshRasterPlacesFunction.instance()
hazard_path = standard_data_path("hazard", "ash_raster_wgs84.tif")
exposure_path = standard_data_path("exposure", "places.shp")
hazard_layer = QgsRasterLayer(hazard_path, "Ash")
exposure_layer = QgsVectorLayer(exposure_path, "Places", "ogr")
impact_function.hazard = hazard_layer
impact_function.exposure = exposure_layer
# Let's set the extent to the hazard extent
extent = hazard_layer.extent()
rect_extent = [extent.xMinimum(), extent.yMaximum(), extent.xMaximum(), extent.yMinimum()]
impact_function.requested_extent = rect_extent
impact_function.run()
impact_layer = impact_function.impact
# Extract calculated result
impact_data = impact_layer.get_data()
# 1 = inundated, 2 = wet, 3 = dry
expected_result = {0: 0, 1: 135, 2: 62, 3: 1, 4: 0}
result = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0}
for feature in impact_data:
inundated_status = feature[impact_function.target_field]
result[inundated_status] += 1
self.assertDictEqual(expected_result, result)
示例2: testLayerRemovalBeforeRun
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def testLayerRemovalBeforeRun(self):
"""test behavior when layer is removed before task begins"""
path = os.path.join(unitTestDataPath(), 'raster', 'with_color_table.tif')
raster_layer = QgsRasterLayer(path, "test")
self.assertTrue(raster_layer.isValid())
pipe = QgsRasterPipe()
self.assertTrue(pipe.set(raster_layer.dataProvider().clone()))
tmp = create_temp_filename('remove_layer.tif')
writer = QgsRasterFileWriter(tmp)
task = QgsRasterFileWriterTask(writer, pipe, 100, 100, raster_layer.extent(), raster_layer.crs())
task.writeComplete.connect(self.onSuccess)
task.errorOccurred.connect(self.onFail)
# remove layer
raster_layer = None
QgsApplication.taskManager().addTask(task)
while not self.success and not self.fail:
QCoreApplication.processEvents()
# in this case will still get a positive result - since the pipe is cloned before the task
# begins the task is no longer dependent on the original layer
self.assertTrue(self.success)
self.assertFalse(self.fail)
self.assertTrue(os.path.exists(tmp))
示例3: test_run
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def test_run(self):
function = FloodRasterRoadsFunction.instance()
hazard_path = test_data_path('hazard', 'continuous_flood_20_20.asc')
exposure_path = test_data_path('exposure', 'roads.shp')
# noinspection PyCallingNonCallable
hazard_layer = QgsRasterLayer(hazard_path, 'Flood')
# noinspection PyCallingNonCallable
exposure_layer = QgsVectorLayer(exposure_path, 'Roads', 'ogr')
# Let's set the extent to the hazard extent
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(), extent.yMaximum(),
extent.xMaximum(), extent.yMinimum()]
function.hazard = SafeLayer(hazard_layer)
function.exposure = SafeLayer(exposure_layer)
function.requested_extent = rect_extent
function.run()
impact = function.impact
keywords = impact.get_keywords()
self.assertEquals(function.target_field, keywords['target_field'])
expected_inundated_feature = 182
count = sum(impact.get_data(attribute=function.target_field))
self.assertEquals(count, expected_inundated_feature)
示例4: on_pushButton_clicked
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def on_pushButton_clicked(self):
"""Wow - an autoconnected slot!"""
print 'Click!'
myPath = os.path.join(
os.path.dirname(__file__),
'landsat.tif')
print myPath
layer = QgsRasterLayer(myPath, 'A Layer')
QgsMapLayerRegistry.instance().addMapLayers([layer])
layer.setGrayBandName(layer.bandName(1))
layer.setDrawingStyle(QgsRasterLayer.SingleBandPseudoColor)
layer.setColorShadingAlgorithm(QgsRasterLayer.PseudoColorShader)
layer.saveDefaultStyle()
self.widget.zoomToFullExtent()
print self.widget.extent().toString()
print layer.extent().toString()
self.widget.refresh()
示例5: testPrintMapFromTemplate
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def testPrintMapFromTemplate(self):
"""Test that we can get a map to render in the template."""
myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
myFileInfo = QFileInfo(myPath)
myRasterLayer = QgsRasterLayer(myFileInfo.filePath(),
myFileInfo.completeBaseName())
myRenderer = QgsMultiBandColorRenderer(
myRasterLayer.dataProvider(), 2, 3, 4
)
#mRasterLayer.setRenderer( rasterRenderer )
myPipe = myRasterLayer.pipe()
assert myPipe.set(myRenderer), "Cannot set pipe renderer"
QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])
myMapRenderer = QgsMapRenderer()
myLayerStringList = []
myLayerStringList.append(myRasterLayer.id())
myMapRenderer.setLayerSet(myLayerStringList)
myMapRenderer.setProjectionsEnabled(False)
myComposition = QgsComposition(myMapRenderer)
myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
myTemplateFile = file(myFile, 'rt')
myTemplateContent = myTemplateFile.read()
myTemplateFile.close()
myDocument = QDomDocument()
myDocument.setContent(myTemplateContent)
myComposition.loadFromTemplate(myDocument)
# now render the map, first zooming to the raster extents
myMap = myComposition.getComposerMapById(0)
myMessage = ('Map 0 could not be found in template %s', myFile)
assert myMap is not None, myMessage
myExtent = myRasterLayer.extent()
myMap.setNewExtent(myExtent)
myImagePath = os.path.join(str(QDir.tempPath()),
'template_map_render_python.png')
myPageNumber = 0
myImage = myComposition.printPageAsRaster(myPageNumber)
myImage.save(myImagePath)
assert os.path.exists(myImagePath), 'Map render was not created.'
# Not sure if this is a predictable way to test but its quicker than
# rendering.
myFileSize = QFileInfo(myImagePath).size()
myExpectedFileSize = 100000
myMessage = ('Expected file size to be greater than %s, got %s'
' for %s' %
(myExpectedFileSize, myFileSize, myImagePath))
assert myFileSize > myExpectedFileSize, myMessage
示例6: testPalettedBand
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def testPalettedBand(self):
""" test paletted raster render band"""
path = os.path.join(unitTestDataPath(),
'landsat_4326.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 2,
[QgsPalettedRasterRenderer.Class(137, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(138, QColor(255, 0, 0), 'class 1'),
QgsPalettedRasterRenderer.Class(139, QColor(0, 0, 255), 'class 1')])
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer_band2")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer_band2"), "Paletted rendering test failed")
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 3,
[QgsPalettedRasterRenderer.Class(120, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(123, QColor(255, 0, 0), 'class 1'),
QgsPalettedRasterRenderer.Class(124, QColor(0, 0, 255), 'class 1')])
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer_band3")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer_band3"), "Paletted rendering test failed")
示例7: test_raster_to_vector_and_line_intersection
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def test_raster_to_vector_and_line_intersection(self):
"""Test the core part of the analysis.
1. Test creation of spatial index of flood cells
2. Test intersection of flood cells with roads layer
"""
raster_name = standard_data_path(
'hazard',
'tsunami_wgs84.tif')
exposure_name = standard_data_path(
'exposure',
'roads_osm_4326.shp')
raster = QgsRasterLayer(raster_name, 'Flood')
exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr')
ranges = OrderedDict()
ranges[0] = [0, 1]
ranges[1] = [1, 2]
ranges[2] = [2, 100]
index, flood_cells_map = _raster_to_vector_cells(
raster, ranges, exposure.crs())
self.assertEqual(len(flood_cells_map), 4198)
rect_with_all_cells = raster.extent()
rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179)
rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175)
self.assertEqual(len(index.intersects(rect_with_all_cells)), 4198)
self.assertEqual(len(index.intersects(rect_with_4_cells)), 43)
self.assertEqual(len(index.intersects(rect_with_0_cells)), 504)
layer = create_layer(exposure)
new_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([new_field])
request = QgsFeatureRequest()
_intersect_lines_with_vector_cells(
exposure, request, index, flood_cells_map, layer, 'flooded')
feature_count = layer.featureCount()
self.assertEqual(feature_count, 388)
flooded = 0
iterator = layer.getFeatures()
for feature in iterator:
attributes = feature.attributes()
if attributes[3] == 1:
flooded += 1
self.assertEqual(flooded, 40)
示例8: clip_layers
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def clip_layers(first_layer_path, second_layer_path):
"""Clip and resample layers with the reference to the first layer.
:param first_layer_path: Path to the first layer path.
:type first_layer_path: str
:param second_layer_path: Path to the second layer path.
:type second_layer_path: str
:return: Path to the clipped datasets (clipped 1st layer, clipped 2nd
layer).
:rtype: tuple(str, str)
:raise
FileNotFoundError
"""
base_name, _ = os.path.splitext(first_layer_path)
# noinspection PyCallingNonCallable
first_layer = QgsRasterLayer(first_layer_path, base_name)
base_name, _ = os.path.splitext(second_layer_path)
# noinspection PyCallingNonCallable
second_layer = QgsRasterLayer(second_layer_path, base_name)
# Get the firs_layer extents as an array in EPSG:4326
first_layer_geo_extent = extent_to_geoarray(
first_layer.extent(),
first_layer.crs())
first_layer_geo_cell_size, _ = get_wgs84_resolution(first_layer)
second_layer_geo_cell_size, _ = get_wgs84_resolution(second_layer)
if first_layer_geo_cell_size < second_layer_geo_cell_size:
cell_size = first_layer_geo_cell_size
else:
cell_size = second_layer_geo_cell_size
clipped_first_layer = clip_layer(
layer=first_layer,
extent=first_layer_geo_extent,
cell_size=cell_size)
clipped_second_layer = clip_layer(
layer=second_layer,
extent=first_layer_geo_extent,
cell_size=cell_size)
return clipped_first_layer, clipped_second_layer
示例9: test_run
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def test_run(self):
"""Test the tsunami on roads IF"""
impact_function = TsunamiRasterRoadsFunction.instance()
hazard_path = test_data_path('hazard', 'tsunami_wgs84.tif')
exposure_path = test_data_path('exposure', 'roads.shp')
hazard_layer = QgsRasterLayer(hazard_path, 'Tsunami')
exposure_layer = QgsVectorLayer(exposure_path, 'Roads', 'ogr')
impact_function.hazard = hazard_layer
impact_function.exposure = exposure_layer
# Let's set the extent to the hazard extent
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(), extent.yMaximum(),
extent.xMaximum(), extent.yMinimum()]
impact_function.requested_extent = rect_extent
impact_function.run()
impact_layer = impact_function.impact
# Extract calculated result
impact_data = impact_layer.get_data()
self.assertEqual(len(impact_data), 3580)
# 1 = inundated, 2 = wet, 3 = dry
expected_result = {
0: 3218,
1: 88,
2: 107,
3: 114,
4: 53
}
result = {
0: 0,
1: 0,
2: 0,
3: 0,
4: 0
}
for feature in impact_data:
inundated_status = feature[impact_function.target_field]
result[inundated_status] += 1
message = 'Expecting %s, but it returns %s' % (expected_result, result)
self.assertEqual(expected_result, result, message)
示例10: testSuccess
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def testSuccess(self):
"""test successfully writing a layer"""
path = os.path.join(unitTestDataPath(), 'raster', 'with_color_table.tif')
raster_layer = QgsRasterLayer(path, "test")
self.assertTrue(raster_layer.isValid())
pipe = QgsRasterPipe()
self.assertTrue(pipe.set(raster_layer.dataProvider().clone()))
tmp = create_temp_filename('success.tif')
writer = QgsRasterFileWriter(tmp)
task = QgsRasterFileWriterTask(writer, pipe, 100, 100, raster_layer.extent(), raster_layer.crs())
task.writeComplete.connect(self.onSuccess)
task.errorOccurred.connect(self.onFail)
QgsApplication.taskManager().addTask(task)
while not self.success and not self.fail:
QCoreApplication.processEvents()
self.assertTrue(self.success)
self.assertFalse(self.fail)
self.assertTrue(os.path.exists(tmp))
示例11: TestQgsBlendModes
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
class TestQgsBlendModes(unittest.TestCase):
def __init__(self, methodName):
"""Run once on class initialization."""
unittest.TestCase.__init__(self, methodName)
self.iface = get_iface()
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
self.mMapRegistry = QgsProject.instance()
# create point layer
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.mPointLayer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.mMapRegistry.addMapLayer(self.mPointLayer)
self.mSimplifyMethod = QgsVectorSimplifyMethod()
self.mSimplifyMethod.setSimplifyHints(QgsVectorSimplifyMethod.NoSimplification)
# create polygon layer
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.mPolygonLayer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr')
self.mPolygonLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mPolygonLayer)
# create line layer
myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.mLineLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr')
self.mLineLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mLineLayer)
# create two raster layers
myRasterFile = os.path.join(TEST_DATA_DIR, 'rgb256x256.png')
self.mRasterLayer1 = QgsRasterLayer(myRasterFile, "raster1")
self.mRasterLayer2 = QgsRasterLayer(myRasterFile, "raster2")
myMultiBandRenderer1 = QgsMultiBandColorRenderer(self.mRasterLayer1.dataProvider(), 1, 2, 3)
self.mRasterLayer1.setRenderer(myMultiBandRenderer1)
self.mMapRegistry.addMapLayer(self.mRasterLayer1)
myMultiBandRenderer2 = QgsMultiBandColorRenderer(self.mRasterLayer2.dataProvider(), 1, 2, 3)
self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
self.mMapRegistry.addMapLayer(self.mRasterLayer2)
# to match blend modes test comparisons background
self.mapSettings = QgsMapSettings()
self.mapSettings.setLayers([self.mRasterLayer1, self.mRasterLayer2])
self.mapSettings.setBackgroundColor(QColor(152, 219, 249))
self.mapSettings.setOutputSize(QSize(400, 400))
self.mapSettings.setOutputDpi(96)
self.extent = QgsRectangle(-118.8888888888887720, 22.8002070393376783, -83.3333333333331581, 46.8719806763287536)
def testVectorBlending(self):
"""Test that blend modes work for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set blending modes for both layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_Difference)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_Difference)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_blendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_blendmodes", 20)
myMessage = ('vector blending failed')
assert myResult, myMessage
# Reset layers
self.mLineLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorFeatureBlending(self):
"""Test that feature blend modes work for vector layers."""
# Add vector layers to map
myLayers = [self.mLineLayer, self.mPolygonLayer]
self.mapSettings.setLayers(myLayers)
self.mapSettings.setExtent(self.extent)
# Set feature blending for line layer
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_Plus)
checker = QgsMultiRenderChecker()
checker.setControlName("expected_vector_featureblendmodes")
checker.setMapSettings(self.mapSettings)
checker.setColorTolerance(1)
myResult = checker.runTest("vector_featureblendmodes", 20)
myMessage = ('vector feature blending failed')
assert myResult, myMessage
# Reset layers
self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_SourceOver)
def testVectorLayerTransparency(self):
#.........这里部分代码省略.........
示例12: testTransparency
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def testTransparency(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
myRasterLayer = QgsRasterLayer(myPath, myBaseName)
myMessage = 'Raster not loaded: %s' % myPath
assert myRasterLayer.isValid(), myMessage
renderer = QgsSingleBandGrayRenderer(myRasterLayer.dataProvider(), 1)
myRasterLayer.setRenderer(renderer)
myRasterLayer.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum,
QgsRasterLayer.ContrastEnhancementMinMax)
myContrastEnhancement = myRasterLayer.renderer().contrastEnhancement()
#print ("myContrastEnhancement.minimumValue = %.17g" %
# myContrastEnhancement.minimumValue())
#print ("myContrastEnhancement.maximumValue = %.17g" %
# myContrastEnhancement.maximumValue())
# Unfortunately the minimum/maximum values calculated in C++ and Python
# are slightly different (e.g. 3.3999999521443642e+38 x
# 3.3999999521444001e+38)
# It is not clear where the precision is lost.
# We set the same values as C++.
myContrastEnhancement.setMinimumValue(-3.3319999287625854e+38)
myContrastEnhancement.setMaximumValue(3.3999999521443642e+38)
#myType = myRasterLayer.dataProvider().dataType(1);
#myEnhancement = QgsContrastEnhancement(myType);
myTransparentSingleValuePixelList = []
rasterTransparency = QgsRasterTransparency()
myTransparentPixel1 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel1.min = -2.5840000772112106e+38
myTransparentPixel1.max = -1.0879999684602689e+38
myTransparentPixel1.percentTransparent = 50
myTransparentSingleValuePixelList.append(myTransparentPixel1)
myTransparentPixel2 = \
QgsRasterTransparency.TransparentSingleValuePixel()
myTransparentPixel2.min = 1.359999960575336e+37
myTransparentPixel2.max = 9.520000231087593e+37
myTransparentPixel2.percentTransparent = 70
myTransparentSingleValuePixelList.append(myTransparentPixel2)
rasterTransparency.setTransparentSingleValuePixelList(
myTransparentSingleValuePixelList)
rasterRenderer = myRasterLayer.renderer()
assert rasterRenderer
rasterRenderer.setRasterTransparency(rasterTransparency)
QgsMapLayerRegistry.instance().addMapLayers([ myRasterLayer, ])
myMapRenderer = QgsMapRenderer()
myLayers = QStringList()
myLayers.append(myRasterLayer.id())
myMapRenderer.setLayerSet(myLayers)
myMapRenderer.setExtent(myRasterLayer.extent())
myChecker = QgsRenderChecker()
myChecker.setControlName("expected_raster_transparency")
myChecker.setMapRenderer(myMapRenderer)
myResultFlag = myChecker.runTest("raster_transparency_python");
assert myResultFlag, "Raster transparency rendering test failed"
示例13: select_HDF5_file
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def select_HDF5_file(self):
"""Run method that performs all the real work"""
# show the dialog
#self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# close the dialog
self.dlg.close()
# See if OK was pressed
if result:
#### to open windows browser and search for HDF5 files only:
myfileNames = QFileDialog.getOpenFileNames(self.dlg,
self.tr("HDF5 File Selector"),
"",
self.tr("HDF5 (*.hdf5 *.h5)"))
#### to loop through all selected HDF5 files, just handling one for now
for i in myfileNames:
#### bind the HDF5 file
myfile = QgsRasterLayer(i)
#### to deal with multiple datasets within file
if (len(myfile.subLayers()) > 1):
#### to open dataset with desired data and name it Reflectance
#mydset = QgsRasterLayer(myfile.subLayers()[0], 'Reflectance')
fileName = myfile.subLayers()[0]
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
mydset = QgsRasterLayer(fileName, baseName)
##################################### Trials of setting proper extent begin here
print 'Extent before: '
print mydset.extent().toString()
########################## test almost worked
### loaded layer in right place but without data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#mydset.setExtent(rect)
####################################
######################## test almost worked
### loaded layer in right place but without data
#size = QSizeF(1,1)
#point = QPointF(326380.0, 4103390.0)
#rect = QRectF(point, size)
#rect = QgsRectangle(rect)
#mydset.setExtent(rect)
###################################
########################## did not change extent
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#context = QgsRenderContext()
#context.setExtent(rect)
#mydset.draw(context)
####################################
#################################### did not change extent
#size = QSizeF(1,1)
#point = QPointF(326380.0, 4103390.0)
#rect = QRectF(point, size)
#rect = QgsRectangle(rect)
#context = QgsRenderContext()
#context.setExtent(rect)
#mydset.draw(context)
#####################################
###################################### did not change extent
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#context = QgsRenderContext()
#context.setExtent(rect)
#print 'Context extent: '
#print context.extent().toString() #this printed correct extent
#mydset.createMapRenderer(context)
#######################################
######################## test almost worked
### loaded layer in right place but without data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#provider = mydset.dataProvider().clone()
#mydset.setExtent(rect)
#provider.reloadData()
######################################
########################################
# did not change extent, loaded data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#context = QgsRenderContext()
#context.setExtent(rect)
#renderer = mydset.createMapRenderer(context)
#renderer.render()
#########################################
###########################################
# did not change extent, loaded data
#rect = QgsRectangle(326380.0,4103390.0-2853,326380.0+1332,4103390.0)
#.........这里部分代码省略.........
示例14: testPaletted
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def testPaletted(self):
""" test paletted raster renderer with raster with color table"""
path = os.path.join(unitTestDataPath('raster'),
'with_color_table.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 1,
[QgsPalettedRasterRenderer.Class(1, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(3, QColor(255, 0, 0), 'class 1')])
self.assertEqual(renderer.nColors(), 2)
self.assertEqual(renderer.usesBands(), [1])
# test labels
self.assertEqual(renderer.label(1), 'class 2')
self.assertEqual(renderer.label(3), 'class 1')
self.assertFalse(renderer.label(101))
# test legend symbology - should be sorted by value
legend = renderer.legendSymbologyItems()
self.assertEqual(legend[0][0], 'class 2')
self.assertEqual(legend[1][0], 'class 1')
self.assertEqual(legend[0][1].name(), '#00ff00')
self.assertEqual(legend[1][1].name(), '#ff0000')
# test retrieving classes
classes = renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'class 1')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
# test set label
# bad index
renderer.setLabel(1212, 'bad')
renderer.setLabel(3, 'new class')
self.assertEqual(renderer.label(3), 'new class')
# color ramp
r = QgsLimitedRandomColorRamp(5)
renderer.setSourceColorRamp(r)
self.assertEqual(renderer.sourceColorRamp().type(), 'random')
self.assertEqual(renderer.sourceColorRamp().count(), 5)
# clone
new_renderer = renderer.clone()
classes = new_renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(new_renderer.sourceColorRamp().type(), 'random')
self.assertEqual(new_renderer.sourceColorRamp().count(), 5)
# write to xml and read
doc = QDomDocument('testdoc')
elem = doc.createElement('qgis')
renderer.writeXml(doc, elem)
restored = QgsPalettedRasterRenderer.create(elem.firstChild().toElement(), layer.dataProvider())
self.assertTrue(restored)
self.assertEqual(restored.usesBands(), [1])
classes = restored.classes()
self.assertTrue(classes)
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(restored.sourceColorRamp().type(), 'random')
self.assertEqual(restored.sourceColorRamp().count(), 5)
# render test
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer"), "Paletted rendering test failed")
示例15: idw_interpolation
# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import extent [as 别名]
def idw_interpolation(layer, parent_dialog):
"""Run interpolation using inverse distance weight algorithm
:param layer: Vector layer with drivetimes
:type layer: QgsVectorLayer
:param parent_dialog: A dialog that called this function.
:type parent_dialog: QProgressDialog
:returns raster_layer: Interpolated raster layer with drivetimes
:rtype raster_layer: QgsRasterLayer
"""
raster_layer = None
try:
Processing.initialize()
Processing.updateAlgsList()
output_raster = processing.runalg(
'gdalogr:gridinvdist',
layer,
'minutes',
2, 0, 0, 0, 0, 0, 0, 0, 5,
"[temporary file]")
output_file = output_raster['OUTPUT']
file_info = QFileInfo(output_file)
base_name = file_info.baseName()
# retrieving the raster output , styling it and load it in Qgis
raster_layer = QgsRasterLayer(output_file, base_name)
except Exception as exception: # pylint: disable=broad-except
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map,'
'please check if you have processing '
'plugin installed '))
else:
display_warning_message_box(
parent_dialog,
'Error',
'Error loading isochrone map,'
'please check if you have processing '
'plugin installed ')
if raster_layer:
if raster_layer.isValid():
color_shader = QgsColorRampShader()
color_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
colors = {
'deep_green': '#1a9641',
'light_green': '#a6d96a',
'pale_yellow': '#ffffc0',
'light_red': '#fdae61',
'red': '#d7191c'
}
provider = raster_layer.dataProvider()
stats = provider.bandStatistics(
1,
QgsRasterBandStats.All,
raster_layer.extent(),
0)
values = {}
if stats:
min = stats.minimumValue
max = stats.maximumValue
stat_range = max - min
add = stat_range / 4
values[0] = min
value = min
for index in range(1, 4):
value += add
values[index] = value
values[4] = max
else:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map'
' Problem indexing the isochrones map'))
color_list = [
QgsColorRampShader.ColorRampItem(
values[0],
QColor(colors['deep_green'])),
QgsColorRampShader.ColorRampItem(
values[1],
QColor(colors['light_green'])),
QgsColorRampShader.ColorRampItem(
values[2],
QColor(colors['pale_yellow'])),
#.........这里部分代码省略.........