def close_project(self, project=None):
"""
Close the current open project
"""
if not project is None and not project == self.project:
return
self.tracking.clear_logging()
self.dataentrywidget.clear()
self.canvas_page.cleanup()
QgsMapLayerRegistry.instance().removeAllMapLayers()
for panel in self.panels:
self.removeDockWidget(panel)
del panel
# Remove all the old buttons
self.panels = []
oldproject = self.project
self.project = None
self.set_projectbuttons(False)
self.hidedataentry()
self.infodock.close()
RoamEvents.selectioncleared.emit()
RoamEvents.projectClosed.emit(oldproject)
self.projectwidget.set_open_project(None)
def __init__(self, methodName):
"""Run once on class initialisation."""
unittest.TestCase.__init__(self, methodName)
myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
rasterFileInfo = QFileInfo(myPath)
mRasterLayer = QgsRasterLayer(rasterFileInfo.filePath(),
rasterFileInfo.completeBaseName())
rasterRenderer = QgsMultiBandColorRenderer(
mRasterLayer.dataProvider(), 2, 3, 4)
mRasterLayer.setRenderer(rasterRenderer)
#pipe = mRasterLayer.pipe()
#assert pipe.set(rasterRenderer), 'Cannot set pipe renderer'
QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer])
# create composition with composer map
self.mMapRenderer = QgsMapRenderer()
layerStringList = QStringList()
layerStringList.append(mRasterLayer.id())
self.mMapRenderer.setLayerSet(layerStringList)
self.mMapRenderer.setProjectionsEnabled(False)
self.mComposition = QgsComposition(self.mMapRenderer)
self.mComposition.setPaperSize(297, 210)
self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100)
self.mComposerMap.setFrameEnabled(True)
self.mComposition.addComposerMap(self.mComposerMap)
def testStringWithMaxLen(self):
""" tests that text edit wrappers correctly handle string fields with a maximum length """
layer = QgsVectorLayer("none?field=fldint:integer", "layer", "memory")
assert layer.isValid()
layer.dataProvider().addAttributes([QgsField('max', QVariant.String, 'string', 10),
QgsField('nomax', QVariant.String, 'string', 0)])
layer.updateFields()
QgsMapLayerRegistry.instance().addMapLayer(layer)
reg = QgsEditorWidgetRegistry.instance()
config = {'IsMultiline': 'True'}
# first test for field without character limit
editor = QTextEdit()
editor.setPlainText('this_is_a_long_string')
w = reg.create('TextEdit', layer, 2, config, editor, None)
self.assertEqual(w.value(), 'this_is_a_long_string')
# next test for field with character limit
editor = QTextEdit()
editor.setPlainText('this_is_a_long_string')
w = reg.create('TextEdit', layer, 1, config, editor, None)
self.assertEqual(w.value(), 'this_is_a_')
QgsMapLayerRegistry.instance().removeAllMapLayers()
def create_layer(self, data):
display_name = 'some-layer'
uri = 'Point?crs=epsg:4326&index=yes&uuid=%s' % uuid.uuid4()
vlayer = QgsVectorLayer(uri, display_name, 'memory')
QgsMapLayerRegistry.instance().addMapLayer(vlayer)
provider = vlayer.dataProvider()
vlayer.startEditing()
provider.addAttributes([
QgsField('population_density', QtCore.QVariant.Double),
])
features = []
for x, y, density in data:
feat = QgsFeature()
geom = QgsGeometry.fromPoint(QgsPoint(x, y))
feat.setGeometry(geom)
feat.setAttributes([density])
features.append(feat)
provider.addFeatures(features)
vlayer.commitChanges()
vlayer.updateExtents()
self.canvas.setExtent(vlayer.extent())
cl = QgsMapCanvasLayer(vlayer)
self.canvas.setLayerSet([cl])
vlayer.triggerRepaint()
def test_ValueMap_representValue(self):
layer = QgsVectorLayer("none?field=number1:integer&field=number2:double&field=text1:string&field=number3:integer&field=number4:double&field=text2:string",
"layer", "memory")
assert layer.isValid()
QgsMapLayerRegistry.instance().addMapLayer(layer)
f = QgsFeature()
f.setAttributes([2, 2.5, 'NULL', None, None, None])
assert layer.dataProvider().addFeatures([f])
reg = QgsEditorWidgetRegistry.instance()
factory = reg.factory("ValueMap")
self.assertIsNotNone(factory)
# Tests with different value types occurring in the value map
config = {'two': '2', 'twoandhalf': '2.5', 'NULL text': 'NULL',
'nothing': self.VALUEMAP_NULL_TEXT}
self.assertEqual(factory.representValue(layer, 0, config, None, 2), 'two')
self.assertEqual(factory.representValue(layer, 1, config, None, 2.5), 'twoandhalf')
self.assertEqual(factory.representValue(layer, 2, config, None, 'NULL'), 'NULL text')
# Tests with null values of different types, if value map contains null
self.assertEqual(factory.representValue(layer, 3, config, None, None), 'nothing')
self.assertEqual(factory.representValue(layer, 4, config, None, None), 'nothing')
self.assertEqual(factory.representValue(layer, 5, config, None, None), 'nothing')
# Tests with fallback display for different value types
config = {}
self.assertEqual(factory.representValue(layer, 0, config, None, 2), '(2)')
self.assertEqual(factory.representValue(layer, 1, config, None, 2.5), '(2.50000)')
self.assertEqual(factory.representValue(layer, 2, config, None, 'NULL'), '(NULL)')
# Tests with fallback display for null in different types of fields
self.assertEqual(factory.representValue(layer, 3, config, None, None), '(NULL)')
self.assertEqual(factory.representValue(layer, 4, config, None, None), '(NULL)')
self.assertEqual(factory.representValue(layer, 5, config, None, None), '(NULL)')
QgsMapLayerRegistry.instance().removeAllMapLayers()
def show_qgis_layer(layer):
"""Show a QGIS layer in the map canvas.
:param layer: The layer to show.
:type layer: QgsMapLayer
"""
QgsMapLayerRegistry.instance().addMapLayer(layer)
def accept(self):
input_path = str(self.leInputPath.text())
output_path = str(self.leOutputPath.text())
if not output_path.endswith('.tif'):
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Output file name must be tif file')))
if not os.path.exists(input_path):
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Input file is not exist')))
return
my_algorithm = str(self.cboAlgorithm.currentText()).lower()
fileName = convert_mmi_data(input_path, output_path,
the_algorithm=my_algorithm,
algorithm_name=False)
if self.cBLoadLayer.isChecked():
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
my_raster_layer = QgsRasterLayer(fileName, baseName)
if not my_raster_layer.isValid():
LOGGER.debug("Failed to load")
else:
QgsMapLayerRegistry.instance().addMapLayer(my_raster_layer)
self.done(self.Accepted)
if not self.test_mode:
QMessageBox.warning(
self.parent, self.tr('InaSAFE'),
(self.tr('Success to convert %1 to %2').
arg(input_path).arg(output_path)))
def _layerRemoved(self, layerId):
if self._layerId and layerId == self._layerId:
self._layerId = ''
self.setEnabled(False)
QgsProject.instance().snapSettingsChanged.disconnect(self._refresh)
QgsMapLayerRegistry.instance().layerRemoved.disconnect(self._layerRemoved)
self.snappingEnabledChanged.disconnect(QgsProject.instance().snapSettingsChanged)
def finishInit(self):
# connect signal for layers and populate combobox
QgsMapLayerRegistry.instance().layersAdded.connect(self.__canvasLayersChanged)
QgsMapLayerRegistry.instance().layersRemoved.connect(self.__canvasLayersChanged)
if self.options.groupLayers:
self.options.legendInterface.groupRelationsChanged.connect(self.__canvasLayersChanged)
self.__canvasLayersChanged()
def testNoSliverPolygons(self):
# create a layer with some polygons that will be used as a source for "avoid intersections"
l = QgsVectorLayer('MultiPolygon', 'test_layer', 'memory')
assert l.isValid()
QgsMapLayerRegistry.instance().addMapLayer(l)
QgsProject.instance().writeEntry("Digitizing", "/AvoidIntersectionsList", [l.id()])
features = []
for i, wkt in enumerate(feat_wkt):
f = QgsFeature(i + 1)
f.setGeometry(QgsGeometry.fromWkt(wkt))
features.append(f)
l.dataProvider().addFeatures(features)
assert l.pendingFeatureCount() == 7
# create a geometry and remove its intersections with other geometries
g = QgsGeometry.fromWkt(newg_wkt)
assert g.avoidIntersections() == 0
# the resulting multi-polygon must have exactly three parts
# (in QGIS 2.0 it has one more tiny part that appears at the border between two of the original polygons)
mpg = g.asMultiPolygon()
assert len(mpg) == 3
def __init__(self, snapLayer, parent=None):
super(LayerSnappingEnabledAction, self).__init__(parent)
self._layerId = ''
self._iface = None # QgisInteface
if isinstance(snapLayer, QgisInterface):
self._iface = snapLayer
elif isinstance(snapLayer, QgsVectorLayer):
self._layerId = snapLayer.id()
elif isinstance(snapLayer, str) or isinstance(snapLayer, unicode):
self._layerId = snapLayer
self.setCheckable(True)
self.setText('Toggle Layer Snapping')
self.setStatusTip('Toggle snapping on this layer')
self.setIcon(QIcon(':/plugins/ark/snapEnable.png'))
self._refresh()
self.triggered.connect(self._triggered)
# Make sure we catch changes in the main snapping dialog
QgsProject.instance().snapSettingsChanged.connect(self._refresh)
# If using current layer, make sure we update when it changes
if self._iface:
self._iface.legendInterface().currentLayerChanged.connect(self._refresh)
# If the layer is removed then disable the button
QgsMapLayerRegistry.instance().layerRemoved.connect(self._layerRemoved)
# If we change the settings, make such others are told
self.snappingEnabledChanged.connect(QgsProject.instance().snapSettingsChanged)
def accept(self):
"""Process the layer and field and generate a new layer.
.. note:: This is called on ok click.
"""
myIndex = self.cboFields.currentIndex()
myFieldName = self.cboFields.itemData(
myIndex, QtCore.Qt.UserRole).toString()
myIndex = self.cboPolygonLayers.currentIndex()
myLayerId = self.cboPolygonLayers.itemData(
myIndex, QtCore.Qt.UserRole).toString()
myLayer = QgsMapLayerRegistry.instance().mapLayer(myLayerId)
myFileName = str(myLayer.source())
myInputLayer = safe_read_layer(myFileName)
try:
myOutputLayer = self.minimum_needs(myInputLayer, str(myFieldName))
except ValueError:
return
myNewFile = myFileName[:-4] + '_perka7' + '.shp'
myOutputLayer.write_to_file(myNewFile)
myNewLayer = QgsVectorLayer(myNewFile, 'Minimum Needs', 'ogr')
QgsMapLayerRegistry.instance().addMapLayers([myNewLayer])
self.done(QtGui.QDialog.Accepted)
def add_qgis_raser_layer(raster_layer, canvas, bands = None):
index_group = TerreImageConstant().index_group
logger.debug("index_group: " + str(index_group))
if bands:
if raster_layer.rasterType() == 2:
logger.debug(bands)
pir = bands['pir']
red = bands['red']
green = bands['green']
logger.debug('pir: ' + str(pir))
logger.debug("red: " + str(red))
logger.debug("green: " + str(green))
if pir and red and green:
renderer = raster_layer.renderer()
# raster_layer.setDrawingStyle("MultiBandColor")
renderer.setRedBand(pir)
renderer.setGreenBand(red)
renderer.setBlueBand(green)
# raster_layer.setRenderer( renderer )
# contrastForRasters( raster_layer, 0, 0, [pir, red, green] )
histogram_stretching(raster_layer, canvas)
QgsMapLayerRegistry.instance().addMapLayer(raster_layer)
TerreImageConstant().legendInterface.moveLayer(raster_layer, index_group)
def test_cboAggregationToggle(self):
"""Aggregation Combobox toggles on and off as expected."""
# With aggregation layer
myResult, myMessage = setup_scenario(
DOCK,
hazard='A flood in Jakarta like in 2007',
exposure='People',
function='Need evacuation',
function_id='Flood Evacuation Function',
aggregation_layer='kabupaten jakarta singlepart',
aggregation_enabled_flag=True)
myMessage += ' when an aggregation layer is defined.'
assert myResult, myMessage
# With no aggregation layer
myLayer = DOCK.get_aggregation_layer()
myId = myLayer.id()
QgsMapLayerRegistry.instance().removeMapLayer(myId)
myResult, myMessage = setup_scenario(
DOCK,
hazard='A flood in Jakarta like in 2007',
exposure='People',
function='Need evacuation',
function_id='Flood Evacuation Function',
aggregation_enabled_flag=False)
myMessage += ' when no aggregation layer is defined.'
assert myResult, myMessage
def loadLayers(theLayerList, theClearFlag=True, DIR=TESTDATA):
"""Helper function to load layers as defined in a python list."""
# First unload any layers that may already be loaded
if theClearFlag:
for myLayer in QgsMapLayerRegistry.instance().mapLayers():
QgsMapLayerRegistry.instance().removeMapLayer(myLayer)
# Now go ahead and load our layers
myExposureLayerCount = 0
myHazardLayerCount = 0
myCanvasLayers = []
# Now create our new layers
for myFile in theLayerList:
myLayer, myType = loadLayer(myFile, DIR)
if myType == 'hazard':
myHazardLayerCount += 1
elif myType == 'exposure':
myExposureLayerCount += 1
# Add layer to the registry (that QGis knows about)
QgsMapLayerRegistry.instance().addMapLayer(myLayer)
# Create Map Canvas Layer Instance and add to list
myCanvasLayers.append(QgsMapCanvasLayer(myLayer))
# Quickly add any existing CANVAS layers to our list first
for myLayer in CANVAS.layers():
myCanvasLayers.append(QgsMapCanvasLayer(myLayer))
# now load all these layers in the CANVAS
CANVAS.setLayerSet(myCanvasLayers)
DOCK.getLayers()
# Add MCL's to the CANVAS
return myHazardLayerCount, myExposureLayerCount
def load_table_layers(config_collection):
"""
In order to be able to use attribute tables in the composition, the
corresponding vector layers need to be added to the layer
registry. This method creates vector layers from the linked tables
in the configuration items. This is required prior to creating the
composition from file.
:param config_collection: Table configuration collection built from
the template file.
:type config_collection: TableConfigurationCollection
:returns: Valid layers that have been successfully added to the
registry.
:rtype: list
"""
table_configs = config_collection.items().values()
v_layers = []
for conf in table_configs:
layer_name = conf.linked_table()
v_layer = vector_layer(layer_name)
if v_layer is None:
return
if not v_layer.isValid():
return
v_layers.append(v_layer)
QgsMapLayerRegistry.instance().addMapLayers(v_layers, False)
return v_layers
def test_geometryTypes(self):
geo = [(1, "POINT", "(0 0)"),
(2, "LINESTRING", "(0 0,1 0)"),
(3, "POLYGON", "((0 0,1 0,1 1,0 0))"),
(4, "MULTIPOINT", "((1 1))"),
(5, "MULTILINESTRING", "((0 0,1 0),(0 1,1 1))"),
(6, "MULTIPOLYGON", "(((0 0,1 0,1 1,0 0)),((2 2,3 0,3 3,2 2)))")]
for wkb_type, wkt_type, wkt in geo:
l = QgsVectorLayer("%s?crs=epsg:4326" % wkt_type, "m1", "memory", False)
self.assertEqual(l.isValid(), True)
QgsMapLayerRegistry.instance().addMapLayer(l)
f1 = QgsFeature(1)
g = QgsGeometry.fromWkt(wkt_type + wkt)
self.assertEqual(g is None, False)
f1.setGeometry(g)
l.dataProvider().addFeatures([f1])
l2 = QgsVectorLayer("?layer_ref=%s" % l.id(), "vtab", "virtual", False)
self.assertEqual(l2.isValid(), True)
self.assertEqual(l2.dataProvider().featureCount(), 1)
self.assertEqual(l2.dataProvider().wkbType(), wkb_type)
QgsMapLayerRegistry.instance().removeMapLayer(l.id())
def accept(self):
"""Process the layer and field and generate a new layer.
.. note:: This is called on OK click.
"""
index = self.cboFields.currentIndex()
field_name = self.cboFields.itemData(
index, QtCore.Qt.UserRole)
index = self.cboPolygonLayers.currentIndex()
layer_id = self.cboPolygonLayers.itemData(
index, QtCore.Qt.UserRole)
# noinspection PyArgumentList
layer = QgsMapLayerRegistry.instance().mapLayer(layer_id)
file_name = layer.source()
input_layer = safe_read_layer(file_name)
try:
output_layer = self.minimum_needs(input_layer, field_name)
except ValueError:
return
new_file = file_name[:-4] + '_perka7' + '.shp'
output_layer.write_to_file(new_file)
new_layer = QgsVectorLayer(new_file, 'Minimum Needs', 'ogr')
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayers([new_layer])
self.done(QtGui.QDialog.Accepted)
def __init__(self, iface, parent = None):
"""Constructor."""
super(CalcContour, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.iface = iface
#insert layers into the combobox
self.populateLayers()
#instance of the QgsMapTool derived class (line tool)
self.tool = DsgLineTool(self.iface.mapCanvas())
self.tool.lineCreated.connect(self.updateLayer)
#instance of the class responsible to update layer features
self.contourTool = ContourTool()
#Connecting slot to deal with adition/removal of layers
QgsMapLayerRegistry.instance().layersAdded.connect(self.addLayers)
QgsMapLayerRegistry.instance().layersRemoved.connect(self.populateLayers)
def __init__(self, parent=None, iface=None):
QTabWidget.__init__(self, parent)
self.setupUi(self)
self._notif_bar = None
self._ol_loaded = False
self._overlay_layer = None
self.sel_highlight = None
self.memory_layer = None
self._db_session = STDMDb.instance().session
self.set_iface(iface)
#Web config
self._web_spatial_loader = WebSpatialLoader(self.spatial_web_view, self)
#Connect signals
self._web_spatial_loader.loadError.connect(self.on_spatial_browser_error)
self._web_spatial_loader.loadProgress.connect(self.on_spatial_browser_loading)
self._web_spatial_loader.loadFinished.connect(self.on_spatial_browser_finished)
self._web_spatial_loader.zoomChanged.connect(self.on_map_zoom_level_changed)
self.rbGMaps.toggled.connect(self.on_load_GMaps)
self.rbOSM.toggled.connect(self.on_load_OSM)
self.zoomSlider.sliderReleased.connect(self.on_zoom_changed)
self.btnResetMap.clicked.connect(self.on_reset_web_map)
self.btnSync.clicked.connect(self.on_sync_extents)
QgsMapLayerRegistry.instance().layersWillBeRemoved.connect(self._on_overlay_to_be_removed)
def add_layer_to_canvas(layer, name, impact_function):
"""Helper method to add layer to QGIS.
:param layer: The layer.
:type layer: QgsMapLayer
:param name: Layer name.
:type name: str
:param impact_function: The impact function used.
:type impact_function: ImpactFunction
:param iface: QGIS QGisAppInterface instance.
:type iface: QGisAppInterface
"""
group_name = impact_function.name
# noinspection PyArgumentList
root = QgsProject.instance().layerTreeRoot()
group_analysis = root.findGroup(group_name)
group_analysis.setVisible(Qt.Checked)
layer.setLayerName(name)
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
layer_node = group_analysis.addLayer(layer)
layer_node.setVisible(Qt.Checked)
def tearDown(self):
"""Destroy the dialog after each test."""
# Clear all the loaded layers in Map Registry
# noinspection PyArgumentList,PyUnresolvedReferences
for layer in QgsMapLayerRegistry.instance().mapLayers():
# noinspection PyArgumentList,PyUnresolvedReferences
QgsMapLayerRegistry.instance().removeMapLayer(layer)
def prepare_ordered_marker(self, coords, idx):
"""
Try to display nice marker on a point layer, showing the order of
the path computed by OSRM.
"""
self.tsp_marker_lr = QgsVectorLayer(
"Point?crs=epsg:4326&field=id:integer"
"&field=TSP_nb:integer(20)&field=Origin_nb:integer(20)",
"tsp_markers_osrm{}".format(self.nb_route), "memory")
symbol = QgsSymbolV2.defaultSymbol(self.tsp_marker_lr.geometryType())
symbol.setSize(4.5)
symbol.setColor(QtGui.QColor("yellow"))
ordered_pts = \
[coords[i["waypoint_index"]] for i in self.parsed['waypoints']]
print("ordered_pts : ", ordered_pts)
features = []
for nb, pt in enumerate(ordered_pts):
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(pt)))
ft.setAttributes([nb, nb + 1, coords.index(pt)])
features.append(ft)
self.tsp_marker_lr.dataProvider().addFeatures(features)
pal_lyr = QgsPalLayerSettings()
pal_lyr.readFromLayer(self.tsp_marker_lr)
pal_lyr.enabled = True
pal_lyr.fieldName = 'TSP_nb'
pal_lyr.placement= QgsPalLayerSettings.OverPoint
pal_lyr.setDataDefinedProperty(QgsPalLayerSettings.Size,True,True,'12','')
pal_lyr.writeToLayer(self.tsp_marker_lr)
self.tsp_marker_lr.setRendererV2(QgsSingleSymbolRendererV2(symbol))
QgsMapLayerRegistry.instance().addMapLayer(self.tsp_marker_lr)
def Xtest_print_impact_table(self):
"""Test print impact table to pdf."""
impact_layer_path = test_data_path(
'impact', 'population_affected_entire_area.shp')
layer, _ = load_layer(impact_layer_path)
# noinspection PyUnresolvedReferences,PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(layer)
# noinspection PyCallingNonCallable
rect = QgsRectangle(106.8194, -6.2108, 106.8201, -6.1964)
CANVAS.setExtent(rect)
CANVAS.refresh()
template = resources_path(
'qgis-composer-templates', 'a4-portrait-blue.qpt')
report = ImpactReport(IFACE, template, layer)
report.template = template # just to cover set template
out_path = unique_filename(
prefix='test_print_impact_table',
suffix='.pdf',
dir=temp_dir('test'))
report.print_impact_table(out_path)
# Check the file exists
message = 'Rendered output does not exist: %s' % out_path
self.assertTrue(os.path.exists(out_path), message)
# Check the file is not corrupt
message = 'The output file %s is corrupt' % out_path
out_size = os.stat(out_path).st_size
self.assertTrue(out_size > 0, message)
def return_batch_route(self, features):
"""Save and/or display the routes retrieved"""
osrm_batch_route_layer = QgsVectorLayer(
"Linestring?crs=epsg:4326&field=id:integer"
"&field=total_time:integer(20)&field=distance:integer(20)",
"routes_osrm{}".format(self.nb_done), "memory")
provider = osrm_batch_route_layer.dataProvider()
provider.addFeatures(features)
QgsMapLayerRegistry.instance().addMapLayer(osrm_batch_route_layer)
if self.filename:
error = QgsVectorFileWriter.writeAsVectorFormat(
osrm_batch_route_layer, self.filename,
self.encoding, None, "ESRI Shapefile")
if error != QgsVectorFileWriter.NoError:
self.iface.messageBar().pushMessage(
"Error",
"Can't save the result into {} - Output have been "
"added to the canvas (see QGis log for error trace"
"back)".format(self.filename), duration=10)
QgsMessageLog.logMessage(
'OSRM-plugin error report :\n {}'.format(error),
level=QgsMessageLog.WARNING)
self.iface.setActiveLayer(osrm_batch_route_layer)
return -1
else:
QtGui.QMessageBox.information(
self.iface.mainWindow(), 'Info',
"Result saved in {}".format(self.filename))
if self.check_add_layer.isChecked():
self.iface.setActiveLayer(osrm_batch_route_layer)
else:
QgsMapLayerRegistry.instance().removeMapLayer(
osrm_batch_route_layer.id())
self.iface.messageBar().clearWidgets()
def testRenderMarkerLayerDataDefined(self):
""" test that rendering a marker symbol with data defined enabled layer works"""
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(points_layer)
layer = QgsSimpleMarkerSymbolLayer()
layer.setDataDefinedProperty("enabled", QgsDataDefined("Class='Biplane'"))
layer.setColor(QColor(100, 150, 150))
layer.setSize(5)
layer.setOutlineStyle(Qt.NoPen)
symbol = QgsMarkerSymbol()
symbol.changeSymbolLayer(0, layer)
points_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([points_layer.id()])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_layer')
renderchecker.setControlName('expected_markerlayer_ddenabled')
self.assertTrue(renderchecker.runTest('markerlayer_ddenabled'))
QgsMapLayerRegistry.instance().removeMapLayer(points_layer)
def createLayers(self):
types = [("Point", ptOursStyle, ptTheirsStyle),
("LineString", lineOursStyle, lineTheirsStyle),
("Polygon", polygonOursStyle, polygonTheirsStyle)]
if self.oursgeom is not None:
geomtype = types[int(self.oursgeom.type())][0]
style = types[int(self.oursgeom.type())][1]
self.oursLayer = loadLayerNoCrsDialog(geomtype + "?crs=EPSG:4326", "ours", "memory")
pr = self.oursLayer.dataProvider()
feat = QgsFeature()
feat.setGeometry(self.oursgeom)
pr.addFeatures([feat])
self.oursLayer.loadNamedStyle(style)
self.oursLayer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(self.oursLayer, False)
else:
self.oursLayer = None
if self.theirsgeom is not None:
geomtype = types[int(self.theirsgeom.type())][0]
style = types[int(self.theirsgeom.type())][2]
self.theirsLayer = loadLayerNoCrsDialog(geomtype + "?crs=EPSG:4326", "theirs", "memory")
pr = self.theirsLayer.dataProvider()
feat = QgsFeature()
feat.setGeometry(self.theirsgeom)
pr.addFeatures([feat])
self.theirsLayer.loadNamedStyle(style)
self.theirsLayer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(self.theirsLayer, False)
else:
self.theirsLayer = None
def test_add_layer_to_registry(self):
layer_name = layer_interaction.biuniquify_layer_name('this_layer_was_added_for_testing_purpose')
layer = QgsVectorLayer('Polygon?crs=EPSG:3857', layer_name, 'memory', False)
number_of_layers = len(QgsMapLayerRegistry.instance().mapLayers())
layer_interaction.add_layer_to_registry(layer)
self.layer_list.append(layer.name())
map_layers = QgsMapLayerRegistry.instance().mapLayers()
actual = len(map_layers)
expected = number_of_layers + 1
message = 'An error occured when adding a layer to the MapLayerRegistry. {} is not {}!'.format(actual, expected)
self.assertEqual(actual, expected, message)
layer_added = False
for layer_key in map_layers:
if map_layers[layer_key].name() == layer_name:
layer_added = True
break
self.assertTrue(layer_added, 'An error occured when adding a layer to the MapLayerRegistry.')
number_of_layers = len(map_layers)
layer_interaction.add_layer_to_registry(None)
self.assertEqual(len(QgsMapLayerRegistry.instance().mapLayers()), number_of_layers, 'An error occured when trying to add a none-type-layer to the MapLayerRegistry. The number of layers should not increase.')
def testRenderLineLayerDataDefined(self):
""" test that rendering a line symbol with data defined enabled layer works"""
lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(lines_layer)
layer = QgsSimpleLineSymbolLayer()
layer.setDataDefinedProperty("enabled", QgsDataDefined("Name='Highway'"))
layer.setColor(QColor(100, 150, 150))
layer.setWidth(5)
symbol = QgsLineSymbol()
symbol.changeSymbolLayer(0, layer)
lines_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([lines_layer.id()])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_layer')
renderchecker.setControlName('expected_linelayer_ddenabled')
self.assertTrue(renderchecker.runTest('linelayer_ddenabled'))
QgsMapLayerRegistry.instance().removeMapLayer(lines_layer)
def build_index(self, project):
self.searchbox.setEnabled(False)
self.resultsView.setEnabled(False)
self.resultsView.addItem("building search index...")
validformat, settings = valid_search_settings(project.settings)
if not validformat:
RoamEvents.raisemessage("Searching", "Invalid search config.", level=1)
self.searchbox.hide()
self.resultsView.clear()
self.resultsView.addItem("Invalid search config found")
return
self.indexthread = QThread()
path = os.path.join(os.environ['APPDATA'], "roam", project.name)
roam.utils.info("Search index path: {0}".format(path))
if not os.path.exists(path):
os.makedirs(path)
self.indexbuilder = IndexBuilder(path, settings)
self.indexbuilder.moveToThread(self.indexthread)
QgsMapLayerRegistry.instance().removeAll.connect(self.indexthread.quit)
self.indexbuilder.indexBuilt.connect(self.index_built)
self.indexbuilder.finished.connect(self.indexthread.quit)
self.indexthread.started.connect(self.indexbuilder.build_index)
self.indexthread.finished.connect(self.indexbuilder.quit)
self.indexthread.start()
def tearDown(self):
QgsMapLayerRegistry.instance().removeAllMapLayers()
def on_add_to_canvas_button_clicked(self):
"""
Add STDM layer to map canvas.
"""
if self.stdm_layers_combo.count() == 0:
return
sp_col_info = self.stdm_layers_combo.itemData(
self.stdm_layers_combo.currentIndex())
if sp_col_info is None:
title = QApplication.translate('SpatialUnitManagerDockWidget',
'Spatial Unit Manager')
msg = QApplication.translate(
'SpatialUnitManagerDockWidget',
'Spatial Column Layer Could not be found')
# Message: Spatial column information
# could not be found
QMessageBox.warning(self.iface.mainWindow(), title, msg)
table_name, spatial_column = sp_col_info["table_name"], \
sp_col_info["column_name"]
# Check if the layer has already been
layer_item = sp_col_info.get('item', None)
layer_name = self.geom_col_layer_name(table_name, layer_item)
if layer_name in self._map_registry_layer_names():
layer = QgsMapLayerRegistry.instance().mapLayersByName(
layer_name)[0]
self.iface.setActiveLayer(layer)
return
self.curr_lyr_table = table_name
self.curr_lyr_sp_col = spatial_column
if not layer_item is None:
if isinstance(layer_item, str) or isinstance(layer_item, unicode):
layer_name = layer_item
else:
layer_name = layer_item.layer_display()
entity = self._curr_profile.entity_by_name(table_name)
if entity is not None:
geom_col_obj = entity.columns[spatial_column]
srid = None
if geom_col_obj.srid >= 100000:
srid = geom_col_obj.srid
curr_layer = vector_layer(table_name,
geom_column=spatial_column,
layer_name=layer_name,
proj_wkt=srid)
else:
curr_layer = vector_layer(table_name,
geom_column=spatial_column,
layer_name=layer_name,
proj_wkt=None)
# for lookup layer.
else:
curr_layer = vector_layer(table_name, geom_column=spatial_column)
if curr_layer.isValid():
if curr_layer.name() in self._map_registry_layer_names():
return
QgsMapLayerRegistry.instance().addMapLayer(curr_layer)
self.zoom_to_layer()
self.onLayerAdded.emit(spatial_column, curr_layer)
self.toggle_entity_multi_layers(curr_layer)
self.set_canvas_crs(curr_layer)
# Required in order for the layer name to be set
if layer_name is not None:
QTimer.singleShot(
100, lambda: self._set_layer_display_name(
curr_layer, layer_name))
entity = self._curr_profile.entity_by_name(self.curr_lyr_table)
fk_fields = self.join_fk_layer(curr_layer, entity)
if entity is not None:
self.sort_joined_columns(curr_layer, fk_fields)
self.set_field_alias(curr_layer, entity, fk_fields)
else:
msg = QApplication.translate(
"Spatial Unit Manager",
"'{0}.{1}' layer is invalid, it cannot "
"be added to the map view.".format(table_name, spatial_column))
QMessageBox.critical(self.iface.mainWindow(),
'Spatial Unit Manager', msg)
def responseComplete(self):
"""Create a QGIS Project.
Example :
SERVICE=MAPCOMPOSITION&
PROJECT=/destination/project.qgs&
FILES=/path/1.shp;/path/2.shp;/path/3.asc&
NAMES=Layer 1;Layer 2;Layer 3&
REMOVEQML=true&
OVERWRITE=true
"""
request = self.serverInterface().requestHandler()
params = request.parameterMap()
if params.get('SERVICE', '').upper() == 'MAPCOMPOSITION':
request.clearHeaders()
request.setHeader('Content-type', 'text/plain')
request.clearBody()
project_path = params.get('PROJECT')
if not project_path:
request.appendBody('PROJECT parameter is missing.\n')
return
overwrite = params.get('OVERWRITE')
if overwrite:
if overwrite.upper() in ['1', 'YES', 'TRUE']:
overwrite = True
else:
overwrite = False
else:
overwrite = False
remove_qml = params.get('REMOVEQML')
if remove_qml:
if remove_qml.upper() in ['1', 'YES', 'TRUE']:
remove_qml = True
else:
remove_qml = False
else:
remove_qml = False
if exists(project_path):
if not overwrite:
msg = 'PROJECT is already existing : %s \n' % project_path
request.appendBody(msg)
return
else:
remove(project_path)
files_parameters = params.get('FILES')
if not files_parameters:
request.appendBody('FILES parameter is missing.\n')
return
files = files_parameters.split(';')
for layer_file in files:
if not exists(layer_file):
request.appendBody('file not found : %s.\n' % layer_file)
return
names_parameters = params.get('NAMES', None)
if names_parameters:
names = names_parameters.split(';')
if len(names) != len(files):
request.appendBody(
'Not same length between NAMES and FILES')
return
else:
names = [
splitext(basename(layer_file))[0] for layer_file in files]
QgsMessageLog.logMessage('Setting up project to %s' % project_path)
project = QgsProject.instance()
project.setFileName(project_path)
qml_files = []
qgis_layers = []
vector_layers = []
raster_layer = []
for layer_name, layer_file in zip(names, files):
if layer_file.endswith(('shp', 'geojson')):
qgis_layer = QgsVectorLayer(layer_file, layer_name, 'ogr')
vector_layers.append(qgis_layer.id())
elif layer_file.endswith(('asc', 'tiff', 'tif')):
qgis_layer = QgsRasterLayer(layer_file, layer_name)
raster_layer.append(qgis_layer.id())
else:
request.appendBody('Invalid format : %s' % layer_file)
return
if not qgis_layer.isValid():
request.appendBody('Layer is not valid : %s' % layer_file)
return
qgis_layers.append(qgis_layer)
qml_file = splitext(layer_file)[0] + '.qml'
if exists(qml_file):
# Check if there is a QML
qml_files.append(qml_file)
style_manager = qgis_layer.styleManager()
style_manager.renameStyle('', 'default')
# Add layer to the registry
QgsMapLayerRegistry.instance().addMapLayer(qgis_layer)
if len(vector_layers):
for layer_file in vector_layers:
project.writeEntry(
'WFSLayersPrecision', '/%s' % layer_file, 8)
project.writeEntry('WFSLayers', '/', vector_layers)
if len(raster_layer):
project.writeEntry('WCSLayers', '/', raster_layer)
project.write()
project.clear()
if not exists(project_path) and not isfile(project_path):
request.appendBody(project.error())
return
generate_legend(qgis_layers, project_path)
if remove_qml:
for qml in qml_files:
QgsMessageLog.logMessage(
'Removing QML {path}'.format(path=qml))
remove(qml)
request.appendBody('OK')
def open_file(
dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
output_format=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None):
"""
open an osm file
"""
outputs = get_outputs(output_dir, output_format, prefix_file, layer_name)
# Parsing the file
osm_parser = OsmParser(
osm_file=osm_file,
layers=output_geom_types,
white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
layers = osm_parser.parse()
# Finishing the process with geojson or shapefile
num_layers = 0
if output_format == "shape":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to Shapefile"))
for i, (layer, item) in enumerate(layers.iteritems()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
# Transforming the vector file
osm_geometries = {
'points': QGis.WKBPoint,
'lines': QGis.WKBLineString,
'multilinestrings': QGis.WKBMultiLineString,
'multipolygons': QGis.WKBMultiPolygon}
geojson_layer = QgsVectorLayer(item['geojsonFile'], "temp", "ogr")
encoding = get_default_encoding()
if output_format == "shape":
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
"ESRI Shapefile")
else:
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
"GeoJSON")
for f in geojson_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name, "ogr")
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))),
"styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
actions = new_layer.actions()
actions.addAction(
QgsAction.OpenUrl,
"OpenStreetMap Browser",
'http://www.openstreetmap.org/browse/'
'[% "osm_type" %]/[% "osm_id" %]',
False)
actions.addAction(
QgsAction.GenericPython,
'JOSM',
'from QuickOSM.CoreQuickOSM.Actions import Actions;'
'Actions.run("josm","[% "full_id" %]")',
False)
actions.addAction(
QgsAction.OpenUrl,
"User default editor",
'http://www.openstreetmap.org/edit?'
'[% "osm_type" %]=[% "osm_id" %]',
False)
for link in ['url', 'website', 'wikipedia', 'ref:UAI']:
if link in item['tags']:
link = link.replace(":", "_")
actions.addAction(
QgsAction.GenericPython,
link,
'from QuickOSM.core.actions import Actions;'
'Actions.run("' + link + '","[% "' + link + '" %]")',
False)
if 'network' in item['tags'] and 'ref' in item['tags']:
actions.addAction(
QgsAction.GenericPython,
"Sketchline",
'from QuickOSM.core.actions import Actions;'
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")',
False)
# Add index if possible
if output_format == "shape":
new_layer.dataProvider().createSpatialIndex()
QgsMapLayerRegistry.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
# Start qGIS, then copy and paste ALL lines of this script into the Python Console (Ctrl+Alt+P)
# Note: You will need to change the value of `directoryContainingWktFiles` to the correct folder
from qgis.core import QgsVectorLayer, QgsMapLayerRegistry
import os, PyQt4
# Remember, no backslashes '\' in paths, only forward slashes '/'
directoryContainingWktFiles = 'D:/Dropbox/VATSIM/ZDC/vSTARSZDC/vSTARS Facility - Potomac TRACON (PCT)/Video Map WKTs'
for root, dirs, files in os.walk(directoryContainingWktFiles):
for file in files:
fullname = os.path.join(root, file).replace('\\', '/')
filename = os.path.splitext(os.path.basename(fullname))[0]
uri = PyQt4.QtCore.QUrl.fromLocalFile(fullname)
uri.addQueryItem('delimiter', '|')
uri.addQueryItem('useHeader', 'yes')
uri.addQueryItem('wktField', 'wkt')
uri.addQueryItem('crs', 'ESPG:4326')
layer = QgsVectorLayer(str(uri.toEncoded()), filename, 'delimitedtext')
if layer.isValid():
QgsMapLayerRegistry.instance().addMapLayer(layer)
else:
print('file invalid')
def run(self, fid = 0):
##################################
###### PEGA A LAYER ATIVA ########
##################################
parametros = self.layer.source().split(" ") # recebe todos os parametros em uma lista ( senha, porta, password etc..)
####################################
###### INICIANDO CONEXÃO DB ########
####################################
# Outra opção para isso, seria usar ex: self.dbname.. self.host.. etc.. direto dentro do laço for.
dbname = ""
host = ""
port = 0
user = ""
password = ""
for i in parametros:
part = i.split("=")
# Recebe os parametros guardados na própria Layer
if "dbname" in part[0]:
dbname = part[1].replace("'", "")
elif "host" in part[0]:
host = part[1].replace("'", "")
elif "port" in part[0]:
port = int(part[1].replace("'", ""))
elif "user" in part[0]:
user = part[1].replace("'", "")
elif "password" in part[0]:
password = part[1].split("|")[0].replace("'", "")
print dbname, host, port, user, password
# Testa se os parametros receberam os valores pretendidos, caso não, apresenta a mensagem informando..
if len(dbname) == 0 or len(host) == 0 or port == 0 or len(user) == 0 or len(password) == 0:
self.iface.messageBar().pushMessage("Erro", u'Um dos parametros não foram devidamente recebidos!', level=QgsMessageBar.CRITICAL, duration=4)
return
####################################
#### SETA VALORES DE CONEXÃO DB ####
####################################
connection = QSqlDatabase.addDatabase('QPSQL')
connection.setHostName(host)
connection.setPort(port)
connection.setUserName(user)
connection.setPassword(password)
connection.setDatabaseName(dbname)
if not connection.isOpen(): # Testa se a conexão esta recebendo os parametros adequadamente.
if not connection.open():
print 'Error connecting to database!'
self.iface.messageBar().pushMessage("Erro", u'Error connecting to database!', level=QgsMessageBar.CRITICAL, duration=4)
print connection.lastError().text()
return
####################################
###### CRIAÇÃO DE MEMORY LAYER #####
####################################
layerCrs = self.layer.crs().authid() # Passa o formato (epsg: numeros)
flagsLayerName = self.layer.name() + "_flags"
flagsLayerExists = False
for l in QgsMapLayerRegistry.instance().mapLayers().values(): # Recebe todas as camadas que estão abertas
if l.name() == flagsLayerName: # ao encontrar o nome pretendido..
self.flagsLayer = l # flagslayer vai receber o nome..
self.flagsLayerProvider = l.dataProvider()
flagsLayerExists = True # se encontrado os parametros buscados, recebe True.
break
if flagsLayerExists == False: # se não encontrado os parametros buscados, recebe False.
tempString = "Point?crs="
tempString += str(layerCrs)
self.flagsLayer = QgsVectorLayer(tempString, flagsLayerName, "memory")
self.flagsLayerProvider = self.flagsLayer.dataProvider()
self.flagsLayerProvider.addAttributes([QgsField("flagId", QVariant.String), QgsField("geomId", QVariant.String), QgsField("motivo", QVariant.String)])
self.flagsLayer.updateFields()
if fid == 0: # Se for 0 então está iniciando e limpa, caso contrário não.
self.flagsLayer.startEditing()
ids = [feat.id() for feat in self.flagsLayer.getFeatures()]
self.flagsLayer.deleteFeatures(ids)
self.flagsLayer.commitChanges()
lista_fid = [] # Iniciando lista
for f in self.layer.getFeatures():
lista_fid.append(str(f.id())) # Guarda na lista. A lista de Feature ids passa tipo "int", foi convertido e guardado como "str".
source = self.layer.source().split(" ")
self.tableName = " " # Inicia vazio
layerExistsInDB = False
for i in source:
if "table=" in i or "layername=" in i: # Se encontrar os atributos pretendidos dentre todos do for
self.tableName = source[source.index(i)].split(".")[1] # Faz split em ponto e pega a segunda parte.
self.tableName = self.tableName.replace('"', '')
layerExistsInDB = True
break
if layerExistsInDB == False:
self.iface.messageBar().pushMessage("Erro", u"Provedor da camada corrente não provem do banco de dados!", level=QgsMessageBar.CRITICAL, duration=4)
return
##############################
#### Busca através do SQL ####
##############################
sql = """select foo."{3}" as "{3}", ST_AsText(ST_MULTI(st_startpoint(foo."{2}"))) as "{2}" from (
select "{3}" as "{3}", (ST_Dump(ST_Node(ST_SetSRID(ST_MakeValid("{2}"),ST_SRID("{2}"))))).geom as "{2}" from "{0}"."{1}"
where ST_IsSimple("{2}") = 'f' and {3} in ({4})) as foo where st_equals(st_startpoint(foo."{2}"),st_endpoint(foo."{2}"))""".format(self.tableSchema, self.tableName, self.geometryColumn, self.keyColumn, ",".join(lista_fid))
query = QSqlQuery(sql)
self.flagsLayer.startEditing()
flagCount = fid # iniciando contador que será referência para os IDs da camada de memória.
listaFeatures = []
while query.next():
id = query.value(0) # recebendo valores buscados no sql.
local = query.value(1) # recebendo valores buscados no sql.
motivo = query.value(2)
flagId = str(flagCount)
flagFeat = QgsFeature()
flagFeat.setFields(self.flagsLayer.fields()) # passa quais atributos serão usados.
flagGeom = QgsGeometry.fromWkt(local) # passa o local onde foi localizado o erro.
flagFeat.setGeometry(flagGeom)
flagFeat.setAttribute(0, flagId) # insere o id definido para a coluna 0 da layer de memória.
flagFeat.setAttribute(1, id) # insere o id da geometria para a coluna 1 da layer de memória.
flagFeat.setAttribute(2, u"NotSimple-Geom.")
listaFeatures.append(flagFeat)
flagCount += 1 # incrementando o contador a cada iteração.
self.flagsLayerProvider.addFeatures(listaFeatures)
self.flagsLayer.commitChanges() # Aplica as alterações à camada.
QgsMapLayerRegistry.instance().addMapLayer(self.flagsLayer) # Adicione a camada no mapa.
return flagCount
def accept(self):
layer = self.inputPolyComboBox.currentLayer()
if not layer:
self.iface.messageBar().pushMessage("",
"No Valid Layer",
level=QgsMessageBar.WARNING,
duration=4)
layercrs = layer.crs()
wkbtype = layer.wkbType()
polyname = self.geodesicPolyNameLineEdit.text()
# Get the field names for the input layer. The will be copied to the output layers
fields = layer.pendingFields()
# Create the points and polygon output layers
if wkbtype == QGis.WKBPolygon:
polyLayer = QgsVectorLayer(
"Polygon?crs={}".format(layercrs.authid()), polyname, "memory")
else:
polyLayer = QgsVectorLayer(
"MultiPolygon?crs={}".format(layercrs.authid()), polyname,
"memory")
ppoly = polyLayer.dataProvider()
ppoly.addAttributes(fields)
polyLayer.updateFields()
if layercrs != epsg4326:
transto4326 = QgsCoordinateTransform(layercrs, epsg4326)
transfrom4326 = QgsCoordinateTransform(epsg4326, layercrs)
iter = layer.getFeatures()
num_features = 0
num_bad = 0
maxseglen = settings.maxSegLength * 1000.0
maxSegments = settings.maxSegments
for feature in iter:
num_features += 1
try:
if wkbtype == QGis.WKBPolygon:
poly = feature.geometry().asPolygon()
numpolygons = len(poly)
if numpolygons < 1:
continue
ptset = []
for points in poly:
numpoints = len(points)
if numpoints < 2:
continue
# If the input is not 4326 we need to convert it to that and then back to the output CRS
ptStart = QgsPoint(points[0][0], points[0][1])
if layercrs != epsg4326: # Convert to 4326
ptStart = transto4326.transform(ptStart)
pts = [ptStart]
for x in range(1, numpoints):
ptEnd = QgsPoint(points[x][0], points[x][1])
if layercrs != epsg4326: # Convert to 4326
ptEnd = transto4326.transform(ptEnd)
l = self.geod.InverseLine(ptStart.y(), ptStart.x(),
ptEnd.y(), ptEnd.x())
n = int(math.ceil(l.s13 / maxseglen))
if n > maxSegments:
n = maxSegments
seglen = l.s13 / n
for i in range(1, n):
s = seglen * i
g = l.Position(
s, Geodesic.LATITUDE | Geodesic.LONGITUDE
| Geodesic.LONG_UNROLL)
pts.append(QgsPoint(g['lon2'], g['lat2']))
pts.append(ptEnd)
ptStart = ptEnd
if layercrs != epsg4326: # Convert each point to the output CRS
for x, pt in enumerate(pts):
pts[x] = transfrom4326.transform(pt)
ptset.append(pts)
if len(ptset) > 0:
featureout = QgsFeature()
featureout.setGeometry(QgsGeometry.fromPolygon(ptset))
featureout.setAttributes(feature.attributes())
ppoly.addFeatures([featureout])
else:
multipoly = feature.geometry().asMultiPolygon()
multiset = []
for poly in multipoly:
ptset = []
for points in poly:
numpoints = len(points)
if numpoints < 2:
continue
# If the input is not 4326 we need to convert it to that and then back to the output CRS
ptStart = QgsPoint(points[0][0], points[0][1])
if layercrs != epsg4326: # Convert to 4326
ptStart = transto4326.transform(ptStart)
pts = [ptStart]
for x in range(1, numpoints):
ptEnd = QgsPoint(points[x][0], points[x][1])
if layercrs != epsg4326: # Convert to 4326
ptEnd = transto4326.transform(ptEnd)
l = self.geod.InverseLine(
ptStart.y(), ptStart.x(), ptEnd.y(),
ptEnd.x())
n = int(math.ceil(l.s13 / maxseglen))
if n > maxSegments:
n = maxSegments
seglen = l.s13 / n
for i in range(1, n):
s = seglen * i
g = l.Position(
s,
Geodesic.LATITUDE | Geodesic.LONGITUDE
| Geodesic.LONG_UNROLL)
pts.append(QgsPoint(g['lon2'], g['lat2']))
pts.append(ptEnd)
ptStart = ptEnd
if layercrs != epsg4326: # Convert each point to the output CRS
for x, pt in enumerate(pts):
pts[x] = transfrom4326.transform(pt)
ptset.append(pts)
multiset.append(ptset)
if len(multiset) > 0:
featureout = QgsFeature()
featureout.setGeometry(
QgsGeometry.fromMultiPolygon(multiset))
featureout.setAttributes(feature.attributes())
ppoly.addFeatures([featureout])
except:
num_bad += 1
pass
polyLayer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(polyLayer)
if num_bad != 0:
self.iface.messageBar().pushMessage(
"",
"{} out of {} features failed".format(num_bad, num_features),
level=QgsMessageBar.WARNING,
duration=3)
self.close()
def load_knmi(self):
# KNMI
# http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi?SERVICE=WMS&&SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&LAYERS=RADNL_OPER_R___25PCPRR_L3_COLOR&WIDTH=886&HEIGHT=603&CRS=EPSG%3A3857&BBOX=-725.7203842048766,6434348.070664023,1220725.7203842048,7265651.929335977&STYLES=default&FORMAT=image/png&TRANSPARENT=TRUE&time=2016-06-15T08%3A30%3A00Z
# http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi?TIME=2016-06-14T09:25:02Z/2016-06-14T10:25:02Z&&SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&BBOX=41607.58263816371618,373175.3892402839847,308340.3808564461069,650052.614857714274&CRS=EPSG:28992&WIDTH=1451&HEIGHT=1507&LAYERS=RADNL_OPER_R___25PCPRR_L3_COLOR&STYLES=&FORMAT=image/png&DPI=96&MAP_RESOLUTION=96&FORMAT_OPTIONS=dpi:96&TRANSPARENT=TRUE
# http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi?SERVICE=WMS&&SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&LAYERS=RADNL_OPER_R___25PCPRR_L3_COLOR&WIDTH=886&HEIGHT=603&CRS=EPSG%3A3857&BBOX=-725.7203842048766,6434348.070664023,1220725.7203842048,7265651.929335977&STYLES=default&FORMAT=image/png&TRANSPARENT=TRUE
# Timestart en end
# 2016-06-13T18:00:00Z
# 2016-06-15T18:00:00Z
if not 'timemanager' in plugins:
self.iface.messageBar().pushWarning(
"Warning!!",
"No TimeManger plugin, we REALLY need that. Please install via Plugin Manager first..."
)
return
# development: remove the knmi layer from mapcanvas
for l in QgsMapLayerRegistry.instance().mapLayersByName("knmi"):
QgsMapLayerRegistry.instance().removeMapLayer(l)
tm = plugins['timemanager']
# TODO try catch this
from timemanager.layer_settings import LayerSettings
from timemanager.raster.wmstlayer import WMSTRasterLayer
#from timemanager.tmlogging import info
#TODO click on button if not enabled
if not tm.getController().getTimeLayerManager().isEnabled():
tm.getController().getGui().dock.pushButtonToggleTime.click()
# for testing: just remove all timelayers
tm.getController().timeLayerManager.clearTimeLayerList()
# # DEZE WERKT NIET !!!! (?? zelfde probleem als eerder??)
# url = "http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi?SERVICE=WMS"
# # DEZE WERKT WEL !!!!
# url = "http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi"
# layers = "RADNL_OPER_R___25PCPRR_L3_COLOR"
# styles = ""
# imgformat = "image/png"
# crs = "EPSG:28992"
settings = RegenRadarSettings()
name = settings.value("name")
url = settings.value("url")
layers = settings.value("layers")
styles = settings.value("styles")
imgformat = settings.value("imgformat")
crs = settings.value("crs")
# IgnoreGetMapUrl=1&contextualWMSLegend=0&crs=EPSG:28992&dpiMode=7&featureCount=10&format=image/png&layers=RADNL_OPER_R___25PCPRR_L3_COLOR&styles=&url=http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi?
uri = "crs=" + crs + "&layers=" + layers + "&styles=" + styles + "&format=" + imgformat + "&url=" + url
layer = self.iface.addRasterLayer(uri, name, "wms")
tlayer_settings = LayerSettings()
# endTimeAttribute !!! NOT toTimeAttribute
#settings.startTimeAttribute = unicode("2016-06-13T18:00:00Z")
#settings.endTimeAttribute = unicode("2016-06-15T18:00:00Z")
DEFAULT_DATE_FORMAT = 'yyyy-MM-ddTHH:mm:ssZ'
end = QDateTime.currentDateTime().toUTC() # now in UTC
time = end.time()
minute = time.minute()
# prefer times which are %5=0 (that is 0, 5, 15 ... minutes)
time.setHMS(time.hour(), minute - minute % 5, 0, 0)
end.setTime(time)
tlayer_settings.endTimeAttribute = end.toString(DEFAULT_DATE_FORMAT)
hours = settings.value("hours")
start = end.addSecs(-hours * 60 * 60).toString(DEFAULT_DATE_FORMAT)
tlayer_settings.startTimeAttribute = start
# NOK
# http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi?TIME=2016-07-05T13:45:00Z/2016-07-05T13:50:00Z&&SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&BBOX=-145108.7003207547241,299063.8299999999581,436757.3003207547008,626788.5699999999488&CRS=EPSG:28992&WIDTH=941&HEIGHT=530&LAYERS=RADNL_OPER_R___25PCPRR_L3_COLOR&STYLES=&FORMAT=image/png&DPI=96&MAP_RESOLUTION=96&FORMAT_OPTIONS=dpi:96&TRANSPARENT=TRUE
# OK
# http://geoservices.knmi.nl/cgi-bin/RADNL_OPER_R___25PCPRR_L3.cgi?TIME=2016-06-13T18:05:00Z/2016-06-13T18:10:00Z&&SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&BBOX=-145108.7003207547241,299063.8299999999581,436757.3003207547008,626788.5699999999488&CRS=EPSG:28992&WIDTH=941&HEIGHT=530&LAYERS=RADNL_OPER_R___25PCPRR_L3_COLOR&STYLES=&FORMAT=image/png&DPI=96&MAP_RESOLUTION=96&FORMAT_OPTIONS=dpi:96&TRANSPARENT=TRUE
#settings.startTimeAttribute = unicode("2016-06-13T18:00:00Z")
#settings.endTimeAttribute = unicode("2016-06-15T18:00:00Z")
tlayer_settings.layer = layer
timelayer = WMSTRasterLayer(tlayer_settings, self.iface)
# ??
# iface.mapCanvas().mapCanvasRefreshed.disconnect(tm.getController().waitAfterRenderComplete)
# iface.mapCanvas().mapCanvasRefreshed.connect(tm.getController().waitAfterRenderComplete)
# print timelayer
# print timelayer.getTimeExtents()
# tm.getController().refreshGuiTimeExtents([
# QtCore.QDateTime.fromString("2016-06-13T18:00:00Z", 'yyyy-MM-ddTHH:mm:ssZ'),
# QtCore.QDateTime.fromString("2016-06-15T18:00:00Z", 'yyyy-MM-ddTHH:mm:ssZ')])
animationFrameLength = 2000
frame_type = 'minutes'
frame_size = 5 # TODO: make this a parameter?
tm.getController().setPropagateGuiChanges(False)
tm.getController().setAnimationOptions(animationFrameLength, False,
False)
tm.getController().timeLayerManager.registerTimeLayer(timelayer)
tm.getController().getGui().setTimeFrameType(frame_type)
tm.getController().getGui().setTimeFrameSize(frame_size)
# set layer to zero
tm.getController().getGui().dock.horizontalTimeSlider.setValue(0)
# tm.getController().timeLayerManager.refreshTimeRestrictions()
# tm.getController().getGui().dock.pushButtonPlay.click()
# plugins['timemanager'].getController().getGui().dock.pushButtonPlay.click()
QTimer.singleShot(
5000,
tm.getController().getGui().dock.pushButtonPlay.click)
def getAllLayers(self):
if LayerRegistry._iface and hasattr(LayerRegistry._iface, 'legendInterface'):
return LayerRegistry._iface.legendInterface().layers()
return list(QgsMapLayerRegistry.instance().mapLayers().values())
def read_islh(self):
os.chdir(self.plugin_dir) #musim do plugin diru, abysem nacet svg
if not self.dockwidget.input_file.text():
QMessageBox.critical(QDialog(), u"Missing file",
u"Není vybrán žádný soubor")
else:
self.f = open(self.dockwidget.input_file.text())
try:
#nachroustam xml
self.dockwidget.output_working_on.setText(u"načítám XML")
self.load_xml()
except:
QMessageBox.critical(QDialog(), u"vadný soubor",
u"soubor se nepodařilo načíst")
self.dockwidget.output_working_on.setText(
u"Začínám tvořit grafiku")
self.add_layers()
self.dockwidget.output_working_on.setText(
u"přidávám vrstvy do mapové kompozice")
self.dockwidget.progressBar.setRange(0, 8)
self.dockwidget.progressBar.setValue(0)
self.layerTreeRoot = QgsProject.instance().layerTreeRoot()
self.por_mapa_group = self.layerTreeRoot.insertGroup(
0, u'Porostní mapa')
self.bzl_jp_op_mapa_group = self.layerTreeRoot.insertGroup(
1, u'BZL, JP, OP')
#self.iface.mapCanvas().setRenderFlag(False)
if hasattr(self, 'psk_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.psk_layer, False)
self.psk_layer.loadNamedStyle('styles/por_mapa.qml')
self.por_mapa_group.insertLayer(0, self.psk_layer)
self.dockwidget.progressBar.setValue(1)
if hasattr(self, 'bzl_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.bzl_layer, False)
self.bzl_jp_op_mapa_group.insertLayer(0, self.bzl_layer)
self.dockwidget.progressBar.setValue(2)
if hasattr(self, 'jp_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.jp_layer, False)
self.bzl_jp_op_mapa_group.insertLayer(0, self.jp_layer)
self.dockwidget.progressBar.setValue(3)
if hasattr(self, 'op_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.op_layer, False)
self.bzl_jp_op_mapa_group.insertLayer(0, self.op_layer)
self.dockwidget.progressBar.setValue(4)
if hasattr(self, 'kpo_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.kpo_layer, False)
self.kpo_layer.loadNamedStyle('styles/por_mapa_kpo.qml')
self.por_mapa_group.insertLayer(0, self.kpo_layer)
self.dockwidget.progressBar.setValue(5)
if hasattr(self, 'klo_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.klo_layer, False)
self.klo_layer.loadNamedStyle('styles/porostni_mapa_linie.qml')
self.por_mapa_group.insertLayer(0, self.klo_layer)
self.dockwidget.progressBar.setValue(6)
if hasattr(self, 'kbo_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.kbo_layer, False)
self.kbo_layer.loadNamedStyle('styles/styly_body.qml')
self.por_mapa_group.insertLayer(0, self.kbo_layer)
self.dockwidget.progressBar.setValue(7)
if hasattr(self, 'kto_layer'):
QgsMapLayerRegistry.instance().addMapLayer(
self.kto_layer, False)
self.kto_layer.loadNamedStyle('styles/styly_txt.qml')
self.por_mapa_group.insertLayer(0, self.kto_layer)
self.dockwidget.progressBar.setValue(8)
self.bzl_jp_op_mapa_group.setVisible(Qt.Unchecked)
#self.por_mapa_group.setVisible(Qt.Unchecked)
lhc_list = [self.lhc.get('LHC_KOD')]
self.dockwidget.input_lhc.clear()
self.dockwidget.input_lhc.addItems(lhc_list)
#nastavit komba na zacatek
self.select_lhc()
self.select_odd()
self.select_dil()
self.select_por()
self.select_psk()
self.iface.setActiveLayer(self.psk_layer)
def renderer(self):
qgis = QgsApplication([], False)
qgis.setPrefixPath(self.settings.get('path'), True)
qgis.setMaxThreads(1)
qgis.initQgis()
while True:
try:
fndata, srs, render_size, extended, \
target_box, result = self.queue.get()
layer = QgsVectorLayer(fndata, 'layer', 'ogr')
crs = QgsCoordinateReferenceSystem(srs.id)
layer.setCrs(crs)
settings = QgsMapSettings()
settings.setLayers([layer.id()])
settings.setFlag(QgsMapSettings.DrawLabeling)
settings.setFlag(QgsMapSettings.Antialiasing)
settings.setCrsTransformEnabled(True)
settings.setDestinationCrs(crs)
settings.setMapUnits(crs.mapUnits())
settings.setOutputSize(QSize(*render_size))
settings.setExtent(QgsRectangle(*extended))
settings.setOutputImageFormat(QImage.Format_ARGB32)
bgcolor = QColor.fromRgba(qRgba(255, 255, 255, 0))
settings.setBackgroundColor(bgcolor)
settings.setOutputDpi(96)
QgsMapLayerRegistry.instance().addMapLayer(layer)
settings.setLayers([layer.id()])
# Создаем QImage руками чтобы можно было использовать
# QgsMapRendererCustomPainterJob. Остальные не позволяют
# обойти баг с рисованием поверх старого.
img = QImage(settings.outputSize(), QImage.Format_ARGB32)
# Эти костыли нужны для того, чтобы корректно рисовались
# слои на прозрачном фоне, без этого получается каша.
img.fill(QColor.fromRgba(qRgba(255, 255, 255, 255)))
img.fill(QColor.fromRgba(qRgba(255, 255, 255, 0)))
# DPI должно быть таким же как в settings, иначе ошибка. В QImage
# разрешение указывается в точках на метр по каждой оси.
dpm = settings.outputDpi() / 25.4 * 1000
img.setDotsPerMeterX(dpm)
img.setDotsPerMeterY(dpm)
painter = QPainter(img)
job = QgsMapRendererCustomPainterJob(settings, painter)
job.renderSynchronously()
painter.end()
QgsMapLayerRegistry.instance().removeAllMapLayers()
# Преобразование QImage в PIL
ba = QByteArray()
bf = QBuffer(ba)
bf.open(QIODevice.WriteOnly)
img.save(bf, 'PNG')
bf.close()
buf = StringIO()
buf.write(bf.data())
buf.seek(0)
img = PIL.Image.open(buf)
# Вырезаем нужный нам кусок изображения
result.put(img.crop(target_box))
except Exception as e:
self.logger.error(e.message)
qgis.exitQgis()
def refresh(self):
#import traceback
#traceback.print_stack(limit=5)
self.removeall()
for layer in QgsMapLayerRegistry.instance().mapLayers().values():
self.addlayer(layer)
def __init__(self, canvas):
"""Constructor
:param canvas:
"""
QObject.__init__(self)
self.canvas = canvas
# Set up slots so we can mimic the behaviour of QGIS when layers
# are added.
LOGGER.debug('Initialising canvas...')
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().layersAdded.connect(self.addLayers)
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().layerWasAdded.connect(self.addLayer)
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().removeAll.connect(self.removeAllLayers)
# For processing module
self.destCrs = None
# For keeping track of which layer is active in the legend.
self.active_layer = None
# In the next section of code, we are going to do some monkey patching
# to make the QGIS processing framework think that this mock QGIS IFACE
# instance is the actual one. It will also ensure that the processing
# algorithms are nicely loaded and available for use.
# Since QGIS > 2.0, the module is moved from QGisLayers to dataobjects
# pylint: disable=F0401, E0611
if QGis.QGIS_VERSION_INT > 20001:
from processing.tools import dataobjects
else:
from processing.core import QGisLayers as dataobjects
import processing
from processing.core.Processing import Processing
# pylint: enable=F0401, E0611
processing.classFactory(self)
# We create our own getAlgorithm function below which will will monkey
# patch in to the Processing class in QGIS in order to ensure that the
# Processing.initialize() call is made before asking for an alg.
@staticmethod
def mock_getAlgorithm(name):
"""
Modified version of the original getAlgorithm function.
:param name: Name of the algorithm to load.
:type name: str
:return: An algorithm concrete class.
:rtype: QgsAlgorithm ?
"""
Processing.initialize()
for provider in Processing.algs.values():
if name in provider:
return provider[name]
return None
# Now we let the monkey loose!
Processing.getAlgorithm = mock_getAlgorithm
# We also need to make dataobjects think that this iface is 'the one'
# Note. the placement here (after the getAlgorithm monkey patch above)
# is significant, so don't move it!
dataobjects.iface = self
def activeLayer(self):
"""Get pointer to the active layer (layer selected in the legend)"""
myLayers = QgsMapLayerRegistry.instance().mapLayers()
for myItem in myLayers:
return myLayers[myItem]
def layers(self):
# It's for processing module
# simulate iface.legendInterface().layers()
return QgsMapLayerRegistry.instance().mapLayers().values()
def get_vector_layer_by_name(layer_name):
layer = QgsMapLayerRegistry.instance().mapLayersByName(layer_name)
if not layer:
return None
else:
return layer[0]
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer(
"Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)",
"points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRendererV2("attr", [
QgsRendererCategoryV2(
1, QgsMarkerSymbolV2.createSimple({"color": "255,0,0"}),
"red"),
QgsRendererCategoryV2(
2, QgsMarkerSymbolV2.createSimple({"color": "0,0,255"}),
"blue")
])
ptLayer.setRendererV2(r)
QgsMapLayerRegistry.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.mapSettings.layers()
layers = [ptLayer.id()] + layers
self.mapSettings.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mapSettings.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsMapLayerRegistry.instance().removeMapLayer(ptLayer.id())
def newProject(self):
"""Create new project."""
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().removeAllMapLayers()
def run(self):
"""Run method that performs all the real work"""
#create the dialog
self.dlg = LeakDetectionDialog()
self.dlg.comboBox.clear()
self.dlg.comboBox_2.clear()
#this is for pipe
layer_list_pt = QgsMapLayerRegistry.instance().mapLayers().values()
for layer in layer_list_pt:
if layer.type() == QgsMapLayer.VectorLayer:
self.dlg.comboBox.addItem(layer.name(), layer)
#for junction
layer_list_line = QgsMapLayerRegistry.instance().mapLayers().values()
print "layer now", layer_list_line
for layer in layer_list_line:
if layer.type() == QgsMapLayer.VectorLayer:
#print "laye name",layer.name()
self.dlg.comboBox_2.addItem(layer.name(), layer)
self.dlg.lineEdit.clear()
self.dlg.pushButton.clicked.connect(self.select_output_file)
self.dlg.toolButton.clicked.connect(self.select_file_point)
print "layer list line sabse pehle", layer_list_line, type(
layer_list_line)
self.dlg.toolButton_2.clicked.connect(self.select_file_line)
# show the dialog
self.dlg.show()
# Clear the QComboBox before loading layers
'''
layers = QgsMapLayerRegistry.instance().mapLayers().values()
for layer in layers:
if layer.type() == QgsMapLayer.VectorLayer:
self.dlg.comboBox.addItem( layer.name(), layer )
layers = QgsMapLayerRegistry.instance().mapLayers().values()
for layer in layers:
if layer.type() == QgsMapLayer.VectorLayer:
self.dlg.comboBox_2.addItem( layer.name(), layer )
'''
#print "lay",lay
#this is for junction
#layers = self.iface.legendInterface().layers()
'''
layers = self.iface.activeLayer()
print "layers for pipe",layers
for layer in layers:
layer_list_line.append(layer.name())
print "layer check",layer_list_line
self.dlg.comboBox_2.addItems(layer_list_line)
'''
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
filename = self.dlg.lineEdit.text()
output_file = open(filename, 'w')
selectedLayerIndex = self.dlg.comboBox_2.currentIndex(
) #this is needed for line data length,dia,fric so call the open_file function
layer_list_line = QgsMapLayerRegistry.instance().mapLayers(
).values()
#print "YO",selectedLayerIndex,layer_list_line
selectedLayer = layer_list_line[selectedLayerIndex]
print " laye rkaun hai", selectedLayer
fields = selectedLayer.pendingFields()
fieldnames = [field.name() for field in fields]
print "names", fieldnames
if "start_x" not in fieldnames:
selectedLayer.dataProvider().addAttributes(
[QgsField("start_x", QVariant.Double)])
if "end_x" not in fieldnames:
selectedLayer.dataProvider().addAttributes(
[QgsField("end_x", QVariant.Double)])
if "start_y" not in fieldnames:
selectedLayer.dataProvider().addAttributes(
[QgsField("start_y", QVariant.Double)])
if "end_y" not in fieldnames:
selectedLayer.dataProvider().addAttributes(
[QgsField("end_y", QVariant.Double)])
#this is used to add new fiels i.e x_start,x_end,y_start,y_end from shape file to attribute table using regex
#selectedLayer.dataProvider().addAttributes([QgsField("start_x",QVariant.Double),QgsField("end_x",QVariant.Double),QgsField("start_y",QVariant.Double),QgsField("end_y",QVariant.Double)])
selectedLayer.updateFields()
selectedLayer.startEditing()
idx1 = selectedLayer.fieldNameIndex("start_x")
e1 = QgsExpression(""" $x_at(0) """)
e1.prepare(selectedLayer.pendingFields())
idx2 = selectedLayer.fieldNameIndex("end_x")
e2 = QgsExpression(""" $x_at(-1) """)
e2.prepare(selectedLayer.pendingFields())
idy1 = selectedLayer.fieldNameIndex("start_y")
e3 = QgsExpression(""" $y_at(0) """)
e3.prepare(selectedLayer.pendingFields())
idy2 = selectedLayer.fieldNameIndex("end_y")
e4 = QgsExpression(""" $y_at(-1) """)
e4.prepare(selectedLayer.pendingFields())
for f in selectedLayer.getFeatures():
f[idx1] = e1.evaluate(f)
f[idx2] = e2.evaluate(f)
f[idy1] = e3.evaluate(f)
f[idy2] = e4.evaluate(f)
selectedLayer.updateFeature(f)
selectedLayer.commitChanges()
#this is used to write teh attribute table to output file specified by user
output_file.write(','.join(fieldnames) + '\n')
for f in selectedLayer.getFeatures():
line = ','.join(unicode(f[x]) for x in fieldnames) + '\n'
unicode_line = line.encode('utf-8')
#print "line",unicode_line
output_file.write(unicode_line)
output_file.close()
#del output_file
#this calls the main function which does all the flow rate calculations
open_file(filename)
#add_to_table_flow(data_dict)
#index = self.dlg.layerCombo.currentIndex()
#layer = self.dlg.layerCombo.itemData(index)
#QMessageBox.information(self.iface.mainWindow(),"hello world","%s has %d features." %(layer.name(),layer.featureCount()))
print "FIANLLL YY ", data_dict
#this is used to add flow rates from the dictionary to attribute table
if "flow rates" not in fieldnames:
selectedLayer.dataProvider().addAttributes(
[QgsField("flow rates", QVariant.Double)])
selectedLayer.updateFields()
selectedLayer.startEditing()
#idx1=selectedLayer.fieldNameIndex("flow rates")
for feature in selectedLayer.getFeatures():
node_1 = feature["node1"]
node_2 = feature["node2"]
#print "nodhfdv",node_1,node_2
#for i in data_dict:
ls = data_dict[int(node_1)]
for m in range(0, len(ls)):
lls = ls[m]
node2 = lls[0]
flow = lls[4]
#print "node_1",node_1,node_2,node2,type(int(node_2)),type(node2),(int(node2)==int(node_2))
if int(node2) == int(node_2):
print "flow final for vector layer", flow
feature["flow rates"] = flow
selectedLayer.updateFeature(feature)
selectedLayer.commitChanges()
# Hello World program in Python
'''
selectedLayer.setCustomProperty("labeling/fieldname","flow rates")
selectedLayer.setCustomProperty("labeling/placement",QgsPalLayerSettings.Line)
selectedLayer.setCustomProperty("labeling/fontSize","8")
selectedLayer.setCustomProperty("labeling/enabled","true")
selectedLayer.triggerRepaint()
'''
'''
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(QGis.Meters)
# 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 = QgsFillSymbolV2.createSimple(props)
renderer = QgsSingleSymbolRendererV2(fillSymbol)
mVectorLayer.setRendererV2(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.setOverviewFrameMap(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 = QgsFillSymbolV2.createSimple(props2)
mOverview.setOverviewFrameMapSymbol(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("# [%$feature || ' / ' || $numfeatures%]")
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.autoscale_render_test_old_api()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
shutil.rmtree(tmppath, True)
def tearDown(self):
"""Fixture run after each test"""
QgsMapLayerRegistry.instance().removeAllMapLayers()
DOCK.cboHazard.clear()
DOCK.cboExposure.clear()
def accept(self):
"""Do PetaBencana download and display it in QGIS.
.. versionadded: 3.3
"""
self.save_state()
try:
self.require_directory()
except CanceledImportDialogError:
return
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
source = self.define_url()
# save the file as json first
name = 'jakarta_flood.json'
output_directory = self.output_directory.text()
output_prefix = self.filename_prefix.text()
overwrite = self.overwrite_flag.isChecked()
date_stamp_flag = self.include_date_flag.isChecked()
output_base_file_path = self.get_output_base_path(
output_directory,
output_prefix,
date_stamp_flag,
name,
overwrite)
title = self.tr("Can't access API")
try:
self.download(source, output_base_file_path)
# Open downloaded file as QgsMapLayer
layer = QgsVectorLayer(
output_base_file_path, 'flood', 'ogr', False)
except Exception as e:
disable_busy_cursor()
QMessageBox.critical(self, title, str(e))
return
self.time_stamp = time.strftime('%d-%b-%Y %H:%M:%S')
# Now save as shp
name = 'jakarta_flood.shp'
output_base_file_path = self.get_output_base_path(
output_directory,
output_prefix,
date_stamp_flag,
name,
overwrite)
QgsVectorFileWriter.writeAsVectorFormat(
layer, output_base_file_path, 'CP1250', None, 'ESRI Shapefile')
# Get rid of the GeoJSON layer and rather use local shp
del layer
self.copy_style(output_base_file_path)
self.copy_keywords(output_base_file_path)
layer = self.add_flooded_field(output_base_file_path)
# check if the layer has feature or not
if layer.featureCount() <= 0:
city = self.city_combo_box.currentText()
message = self.tr(
'There are no floods data available on {city} '
'at this time.').format(city=city)
display_warning_message_box(
self,
self.tr('No data'),
message)
disable_busy_cursor()
else:
# add the layer to the map
registry = QgsMapLayerRegistry.instance()
registry.addMapLayer(layer)
disable_busy_cursor()
self.done(QDialog.Accepted)
def layer(self):
if self.getType() != self.FILE and self.combo.currentIndex() >= 0:
layerID = self.combo.itemData(self.combo.currentIndex())
return QgsMapLayerRegistry.instance().mapLayer(layerID)
return None
def run_error(self):
print "EROR"
#create the dialog
self.dlg = FindErrorDialog()
self.dlg.lineEdit.clear()
self.dlg.toolButton.clicked.connect(self.select_sensor_data)
self.dlg.toolButton_2.clicked.connect(self.select_equilibrium_data)
self.dlg.checkBox.stateChanged.connect(self.select_canvas)
layer_list_line = []
layer_list_line = QgsMapLayerRegistry.instance().mapLayers().values()
print "layer now FOR ERROR ", layer_list_line
for layer in layer_list_line:
if layer.type() == QgsMapLayer.VectorLayer:
#print "laye name",layer.name()
self.dlg.comboBox.addItem(layer.name(), layer)
#show the dialog for form 2 wich is FindErrorDialog class
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
filename = self.dlg.lineEdit.text()
print "filename", filename
output_sensor_file = open(filename, "r")
selectedLayerIndex = self.dlg.comboBox.currentIndex(
) #this is needed for line data length,dia,fric so call the open_file function
layer_list_line = QgsMapLayerRegistry.instance().mapLayers(
).values()
print "YO", selectedLayerIndex, layer_list_line
selectedLayer = layer_list_line[selectedLayerIndex]
print " ERROR LAYER", selectedLayer
fields = selectedLayer.pendingFields()
fieldnames = [field.name() for field in fields]
print "names", type(fieldnames[0])
open_file_sensor(filename)
#print "dict for sensor",data_dict_sensor
for feature in selectedLayer.getFeatures():
node_1 = feature["node1"]
node_2 = feature["node2"]
flow_data = feature["flow rates"]
#print "nodhfdv",node_1,node_2,flow_data,type(node_1)
ls = []
if int(node_1) in data_dict_sensor:
ls = data_dict_sensor[int(node_1)]
#print "lsss",ls,len(ls)
for m in range(0, len(ls)):
lls = ls[m]
node2 = lls[0]
flow_sensor = lls[1]
#print "node_1",node_1,node_2,node2,type(int(node_2)),type(node2),(int(node2)==int(node_2))
if int(node2) == int(node_2):
if float(flow_data) == float(flow_sensor):
print " NO ERROR "
else:
print "ERROR in FLOW", node2, node_2, flow_sensor, flow_data, type(
flow_sensor), type(flow_data)
'''
pay=QgsPalLayerSettings()
pay.readFromLayer(selectedLayer)
#print "layer",selectedLayer
pay.enabled=True
pay.fieldName='flow rates'.encode('utf-8')
pay.placement=QgsPalLayerSettings.AroundPoint
pay.setDataDefinedProperty(QgsPalLayerSettings.Size,True,True,'20','')
pay.writeToLayer(selectedLayer)
QgsMapLayerRegistry.instance().addMapLayers([selectedLayer])
'''
selectedLayer.setCustomProperty("labelling", "pal")
selectedLayer.setCustomProperty(
"labeling/enabled", "true")
selectedLayer.setCustomProperty(
"labeling/fieldname", "flow rates")
#selectedLayer.setCustomProperty("labeling/placement",QgsPalLayerSettings.Line)
selectedLayer.setCustomProperty(
"labeling/fontSize", "8")
selectedLayer.triggerRepaint()
def test_addMapLayerAlreadyAdded(self):
""" test that already added layers can't be readded to registry """
QgsMapLayerRegistry.instance().removeAllMapLayers()
l1 = createLayer('test')
QgsMapLayerRegistry.instance().addMapLayer(l1)
self.assertEqual(
len(QgsMapLayerRegistry.instance().mapLayersByName('test')), 1)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 1)
self.assertEqual(QgsMapLayerRegistry.instance().addMapLayer(l1), None)
self.assertEqual(
len(QgsMapLayerRegistry.instance().mapLayersByName('test')), 1)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 1)
QgsMapLayerRegistry.instance().removeAllMapLayers()
def addDiffLayers(repo, commit, commit2, layernames):
styles = [diffStylePoints, diffStyleLines, diffStylePolygons]
geomTypes = ["Point","LineString","Polygon"]
beforeFilename = tempFilename("gpkg")
repo.exportdiff(commit.commitid, commit2.commitid, beforeFilename)
afterFilename = tempFilename("gpkg")
repo.exportdiff(commit2.commitid, commit.commitid, afterFilename)
for layername in layernames:
styles = [diffStylePoints, diffStyleLines, diffStylePolygons]
geomTypes = ["Point","LineString","Polygon"]
beforeLayer = loadLayerNoCrsDialog("%s|layername=%s" % (beforeFilename, layername), layername, "ogr")
afterLayer = loadLayerNoCrsDialog("%s|layername=%s" % (afterFilename, layername), layername, "ogr")
beforeCon = sqlite3.connect(beforeFilename)
beforeCursor = beforeCon.cursor()
afterCon = sqlite3.connect(afterFilename)
afterCursor = afterCon.cursor()
attributes = [v[1] for v in beforeCursor.execute("PRAGMA table_info('%s');" % layername)]
attrnames = [f.name() for f in beforeLayer.pendingFields()]
layerFeatures = []
beforeCursor.execute("SELECT * FROM %s_changes WHERE audit_op=2;" % layername)
modified = beforeCursor.fetchall()
for m in modified:
geogigfid = m[0]
beforeGpkgfid = gpkgfidFromGeogigfid(beforeCursor, layername, geogigfid)
beforeCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername, beforeGpkgfid))
featureRow = beforeCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = MODIFIED_BEFORE
request = QgsFeatureRequest()
request.setFilterFid(beforeGpkgfid)
feature = next(beforeLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
afterGpkgfid = gpkgfidFromGeogigfid(afterCursor, layername, geogigfid)
afterCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername,afterGpkgfid))
featureRow = afterCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = MODIFIED_AFTER
request = QgsFeatureRequest()
request.setFilterFid(afterGpkgfid)
feature = next(afterLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
afterCursor.execute("SELECT * FROM %s_changes WHERE audit_op=1;" % layername)
added = afterCursor.fetchall()
for a in added:
geogigfid = a[0]
afterGpkgfid = gpkgfidFromGeogigfid(afterCursor, layername, geogigfid)
afterCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername, afterGpkgfid))
featureRow = afterCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = ADDED
request = QgsFeatureRequest()
request.setFilterFid(afterGpkgfid)
feature = next(afterLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
beforeCursor.execute("SELECT * FROM %s_changes WHERE audit_op=1;" % layername)
removed = beforeCursor.fetchall()
for r in removed:
geogigfid = r[0]
beforeGpkgfid = gpkgfidFromGeogigfid(beforeCursor, layername, geogigfid)
beforeCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername, beforeGpkgfid))
featureRow = beforeCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = REMOVED
request = QgsFeatureRequest()
request.setFilterFid(beforeGpkgfid)
feature = next(beforeLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
if layerFeatures:
attrnames.append("changetype")
uriFields = "&".join(["field=%s" % f for f in attrnames])
uri = "%s?crs=%s&%s" % (geomTypes[beforeLayer.geometryType()], beforeLayer.crs().authid(), uriFields)
layer = QgsVectorLayer(uri, "%s(diff)" % layername, "memory")
featuresList = []
for feature in layerFeatures:
qgsfeature = QgsFeature()
qgsfeature.setGeometry(feature["geom"])
qgsfeature.setAttributes([feature["attrs"][attr] for attr in attrnames])
featuresList.append(qgsfeature)
layer.dataProvider().addFeatures(featuresList)
layer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayers([layer])
layer.loadNamedStyle(styles[layer.geometryType()])
def test_addRemoveLayersSignals(self):
""" test that signals are correctly emitted when removing map layers"""
QgsMapLayerRegistry.instance().removeAllMapLayers()
layers_will_be_removed_spy = QSignalSpy(
QgsMapLayerRegistry.instance().layersWillBeRemoved)
layer_will_be_removed_spy_str = QSignalSpy(
QgsMapLayerRegistry.instance().layerWillBeRemoved[str])
layer_will_be_removed_spy_layer = QSignalSpy(
QgsMapLayerRegistry.instance().layerWillBeRemoved[QgsMapLayer])
layers_removed_spy = QSignalSpy(
QgsMapLayerRegistry.instance().layersRemoved)
layer_removed_spy = QSignalSpy(
QgsMapLayerRegistry.instance().layerRemoved)
remove_all_spy = QSignalSpy(QgsMapLayerRegistry.instance().removeAll)
l1 = createLayer('l1')
l2 = createLayer('l2')
l3 = createLayer('l3')
l4 = createLayer('l4')
QgsMapLayerRegistry.instance().addMapLayers([l1, l2, l3, l4])
# remove 1 layer
QgsMapLayerRegistry.instance().removeMapLayer(l1)
# can't seem to actually test the data which was emitted, so best we can do is test
# the signal count
self.assertEqual(len(layers_will_be_removed_spy), 1)
self.assertEqual(len(layer_will_be_removed_spy_str), 1)
self.assertEqual(len(layer_will_be_removed_spy_layer), 1)
self.assertEqual(len(layers_removed_spy), 1)
self.assertEqual(len(layer_removed_spy), 1)
self.assertEqual(len(remove_all_spy), 0)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 3)
# remove 2 layers at once
QgsMapLayerRegistry.instance().removeMapLayers([l2.id(), l3.id()])
self.assertEqual(len(layers_will_be_removed_spy), 2)
self.assertEqual(len(layer_will_be_removed_spy_str), 3)
self.assertEqual(len(layer_will_be_removed_spy_layer), 3)
self.assertEqual(len(layers_removed_spy), 2)
self.assertEqual(len(layer_removed_spy), 3)
self.assertEqual(len(remove_all_spy), 0)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 1)
# remove all
QgsMapLayerRegistry.instance().removeAllMapLayers()
self.assertEqual(len(layers_will_be_removed_spy), 3)
self.assertEqual(len(layer_will_be_removed_spy_str), 4)
self.assertEqual(len(layer_will_be_removed_spy_layer), 4)
self.assertEqual(len(layers_removed_spy), 3)
self.assertEqual(len(layer_removed_spy), 4)
self.assertEqual(len(remove_all_spy), 1)
#remove some layers which aren't in the registry
QgsMapLayerRegistry.instance().removeMapLayers(['asdasd'])
self.assertEqual(len(layers_will_be_removed_spy), 3)
self.assertEqual(len(layer_will_be_removed_spy_str), 4)
self.assertEqual(len(layer_will_be_removed_spy_layer), 4)
self.assertEqual(len(layers_removed_spy), 3)
self.assertEqual(len(layer_removed_spy), 4)
self.assertEqual(len(remove_all_spy), 1)
l5 = createLayer('test5')
QgsMapLayerRegistry.instance().removeMapLayer(l5)
self.assertEqual(len(layers_will_be_removed_spy), 3)
self.assertEqual(len(layer_will_be_removed_spy_str), 4)
self.assertEqual(len(layer_will_be_removed_spy_layer), 4)
self.assertEqual(len(layers_removed_spy), 3)
self.assertEqual(len(layer_removed_spy), 4)
self.assertEqual(len(remove_all_spy), 1)
def openNdviFile(self, file_name):
"""
Open file with NDVI
:param file_name: path to file with NDVI
:type: unicode
"""
self.LOGGER.info("opening NDVI file: %s", file_name)
try:
self.validateInputFilePath(file_name)
except CalculatorException as e:
self.LOGGER.info(e.message)
self.dlg.show_error_message(self.getTranslation(e.title), self.getTranslation(e.message))
return
ndvi0_raster_layer = QgsRasterLayer(file_name, "NDVI - <0")
layer_data_type = ndvi0_raster_layer.dataProvider().dataType(1)
ndvi_thresholds = NdviThreshold().dataTypes.get(layer_data_type)
if ndvi_thresholds is None:
self.LOGGER.info("NDVI file - unknown data type")
self.dlg.show_error_message(self.getTranslation("NDVI file open error"),
self.getTranslation("Unknown data type"))
ndvi_raster_layer = QgsRasterLayer(file_name, "NDVI")
map_layer_registry = QgsMapLayerRegistry.instance()
map_layer_registry.addMapLayer(ndvi_raster_layer)
return
ndvi025_raster_layer = QgsRasterLayer(file_name, "NDVI - 0-0.25")
ndvi05_raster_layer = QgsRasterLayer(file_name, "NDVI - 0.25-0.5")
ndvi075_raster_layer = QgsRasterLayer(file_name, "NDVI - 0.5-0.75")
ndvi1_raster_layer = QgsRasterLayer(file_name, "NDVI - 0.75-1")
algorithm = QgsContrastEnhancement.StretchToMinimumMaximum
limits = QgsRaster.ContrastEnhancementMinMax
ndvi0_raster_layer.setContrastEnhancement(algorithm, limits)
ndvi025_raster_layer.setContrastEnhancement(algorithm, limits)
ndvi05_raster_layer.setContrastEnhancement(algorithm, limits)
ndvi075_raster_layer.setContrastEnhancement(algorithm, limits)
ndvi1_raster_layer.setContrastEnhancement(algorithm, limits)
colors_scheme = ColorsForNdviMap().getColorScheme(self.dlg.cbx_color_schemes.currentText())
ndvi0_raster_layer.setRenderer(
self.getRenderer(ndvi0_raster_layer.dataProvider(),
self.getColorMapForNdvi0(colors_scheme, ndvi_thresholds)))
ndvi025_raster_layer.setRenderer(
self.getRenderer(ndvi025_raster_layer.dataProvider(),
self.getColorMapForNdvi025(colors_scheme, ndvi_thresholds)))
ndvi05_raster_layer.setRenderer(
self.getRenderer(ndvi05_raster_layer.dataProvider(),
self.getColorMapForNdvi05(colors_scheme, ndvi_thresholds)))
ndvi075_raster_layer.setRenderer(
self.getRenderer(ndvi075_raster_layer.dataProvider(),
self.getColorMapForNdvi075(colors_scheme, ndvi_thresholds)))
ndvi1_raster_layer.setRenderer(
self.getRenderer(ndvi1_raster_layer.dataProvider(),
self.getColorMapForNdvi1(colors_scheme, ndvi_thresholds)))
map_layer_registry = QgsMapLayerRegistry.instance()
map_layer_registry.addMapLayer(ndvi0_raster_layer)
map_layer_registry.addMapLayer(ndvi025_raster_layer)
map_layer_registry.addMapLayer(ndvi05_raster_layer)
map_layer_registry.addMapLayer(ndvi075_raster_layer)
map_layer_registry.addMapLayer(ndvi1_raster_layer)
def test_removeMapLayerByLayer(self):
""" test removing a map layer by layer """
QgsMapLayerRegistry.instance().removeAllMapLayers()
# test no crash with empty registry
QgsMapLayerRegistry.instance().removeMapLayer('bad')
QgsMapLayerRegistry.instance().removeMapLayer(None)
l1 = createLayer('test')
l2 = createLayer('test2')
QgsMapLayerRegistry.instance().addMapLayers([l1, l2])
self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)
#remove bad layers
QgsMapLayerRegistry.instance().removeMapLayer(None)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)
l3 = createLayer('test3')
QgsMapLayerRegistry.instance().removeMapLayer(l3)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)
# remove valid layers
QgsMapLayerRegistry.instance().removeMapLayer(l1)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 1)
# test that layer has been deleted
self.assertTrue(sip.isdeleted(l1))
# remove second layer
QgsMapLayerRegistry.instance().removeMapLayer(l2)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 0)
self.assertTrue(sip.isdeleted(l2))
# try removing a layer not in the registry
l3 = createLayer('test3')
QgsMapLayerRegistry.instance().removeMapLayer(l3)
self.assertFalse(sip.isdeleted(l3))
def test_addMapLayer(self):
""" test adding individual map layers to registry """
QgsMapLayerRegistry.instance().removeAllMapLayers()
l1 = createLayer('test')
self.assertEqual(QgsMapLayerRegistry.instance().addMapLayer(l1), l1)
self.assertEqual(
len(QgsMapLayerRegistry.instance().mapLayersByName('test')), 1)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 1)
# adding a second layer should leave existing layers intact
l2 = createLayer('test2')
self.assertEqual(QgsMapLayerRegistry.instance().addMapLayer(l2), l2)
self.assertEqual(
len(QgsMapLayerRegistry.instance().mapLayersByName('test')), 1)
self.assertEqual(
len(QgsMapLayerRegistry.instance().mapLayersByName('test2')), 1)
self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)
QgsMapLayerRegistry.instance().removeAllMapLayers()