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 run(item, action, mainwindow): db = item.database() uri = db.uri() iface = mainwindow.iface quoteId = db.connector.quoteId quoteStr = db.connector.quoteString # check if the selected item is a topology schema isTopoSchema = False if not hasattr(item, 'schema'): mainwindow.infoBar.pushMessage( "Invalid topology", u'Select a topology schema to continue.', QgsMessageBar.INFO, mainwindow.iface.messageTimeout()) return False if item.schema() is not None: sql = u"SELECT srid FROM topology.topology WHERE name = %s" % quoteStr( item.schema().name) c = db.connector._get_cursor() db.connector._execute(c, sql) res = db.connector._fetchone(c) isTopoSchema = res is not None if not isTopoSchema: mainwindow.infoBar.pushMessage( "Invalid topology", u'Schema "{0}" is not registered in topology.topology.'.format( item.schema().name), QgsMessageBar.WARNING, mainwindow.iface.messageTimeout()) return False if (res[0] < 0): mainwindow.infoBar.pushMessage( "WARNING", u'Topology "{0}" is registered as having a srid of {1} in topology.topology, we will assume 0 (for unknown)' .format(item.schema().name, res[0]), QgsMessageBar.WARNING, mainwindow.iface.messageTimeout()) toposrid = '0' else: toposrid = str(res[0]) # load layers into the current project toponame = item.schema().name template_dir = os.path.join(current_path, 'templates') # do not refresh the canvas until all the layers are added prevRenderFlagState = iface.mapCanvas().renderFlag() iface.mapCanvas().setRenderFlag(False) try: provider = db.dbplugin().providerName() uri = db.uri() # Force use of estimated metadata (topologies can be big) uri.setUseEstimatedMetadata(True) # FACES # face mbr uri.setDataSource(toponame, 'face', 'mbr', '', 'face_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.Polygon) layerFaceMbr = QgsVectorLayer(uri.uri(False), u'%s.face_mbr' % toponame, provider) layerFaceMbr.loadNamedStyle(os.path.join(template_dir, 'face_mbr.qml')) face_extent = layerFaceMbr.extent() # face geometry sql = u'SELECT face_id, topology.ST_GetFaceGeometry(%s,' \ 'face_id)::geometry(polygon, %s) as geom ' \ 'FROM %s.face WHERE face_id > 0' % \ (quoteStr(toponame), toposrid, quoteId(toponame)) uri.setDataSource('', u'(%s\n)' % sql, 'geom', '', 'face_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.Polygon) layerFaceGeom = QgsVectorLayer(uri.uri(False), u'%s.face' % toponame, provider) layerFaceGeom.setExtent(face_extent) layerFaceGeom.loadNamedStyle(os.path.join(template_dir, 'face.qml')) # face_seed sql = u'SELECT face_id, ST_PointOnSurface(' \ 'topology.ST_GetFaceGeometry(%s,' \ 'face_id))::geometry(point, %s) as geom ' \ 'FROM %s.face WHERE face_id > 0' % \ (quoteStr(toponame), toposrid, quoteId(toponame)) uri.setDataSource('', u'(%s)' % sql, 'geom', '', 'face_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.Point) layerFaceSeed = QgsVectorLayer(uri.uri(False), u'%s.face_seed' % toponame, provider) layerFaceSeed.setExtent(face_extent) layerFaceSeed.loadNamedStyle( os.path.join(template_dir, 'face_seed.qml')) # TODO: add polygon0, polygon1 and polygon2 ? # NODES # node uri.setDataSource(toponame, 'node', 'geom', '', 'node_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.Point) layerNode = QgsVectorLayer(uri.uri(False), u'%s.node' % toponame, provider) layerNode.loadNamedStyle(os.path.join(template_dir, 'node.qml')) node_extent = layerNode.extent() # node labels uri.setDataSource(toponame, 'node', 'geom', '', 'node_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.Point) layerNodeLabel = QgsVectorLayer(uri.uri(False), u'%s.node_id' % toponame, provider) layerNodeLabel.setExtent(node_extent) layerNodeLabel.loadNamedStyle( os.path.join(template_dir, 'node_label.qml')) # EDGES # edge uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.LineString) layerEdge = QgsVectorLayer(uri.uri(False), u'%s.edge' % toponame, provider) edge_extent = layerEdge.extent() # directed edge uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.LineString) layerDirectedEdge = QgsVectorLayer(uri.uri(False), u'%s.directed_edge' % toponame, provider) layerDirectedEdge.setExtent(edge_extent) layerDirectedEdge.loadNamedStyle(os.path.join(template_dir, 'edge.qml')) # edge labels uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.LineString) layerEdgeLabel = QgsVectorLayer(uri.uri(False), u'%s.edge_id' % toponame, provider) layerEdgeLabel.setExtent(edge_extent) layerEdgeLabel.loadNamedStyle( os.path.join(template_dir, 'edge_label.qml')) # face_left uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.LineString) layerFaceLeft = QgsVectorLayer(uri.uri(False), u'%s.face_left' % toponame, provider) layerFaceLeft.setExtent(edge_extent) layerFaceLeft.loadNamedStyle( os.path.join(template_dir, 'face_left.qml')) # face_right uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.LineString) layerFaceRight = QgsVectorLayer(uri.uri(False), u'%s.face_right' % toponame, provider) layerFaceRight.setExtent(edge_extent) layerFaceRight.loadNamedStyle( os.path.join(template_dir, 'face_right.qml')) # next_left uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.LineString) layerNextLeft = QgsVectorLayer(uri.uri(False), u'%s.next_left' % toponame, provider) layerNextLeft.setExtent(edge_extent) layerNextLeft.loadNamedStyle( os.path.join(template_dir, 'next_left.qml')) # next_right uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid(toposrid) uri.setWkbType(QgsWkbTypes.LineString) layerNextRight = QgsVectorLayer(uri.uri(False), u'%s.next_right' % toponame, provider) layerNextRight.setExtent(edge_extent) layerNextRight.loadNamedStyle( os.path.join(template_dir, 'next_right.qml')) # Add layers to the layer tree faceLayers = [layerFaceMbr, layerFaceGeom, layerFaceSeed] nodeLayers = [layerNode, layerNodeLabel] edgeLayers = [ layerEdge, layerDirectedEdge, layerEdgeLabel, layerEdgeFaceLeft, layerEdgeFaceRight, layerEdgeNextLeft, layerEdgeNextRight ] QgsMapLayerRegistry.instance().addMapLayers(faceLayers, False) groupFaces = QgsLayerTreeGroup(u'Faces') for layer in faceLayers: nodeLayer = groupFaces.addLayer(layer) nodeLayer.setVisible(Qt.Unchecked) nodeLayer.setExpanded(False) groupNodes = QgsLayerTreeGroup(u'Nodes') for layer in faceLayers: nodeLayer = groupNodes.addLayer(layer) nodeLayer.setVisible(Qt.Unchecked) nodeLayer.setExpanded(False) groupEdges = QgsLayerTreeGroup(u'Edges') for layer in faceLayers: nodeLayer = groupEdges.addLayer(layer) nodeLayer.setVisible(Qt.Unchecked) nodeLayer.setExpanded(False) supergroup = QgsLayerTreeGroup(u'Topology "%s"' % toponame) supergroup.insertChildNodes(-1, [groupFaces, groupNodes, groupEdges]) QgsProject.instance().layerTreeRoot().addChildNode(supergroup) finally: # Set canvas extent to topology extent, if not yet initialized canvas = iface.mapCanvas() if (canvas.fullExtent().isNull()): ext = node_extent ext.combineExtentWith(edge_extent) # Grow by 1/20 of largest side ext = ext.buffer(max(ext.width(), ext.height()) / 20) canvas.setExtent(ext) # restore canvas render flag iface.mapCanvas().setRenderFlag(prevRenderFlagState) return True
def load_map_layers(uri, parent_dialog, drivetime_layer, args): """Style map layers and load them in Qgis :param uri: Connection to the database :type uri: QgsDataSourceURI :param parent_dialog: A dialog that called this function. :type parent_dialog: QProgressDialog :param drivetime_layer: A layer containing drivetimes :type drivetime_layer: QgsVectorLayer :param args: List containing database parameters :type args: {} """ uri.setDataSource(args['network_schema'], args['network_table'], args['network_geom']) network_layer = QgsVectorLayer(uri.uri(), "network", "postgres") uri.setDataSource(args['catchment_schema'], args['catchment_table'], args['catchment_geom']) catchment_layer = QgsVectorLayer(uri.uri(), "catchment", "postgres") # Style the tin, contour and network drivetime_style = resources_path('styles', 'qgis', 'drivetimes.qml') drivetime_layer.loadNamedStyle(drivetime_style) network_style = resources_path('styles', 'qgis', 'network.qml') network_layer.loadNamedStyle(network_style) catchment_style = resources_path('styles', 'qgis', 'catchment.qml') catchment_layer.loadNamedStyle(catchment_style) if drivetime_layer.isValid(): QgsMapLayerRegistry.instance().addMapLayers([drivetime_layer]) else: if parent_dialog: display_warning_message_box( parent_dialog, parent_dialog.tr("Error"), parent_dialog.tr('Error loading isochrone map ' 'Could not load drivetimes file!')) else: display_warning_message_box( parent_dialog, 'Error', 'Error loading isochrone map ' 'Could not load drivetimes file!') if network_layer.isValid(): QgsMapLayerRegistry.instance().addMapLayers([network_layer]) else: if parent_dialog: display_warning_message_box( parent_dialog, parent_dialog.tr("Error"), parent_dialog.tr('Error loading isochrone map ' 'Could not load network file!')) else: display_warning_message_box( parent_dialog, 'Error', 'Error loading isochrone map ' 'Could not load network file!') if catchment_layer.isValid(): QgsMapLayerRegistry.instance().addMapLayers([catchment_layer]) else: if parent_dialog: display_warning_message_box( parent_dialog, parent_dialog.tr("Error"), parent_dialog.tr('Error loading isochrone map ' 'Could not load catchment file!')) else: display_warning_message_box( parent_dialog, 'Error', 'Error loading isochrone map ' 'Could not load catchment file!')
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'])), QgsColorRampShader.ColorRampItem(values[3], QColor(colors['light_red'])), QgsColorRampShader.ColorRampItem(values[4], QColor(colors['red'])) ] color_shader.setColorRampItemList(color_list) raster_shader = QgsRasterShader() raster_shader.setRasterShaderFunction(color_shader) renderer = QgsSingleBandPseudoColorRenderer( raster_layer.dataProvider(), 1, raster_shader) raster_layer.setRenderer(renderer) else: if parent_dialog: display_warning_message_box( parent_dialog, parent_dialog.tr('Problem'), parent_dialog.tr('Problem styling the isochrone map')) else: display_warning_message_box( parent_dialog, 'Problem', 'Problem styling the isochrone map') QgsMapLayerRegistry.instance().addMapLayers([raster_layer]) else: if parent_dialog: display_warning_message_box( parent_dialog, parent_dialog.tr('Error'), parent_dialog.tr('Error loading isochrone map ' 'Could not load interpolated file!')) else: display_warning_message_box( parent_dialog, 'Error', 'Error loading isochrone map ' 'Could not load interpolated file!') return raster_layer
def _loadLayer(): layerfile = os.path.join(os.path.dirname(__file__), "data", "MGRS_100kmSQ_ID_02H.shp") layer = loadLayer(layerfile, provider="ogr") QgsMapLayerRegistry.instance().addMapLayer(layer)
def show_results(self, qgis_impact_layer, engine_impact_layer): """Helper function for slot activated when the process is done. .. note:: Adapted from the dock :param qgis_impact_layer: A QGIS layer representing the impact. :type qgis_impact_layer: QgsMapLayer, QgsVectorLayer, QgsRasterLayer :param engine_impact_layer: A safe_layer representing the impact. :type engine_impact_layer: ReadLayer :returns: Provides a report for writing to the dock. :rtype: str """ keywords = self.keyword_io.read_keywords(qgis_impact_layer) # write postprocessing report to keyword output = self.analysis.postprocessor_manager.get_output( self.analysis.aggregator.aoi_mode) keywords['postprocessing_report'] = output.to_html( suppress_newlines=True) self.keyword_io.write_keywords(qgis_impact_layer, keywords) # Get tabular information from impact layer report = m.Message() report.add(LOGO_ELEMENT) report.add(m.Heading(self.tr('Analysis Results'), **INFO_STYLE)) report.add( self.keyword_io.read_keywords(qgis_impact_layer, 'impact_summary')) # Get requested style for impact layer of either kind style = engine_impact_layer.get_style_info() style_type = engine_impact_layer.get_style_type() # Determine styling for QGIS layer if engine_impact_layer.is_vector: LOGGER.debug('myEngineImpactLayer.is_vector') if not style: # Set default style if possible pass elif style_type == 'categorizedSymbol': LOGGER.debug('use categorized') set_vector_categorized_style(qgis_impact_layer, style) elif style_type == 'graduatedSymbol': LOGGER.debug('use graduated') set_vector_graduated_style(qgis_impact_layer, style) elif engine_impact_layer.is_raster: LOGGER.debug('myEngineImpactLayer.is_raster') if not style: qgis_impact_layer.setDrawingStyle("SingleBandPseudoColor") # qgis_impact_layer.setColorShadingAlgorithm( # QgsRasterLayer.PseudoColorShader) else: setRasterStyle(qgis_impact_layer, style) else: message = self.tr( 'Impact layer %s was neither a raster or a vector layer') % ( qgis_impact_layer.source()) # noinspection PyExceptionInherit raise ReadLayerError(message) # Add layers to QGIS layers_to_add = [] if self.show_intermediate_layers: layers_to_add.append(self.analysis.aggregator.layer) layers_to_add.append(qgis_impact_layer) # noinspection PyArgumentList QgsMapLayerRegistry.instance().addMapLayers(layers_to_add) # make sure it is active in the legend - needed since QGIS 2.4 self.iface.setActiveLayer(qgis_impact_layer) # then zoom to it if self.zoom_to_impact_flag: self.iface.zoomToActiveLayer() if self.hide_exposure_flag: exposure_layer = self.analysis.exposure_layer legend = self.iface.legendInterface() legend.setLayerVisible(exposure_layer, False) # append postprocessing report report.add(output.to_html()) # Layer attribution comes last report.add(impact_attribution(keywords).to_html(True)) # Return text to display in report panel return report
def getLayer(self, l): lid = self.layers.get(l) if lid is None: return lid return QgsMapLayerRegistry.instance().mapLayer(lid)
def getVectorTables(self, schema=None): """ get list of table with a geometry column it returns: name (table name) is_system_table type = 'view' (is a view?) geometry_column: f_table_name (the table name in geometry_columns may be in a wrong case, use this to load the layer) f_geometry_column type coord_dimension srid """ reg = VLayerRegistry.instance() VLayerRegistry.instance().reset() lst = [] for _, l in list(QgsMapLayerRegistry.instance().mapLayers().items()): if l.type() == QgsMapLayer.VectorLayer: lname = l.name() # if there is already a layer with this name, use the layer id # as name if reg.has(lname): lname = l.id() VLayerRegistry.instance().set(lname, l.id()) geomType = None dim = None g = l.dataProvider().wkbType() if g == QgsWkbTypes.Point: geomType = 'POINT' dim = 'XY' elif g == QgsWkbTypes.LineString: geomType = 'LINESTRING' dim = 'XY' elif g == QgsWkbTypes.Polygon: geomType = 'POLYGON' dim = 'XY' elif g == QgsWkbTypes.MultiPoint: geomType = 'MULTIPOINT' dim = 'XY' elif g == QgsWkbTypes.MultiLineString: geomType = 'MULTILINESTRING' dim = 'XY' elif g == QgsWkbTypes.MultiPolygon: geomType = 'MULTIPOLYGON' dim = 'XY' elif g == QgsWkbTypes.Point25D: geomType = 'POINT' dim = 'XYZ' elif g == QgsWkbTypes.LineString25D: geomType = 'LINESTRING' dim = 'XYZ' elif g == QgsWkbTypes.Polygon25D: geomType = 'POLYGON' dim = 'XYZ' elif g == QgsWkbTypes.MultiPoint25D: geomType = 'MULTIPOINT' dim = 'XYZ' elif g == QgsWkbTypes.MultiLineString25D: geomType = 'MULTILINESTRING' dim = 'XYZ' elif g == QgsWkbTypes.MultiPolygon25D: geomType = 'MULTIPOLYGON' dim = 'XYZ' lst.append((Table.VectorType, lname, False, False, l.id(), 'geometry', geomType, dim, l.crs().postgisSrid())) return lst
def getAllLayers(self): if LayerRegistry._iface and hasattr(LayerRegistry._iface, 'legendInterface'): return LayerRegistry._iface.legendInterface().layers() return list(QgsMapLayerRegistry.instance().mapLayers().values())
def testCreateExpression(self): """ Test creating an expression using the widget""" layer = QgsVectorLayer( "Point?field=fldtxt:string&field=fldint:integer", "test", "memory") # setup value relation parent_layer = QgsVectorLayer( "Point?field=stringkey:string&field=intkey:integer&field=display:string", "parent", "memory") f1 = QgsFeature(parent_layer.fields(), 1) f1.setAttributes(['a', 1, 'value a']) f2 = QgsFeature(parent_layer.fields(), 2) f2.setAttributes(['b', 2, 'value b']) f3 = QgsFeature(parent_layer.fields(), 3) f3.setAttributes(['c', 3, 'value c']) parent_layer.dataProvider().addFeatures([f1, f2, f3]) QgsMapLayerRegistry.instance().addMapLayers([layer, parent_layer]) config = { "Layer": parent_layer.id(), "Key": 'stringkey', "Value": 'display' } w = QgsValueRelationSearchWidgetWrapper(layer, 0) w.setConfig(config) c = w.widget() # first, set it to the "select value" item c.setCurrentIndex(0) self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull), '"fldtxt" IS NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull), '"fldtxt" IS NOT NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo), '') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo), '') c.setCurrentIndex(1) self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull), '"fldtxt" IS NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull), '"fldtxt" IS NOT NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo), '"fldtxt"=\'a\'') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo), '"fldtxt"<>\'a\'') c.setCurrentIndex(2) self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull), '"fldtxt" IS NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull), '"fldtxt" IS NOT NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo), '"fldtxt"=\'b\'') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo), '"fldtxt"<>\'b\'') # try with numeric field w = QgsValueRelationSearchWidgetWrapper(layer, 1) config['Key'] = 'intkey' w.setConfig(config) c = w.widget() c.setCurrentIndex(c.findText('value c')) self.assertEqual(c.currentIndex(), 3) self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull), '"fldint" IS NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull), '"fldint" IS NOT NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo), '"fldint"=3') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo), '"fldint"<>3') # try with allow null set w = QgsValueRelationSearchWidgetWrapper(layer, 1) config['AllowNull'] = True w.setConfig(config) c = w.widget() c.setCurrentIndex(c.findText('value c')) self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull), '"fldint" IS NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull), '"fldint" IS NOT NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo), '"fldint"=3') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo), '"fldint"<>3') # try with line edit w = QgsValueRelationSearchWidgetWrapper(layer, 1) config['UseCompleter'] = True w.setConfig(config) l = w.widget() l.setText('value b') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull), '"fldint" IS NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull), '"fldint" IS NOT NULL') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo), '"fldint"=2') self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo), '"fldint"<>2')
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.setContrastEnhancement( QgsContrastEnhancement.StretchToMinimumMaximum, QgsRaster.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 = [] 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"
def saveAutoField(self): """ Do some validation and then call AutoFieldManager """ # Check layers if not self.tblLayers.selectedItems(): self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Warning] Please first select a layer."), 'warning') return # Check expression expression = u'' if self.optXCoord.isChecked(): expression = u'$x' elif self.optYCoord.isChecked(): expression = u'$y' elif self.optLength.isChecked(): expression = u'$length' elif self.optPerimeter.isChecked(): expression = u'$perimeter' elif self.optArea.isChecked(): expression = u'$area' elif self.optDate.isChecked(): expression = u'now()' elif self.optCustomExpression.isChecked(): if self.expressionDlg: expression = self.expressionDlg.expression if not self.expressionDlg or not expression: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Warning] Please first set a valid custom expression." ), 'warning') return else: # optSpatialValue pass # Check fields fieldName = '' if self.optNewField.isChecked(): if self.txtFieldName.text(): fieldName = self.txtFieldName.text().strip() newField = QgsField( fieldName, self.cboFieldType.itemData( self.cboFieldType.currentIndex(), Qt.UserRole)) length = self.txtFieldLength.value() precision = self.txtFieldPrecision.value() # Ensure length and precision are valid values when dealing with Real numbers if self.fieldTypesDict[ self.cboFieldType.currentIndex()] == 'Real': if precision > length: precision = length newField.setLength(length) newField.setPrecision(precision) for item in self.tblLayers.selectedItems(): if item.column() == 1: # It's the layer name item layer = QgsMapLayerRegistry.instance().mapLayer( item.data(Qt.UserRole)) if layer.fieldNameIndex(fieldName) != -1: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Error] The field " ) + fieldName + \ QApplication.translate( "AutoFieldsDockWidgetPy", " already exists in layer " ) + layer.name() + ". " + \ QApplication.translate( "AutoFieldsDockWidgetPy", " If you want to create an AutoField on it, you need to choose it from 'Existing Field' list." ), 'warning' ) else: res = layer.dataProvider().addAttributes( [newField]) if res: layer.updateFields() # Check if fieldName is preserved by the provider after field creation. if layer.fieldNameIndex(fieldName) == -1: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Error] The field " ) + fieldName + \ QApplication.translate( "AutoFieldsDockWidgetPy", " was probably created with another name by the layer (" ) + \ layer.name() + \ QApplication.translate( "AutoFieldsDockWidgetPy", ") provider. " ) + \ QApplication.translate( "AutoFieldsDockWidgetPy", " If you want to create an AutoField on it, you need to choose it from 'Existing Field' list." ), 'warning' ) else: self.doSaveAutoField( layer, fieldName, expression) else: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Error] Couldn't create " ) + newField.name() + \ QApplication.translate( "AutoFieldsDockWidgetPy", " field in " ) + layer.name() + \ QApplication.translate( "AutoFieldsDockWidgetPy", " layer." ), 'warning' ) # Some fields might have been created, update the field list once self.updateFieldList() else: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Warning] Please first set a name for the new field." ), 'warning') return else: fieldName = self.cboField.currentText() for item in self.tblLayers.selectedItems(): if item.column() == 1: # It's the layer name item layer = QgsMapLayerRegistry.instance().mapLayer( item.data(Qt.UserRole)) self.doSaveAutoField(layer, fieldName, expression)
Lt = list(set(tab)) Lt.sort() for c_insee, n_couche in Lt: #AMORCES_CAD,LIEUDIT,CP.CadastralParcel,SUBFISCAL,CLOTURE,DETAIL_TOPO,HYDRO,VOIE_COMMUNICATION,BU.Building,BORNE_REPERE urlWithParams = "url=http://inspire.cadastre.gouv.fr/scpc/" + c_insee + ".wms?contextualWMSLegend=0&crs=EPSG:" + Code_EPSG + "&dpiMode=7&featureCount=10&format=image/png&layers=DETAIL_TOPO&styles=&maxHeight=1024&maxWidth=1280" rlayer = QgsRasterLayer( urlWithParams, 'Details_topographiques_' + n_couche + '_' + c_insee, 'wms') progress.setText(u'Nom de la commune : ' + n_couche + ' - ' + c_insee) progress.setText(u'Validite du flux : %s' % rlayer.isValid()) QgsMapLayerRegistry.instance().addMapLayer(rlayer) if rlayer.isValid() == True: iface.messageBar().pushMessage( "Information :", "Ajout du flux WMS pour la commune : " + n_couche, QgsMessageBar.INFO, duration=5) iface.mapCanvas().refresh() else: iface.messageBar().pushMessage("Warning :", "WMS invalide pour la commune : " + n_couche, QgsMessageBar.WARNING, duration=15)
def featuresdeleted(self, layerid, featureids): layer = QgsMapLayerRegistry.instance().mapLayer(layerid) self.reloadselection(layer, deleted=featureids) self.canvas.refresh()
def __init__(self, parent, iface, autoFieldManager, messageManager, language='en'): self.iface = iface self.msg = messageManager self.language = language QDockWidget.__init__(self, parent) # Set up the user interface from Designer. self.setupUi(self) self.autoFieldManager = autoFieldManager self.geometryDict = ['points', 'lines', 'polygons'] self.fieldTypesDict = ['Integer', 'Real', 'String', 'Date'] self.root = QgsProject.instance().layerTreeRoot() # UI stuff that wasn't set/initialized in Qt-Designer self.tblLayers.setColumnWidth(0, 24) self.tblLayers.setColumnWidth(1, 140) self.tblLayers.setColumnWidth(2, 110) self.tblLayers.horizontalHeader().setResizeMode(0, QHeaderView.Fixed) self.tblLayers.sortItems(1, Qt.AscendingOrder) self.cboField.setEnabled(False) self.cboFieldType.setItemData(0, QVariant.Int, Qt.UserRole) self.cboFieldType.setItemData(1, QVariant.Double, Qt.UserRole) self.cboFieldType.setItemData(2, QVariant.String, Qt.UserRole) self.cboFieldType.setItemData(3, QVariant.Date, Qt.UserRole) self.fieldTypeChanged(self.cboFieldType.currentIndex() ) # Update length/precision controls self.btnGroup = QButtonGroup() self.btnGroup.addButton(self.optXCoord) self.btnGroup.addButton(self.optYCoord) self.btnGroup.addButton(self.optLength) self.btnGroup.addButton(self.optPerimeter) self.btnGroup.addButton(self.optArea) self.btnGroup.addButton(self.optDate) self.btnGroup.addButton(self.optCustomExpression) #self.btnGroup.addButton( self.optSpatialValue ) self.updateExpressionControls(self.optCustomExpression) self.frameFields.setEnabled(False) self.frameExpression.setEnabled(False) self.populateLayersTable() QgsMapLayerRegistry.instance().legendLayersAdded.connect( self.populateLayersTable) QgsMapLayerRegistry.instance().layersRemoved.connect( self.populateLayersTable) # Also listen to Layer Tree node position changes self.root.addedChildren.connect(self.populateLayersTable) self.root.removedChildren.connect(self.populateLayersTable) self.tblLayers.itemSelectionChanged.connect( self.updateFieldAndExpressionControls) self.optNewField.toggled.connect(self.newFieldToggled) self.cboField.currentIndexChanged.connect(self.fieldChanged) self.cboFieldType.currentIndexChanged.connect(self.fieldTypeChanged) self.btnSaveAutoField.clicked.connect(self.saveAutoField) self.btnNewCustomExpression.clicked.connect(self.setCustomExpression) self.btnGroup.buttonClicked.connect(self.updateExpressionControls) self.expressionDlg = None # 'List of AutoFields' Tab settings = QSettings() check = settings.value(self.autoFieldManager.settingsPrefix + "/showOnlyEnabledAutoFields", True, type=bool) self.chkOnlyEnabledAutoFields.setChecked(check) check = settings.value(self.autoFieldManager.settingsPrefix + "/calculateOnExistingFeatures", True, type=bool) self.chkCalculateOnExisting.setChecked(check) self.btnRemoveAutoFields.setEnabled(False) self.tblAutoFields.sortItems(0, Qt.AscendingOrder) self.populateAutoFieldsTable() self.autoFieldManager.autoFieldCreated.connect( self.populateAutoFieldsTable) self.autoFieldManager.autoFieldRemoved.connect( self.populateAutoFieldsTable) self.autoFieldManager.autoFieldEnabled.connect( self.populateAutoFieldsTable) self.autoFieldManager.autoFieldDisabled.connect( self.populateAutoFieldsTable) self.tblAutoFields.itemSelectionChanged.connect( self.updateRemoveAutoFieldButton) self.chkOnlyEnabledAutoFields.toggled.connect( self.saveShowOnlyEnabledPreference) self.chkCalculateOnExisting.toggled.connect( self.saveCalculateOnExistingPreference) self.btnRemoveAutoFields.clicked.connect(self.removeAutoFieldFromTable) # Context menu self.tblAutoFields.setContextMenuPolicy(Qt.CustomContextMenu) self.tblAutoFields.customContextMenuRequested.connect( self.openAutoFieldContextMenu) # About Tab self.btnHelp.clicked.connect(self.openDocumentation)
def tearDown(self): QgsMapLayerRegistry.instance().removeAllMapLayers()
def load_template(self, map_settings): """Load composer template for merged report. Validate it as well. The template needs to have: 1. QgsComposerMap with id 'impact-map' for merged impact map. 2. QgsComposerPicture with id 'safe-logo' for InaSAFE logo. 3. QgsComposerLabel with id 'summary-report' for a summary of two impacts. 4. QgsComposerLabel with id 'aggregation-area' to indicate the area of aggregation. 5. QgsComposerScaleBar with id 'map-scale' for impact map scale. 6. QgsComposerLegend with id 'map-legend' for impact map legend. 7. QgsComposerPicture with id 'organisation-logo' for organisation logo. 8. QgsComposerLegend with id 'impact-legend' for map legend. 9. QgsComposerHTML with id 'merged-report-table' for the merged report. :param map_settings: Map settings. :type map_settings: QgsMapSettings, QgsMapRenderer """ # Create Composition template_composition = TemplateComposition(self.template_path, map_settings) # Validate the component in the template component_ids = [ 'impact-map', 'safe-logo', 'summary-report', 'aggregation-area', 'map-scale', 'map-legend', 'organisation-logo', 'merged-report-table' ] template_composition.component_ids = component_ids if len(template_composition.missing_elements) > 0: raise ReportCreationError( self.tr('Components: %s could not be found' % ', '.join(template_composition.missing_elements))) # Prepare map substitution and set to composition impact_title = '%s and %s' % (self.first_impact['map_title'], self.second_impact['map_title']) substitution_map = { 'impact-title': impact_title, 'hazard-title': self.first_impact['hazard_title'], 'disclaimer': self.disclaimer } template_composition.substitution = substitution_map # Load Template try: template_composition.load_template() except TemplateLoadingError: raise # Draw Composition # Set InaSAFE logo composition = template_composition.composition safe_logo = composition.getComposerItemById('safe-logo') safe_logo.setPictureFile(self.safe_logo_path) # set organisation logo org_logo = composition.getComposerItemById('organisation-logo') org_logo.setPictureFile(self.organisation_logo_path) # Set Map Legend legend = composition.getComposerItemById('map-legend') if qgis_version() < 20400: layers = map_settings.layerSet() else: layers = map_settings.layers() if qgis_version() < 20600: legend.model().setLayerSet(layers) legend.synchronizeWithModel() else: root_group = legend.modelV2().rootGroup() layer_ids = map_settings.layers() for layer_id in layer_ids: # noinspection PyUnresolvedReferences layer = QgsMapLayerRegistry.instance().mapLayer(layer_id) root_group.addLayer(layer) legend.synchronizeWithModel() return composition
def on_legend_click(self, current, column=0): "changes menu when user click on legend" self.current_group_idx = -1 name = '' self.current_layers = [] self.info.setText('No group selected') for act in self.actions: if act.text() in [ 'checkout', 'update', 'commit', 'view', 'branch', 'historize' ]: act.setVisible(False) if current: try: # qgis 2.2 name = current.text(0) except: #qgis 2.4 name = current.data() # we could look if we have something in selected layers # but we prefer impose grouping, otherwize it'll be easy to make errors # need to get all layers including subgroups rel_map = {} for grp, lay in self.iface.legendInterface().groupLayerRelationship(): rel_map[grp] = lay if not name or name not in rel_map: # not a group return group_idx = [ i for i, x in enumerate(self.iface.legendInterface().groups()) if x == name ] if len(group_idx) != 1: self.info.setText("More than one group with this name") self.current_layers = [] return [self.current_group_idx] = group_idx replaced = True while replaced: replaced = False for i, item in enumerate(rel_map[name]): if item in rel_map: rel_map[name][i:i + 1] = rel_map[item] replaced = True self.current_layers = rel_map[name] # we should check that the selection is homogeneous previous_conn = () for layer_id in self.current_layers: layer = QgsMapLayerRegistry.instance().mapLayer(layer_id) uri = QgsDataSourceURI(layer.source()) if previous_conn: if (uri.database(), uri.schema()) != previous_conn: self.current_layers = [] self.info.setText("Layers don't share db and schema") return else: previous_conn = (uri.database(), uri.schema()) if not self.current_layers: return if not len(previous_conn[0]): self.current_layers = [] self.info.setText("Not versionable") return layer = QgsMapLayerRegistry.instance().mapLayer(self.current_layers[0]) uri = QgsDataSourceURI(layer.source()) selection_type = '' if layer.providerType() == "spatialite": rev = 0 try: rev = versioning_base.revision(uri.database()) except: self.current_layers = [] self.info.setText("The selected group is not a working copy") return self.info.setText(uri.database() + ' rev=' + str(rev)) selection_type = 'working copy' if layer.providerType() == "postgres": mtch = re.match(r'(.+)_([^_]+)_rev_(head|\d+)', uri.schema()) if mtch: self.info.setText(uri.database() + ' ' + mtch.group(1) + ' branch=' + mtch.group(2) + ' rev=' + mtch.group(3)) if mtch.group(3) == 'head': selection_type = 'head' else: selection_type = 'versioned' else: # check if it's a working copy rev = 0 try: rev = versioning_base.pg_revision(self.pg_conn_info(), uri.schema()) selection_type = 'working copy' self.info.setText(uri.database() + ' ' + uri.schema() + ' rev=' + str(rev)) except: self.info.setText('Unversioned schema') selection_type = 'unversioned' # refresh the available commands assert (selection_type) if selection_type == 'unversioned': for act in self.actions: if act.text() == 'historize': act.setVisible(True) elif selection_type == 'versioned': for act in self.actions: if act.text() in ['view', 'branch']: act.setVisible(True) elif selection_type == 'head': for act in self.actions: if act.text() in ['checkout', 'view', 'branch']: act.setVisible(True) elif selection_type == 'working copy': for act in self.actions: if act.text() in ['update', 'commit']: act.setVisible(True)
def tearDown(self): QgsMapLayerRegistry.instance().addMapLayer(self.vlayer) QgsMapLayerRegistry.instance().removeMapLayer(self.vlayer.id()) super(self.__class__, self).tearDown()
def on_click_load(self): # default value of the progress bar is set to 0 self.counter = 0 self.ui.progressBar.setValue(self.counter) # check if the user wants to limit the selection by distinct value if self.ui.checkBox.isChecked(): load_key = self.ui.load_field.currentText() # if the data type is not a string if self.data_type != str: load_key = ast.literal_eval(load_key) self.ourList = self.collection.find({self.key: load_key}) else: query_text = self.ui.query_field.currentText().strip() if query_text == '': query = {} else: query = ast.literal_eval(query_text) if type(query) is not dict: QMessageBox.about(self, "Warning!", "Query must be a dict!") return self.ourList = self.collection.find(query) self.percent = 100 / float(self.ourList.count()) # get the first level of attributes, we can modify which fields we want to use self.single_return = self.collection.find_one({}, {'geom': 0, 'fibres': 0, 'date': 0}) # {} , {"geom": 1} self.attr_list = self.single_return.keys() # list defined for the attributes table self.attr_list_new = [] # list defined for structural access to tables self.attr_list_structure = [] # locate the sub attributes and store them in sub_attr_list for attr in self.attr_list: # append keys from the first layer self.attr_list_new.append(str(attr)) self.attr_list_structure.append([attr]) # if the key is a dictionary if type(self.single_return[attr]) is dict: # find all of the sub keys in the dictionary sub_keys_list = self.single_return[attr].keys() # search through the list of sub keys for sub_key in sub_keys_list: # structural code for ease of access later struct_sub = [attr], [sub_key] # append the sub keys to our main list, define differences self.attr_list_new.append(str(attr) + "." + str(sub_key)) # create a structure for ease of access self.attr_list_structure.append(struct_sub) else: pass QMessageBox.about(self, "Info", "Fields are"+ (', '.join(self.attr_list_new))) # define the dataLayer type as either Point, LineString or Polygon self.dataLayer = QgsVectorLayer(self.geometry_name, self.collection_name, "memory") # prepare the layer for the data we will be inputing self.dataLayer.startEditing() self.layerData = self.dataLayer.dataProvider() # create the shapefile attributes based on existing mongoDB field for attribute in (self.attr_list_new): self.layerData.addAttributes([QgsField(attribute, QVariant.String)]) # our attribute container self.feature = QgsFeature() self.feature.initAttributes(len(self.attr_list_new)) for value in self.ourList: # print value[self.geom_name]["type"] # if the user has selected a collection with point geometry if value[self.geom_name]["type"] == "Point": x_coord = value[self.geom_name]["coordinates"][0] y_coord = value[self.geom_name]["coordinates"][1] self.populate_attributes(value) try: self.feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x_coord, y_coord))) except: self.feature.setGeometry(QgsGeometry.fromPoint(QgsPoint(x_coord, y_coord))) (res, outFeats) = self.dataLayer.dataProvider().addFeatures([self.feature]) # update the progress bar self.event_progress() self.ui.load_collection.setEnabled(False) self.ui.listCol.setEnabled(False) elif value[self.geom_name]["type"] == "LineString": # used to store a list of poly lines line_string = [] # checks the geometry and only imports valid geometry if self.check_valid_geom(value): for y in range(len(value[self.geom_name]["coordinates"])): # do not use unless needed, in case there is a multiLineString Object in the DB try: line_string.append(QgsPoint(value[self.geom_name]["coordinates"][y][0], value[self.geom_name]["coordinates"][y][1])) except: qgis.utils.iface.messageBar().pushMessage("Error", "Error loading Linestring on {}: {}".format(str(value["_id"]), str(sys.exc_info()[0])), level=Qgis.critical) self.populate_attributes(value) self.feature.setGeometry(QgsGeometry.fromPolyline(line_string)) (res, outFeats) = self.dataLayer.dataProvider().addFeatures([self.feature]) del line_string[:] # update the progress bar self.event_progress() self.ui.load_collection.setEnabled(False) self.ui.listCol.setEnabled(False) # this deals with Polygon geometry elif value[self.geom_name]["type"] == "Polygon": # store the polygon points poly_shape = [] # store the line (a poly has multiple lines) line_string = [] # checks the geometry and only imports valid geometry if self.check_valid_geom(value): for y in range(len(value[self.geom_name]["coordinates"][0])): try: line_string.append(QgsPoint(value[self.geom_name]["coordinates"][0][y][0], value[self.geom_name]["coordinates"][0][y][1])) except: qgis.utils.iface.messageBar().pushMessage("Error", "Error loading Polygon {}: {}".format(str(value["_id"]), str(sys.exc_info()[0])), level=QgsMessageBar.CRITICAL) poly_shape.append(line_string); self.populate_attributes(value) try: ps = QgsGeometry.fromPolygonXY(poly_shape) self.feature.setGeometry(ps) except AttributeError: ps = QgsGeometry.fromPolygon(poly_shape) self.feature.setGeometry(ps) except: qgis.utils.iface.messageBar().pushMessage("Error", "Error on {}: {}".format(str(value["_id"]), str(sys.exc_info()[0])), level=QgsMessageBar.CRITICAL) (res, outFeats) = self.dataLayer.dataProvider().addFeatures([self.feature]) del line_string[:] del poly_shape[:] # update the progress bar self.event_progress() self.ui.load_collection.setEnabled(False) self.ui.listCol.setEnabled(False) # this deals with Polygon geometry elif value[self.geom_name]["type"] == "MultiPolygon": # store the polygon points poly_shape = [] # checks the geometry and only imports valid geometry if self.check_valid_geom(value): multi_poly_shape = [] for multi_shape in value[self.geom_name]["coordinates"]: for shape in multi_shape: each_shape = [] for xy in shape: try: each_shape.append(QgsPoint(xy[0], xy[1])) except: qgis.utils.iface.messageBar().pushMessage("Error", "Error loading Multipolygon {}: {}".format(str(value["_id"]), str(sys.exc_info()[0])), level=QgsMessageBar.CRITICAL) multi_poly_shape.append(each_shape) # final append at highest level poly_shape.append(multi_poly_shape) self.populate_attributes(value) try: ps = QgsGeometry.fromMultiPolygonXY(poly_shape) self.feature.setGeometry(ps) except AttributeError: ps = QgsGeometry.fromMultiPolygon(poly_shape) self.feature.setGeometry(ps) except: qgis.utils.iface.messageBar().pushMessage("Error", "Error on {}: {}".format(str(value["_id"]), str(sys.exc_info()[0])), level=QgsMessageBar.CRITICAL) (res, outFeats) = self.dataLayer.dataProvider().addFeatures([self.feature]) del poly_shape[:] # update the progress bar self.event_progress() self.ui.load_collection.setEnabled(False) self.ui.listCol.setEnabled(False) else: qgis.utils.iface.messageBar().pushMessage("Error", "Failed to load geometry due to {} being unsupported".format(value[self.geom_name]["type"]), level=QgsMessageBar.CRITICAL) self.ui.listCol.setEnabled(True) # commits the changes made to the layer and adds the layer to the map self.dataLayer.commitChanges() # the path we will be writing to is the plugin folder dependant on the layer name write_to = str(os.path.abspath(__file__ + "/../../")) + "/" + str(self.collection_name) + ".shp" write_error = QgsVectorFileWriter.writeAsVectorFormat(self.dataLayer, write_to, "system", self.dataLayer.crs(), "ESRI Shapefile") self.dataLayer = QgsVectorLayer(write_to, self.collection_name, "ogr") try: QgsProject.instance().addMapLayer(self.dataLayer) except: QgsMapLayerRegistry.instance().addMapLayer(self.dataLayer)
def branch(self): """create branch and import layers""" layer = QgsMapLayerRegistry.instance().mapLayer(self.current_layers[0]) uri = QgsDataSourceURI(layer.source()) mtch = re.match(r'(.+)_([^_]+)_rev_(head|\d+)', uri.schema()) schema = mtch.group(1) base_branch = mtch.group(2) base_rev = mtch.group(3) assert (schema) dlg = QDialog() dlg.setWindowTitle('Enter branch name') layout = QVBoxLayout(dlg) button_box = QDialogButtonBox(dlg) button_box.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) button_box.accepted.connect(dlg.accept) button_box.rejected.connect(dlg.reject) line_edit = QLineEdit(dlg) layout.addWidget(line_edit) layout.addWidget(button_box) if not dlg.exec_(): return branch = line_edit.text() if not branch: print 'aborted' return pcur = versioning_base.Db(psycopg2.connect(self.pg_conn_info())) pcur.execute("SELECT * FROM " + schema + ".revisions " "WHERE branch = '" + branch + "'") if pcur.fetchone(): pcur.close() QMessageBox.warning(self.iface.mainWindow(), "Warning", "Branch " + branch + ' already exists.') return pcur.close() # get the commit message if not self.q_commit_msg_dlg.exec_(): return commit_msg = self.commit_msg_dlg.commitMessage.document().toPlainText() if not commit_msg: QMessageBox.warning(self.iface.mainWindow(), "Warning", "No commit message, aborting commit") print "aborted" return versioning_base.add_branch(uri.connectionInfo(), schema, branch, commit_msg, base_branch, base_rev) grp_name = branch + ' revision head' grp_idx = self.iface.legendInterface().addGroup(grp_name) for layer_id in reversed(self.current_layers): layer = QgsMapLayerRegistry.instance().mapLayer(layer_id) new_uri = QgsDataSourceURI(layer.source()) new_uri.setDataSource(schema + '_' + branch + '_rev_head', new_uri.table(), new_uri.geometryColumn(), new_uri.sql(), new_uri.keyColumn()) display_name = QgsMapLayerRegistry.instance().mapLayer( layer_id).name() new_layer = self.iface.addVectorLayer( new_uri.uri().replace('()', ''), display_name, 'postgres') self.iface.legendInterface().moveLayer(new_layer, grp_idx)
def activeLayer(self): """Get pointer to the active layer (layer selected in the legend).""" # noinspection PyArgumentList layers = QgsMapLayerRegistry.instance().mapLayers() for item in layers: return layers[item]
def execute(self): """ Reimplementation of the execute method from the parent class """ QgsMessageLog.logMessage( self.tr('Starting ') + self.getName() + self.tr(' Process.'), "DSG Tools Plugin", QgsMessageLog.CRITICAL) self.startTimeCount() try: self.setStatus(self.tr('Running'), 3) #now I'm running! self.abstractDb.deleteProcessFlags( self.getName()) #erase previous flags classesWithElem = self.parameters['Classes'] if len(classesWithElem) == 0: self.setStatus( self.tr('No classes selected!. Nothing to be done.'), 1) #Finished QgsMessageLog.logMessage( self.tr('No classes selected! Nothing to be done.'), "DSG Tools Plugin", QgsMessageLog.CRITICAL) return 1 error = False for key in classesWithElem: # preparation classAndGeom = self.classesWithElemDict[key] lyr = self.loadLayerBeforeValidationProcess(classAndGeom) # specific EPSG search parameters = { 'tableSchema': classAndGeom['tableSchema'], 'tableName': classAndGeom['tableName'], 'geometryColumn': classAndGeom['geom'] } srid = self.abstractDb.findEPSG(parameters=parameters) # running the process in the temp table coverage = self.createUnifiedLayer([lyr]) result, output = self.runProcessinAlg(coverage) self.splitUnifiedLayer(output, [lyr]) try: QgsMapLayerRegistry.instance().removeMapLayer( coverage.id()) except: QgsMessageLog.logMessage( self.tr( 'Error while trying to remove coverage layer.'), "DSG Tools Plugin", QgsMessageLog.CRITICAL) # storing flags if len(result) > 0: error = True recordList = [] for tupple in result: recordList.append( ('{0}.{1}'.format(classAndGeom['tableSchema'], classAndGeom['tableName']), tupple[0], self.tr('Cleaning error.'), tupple[1], classAndGeom['geom'])) numberOfProblems = self.addFlag(recordList) QgsMessageLog.logMessage( str(numberOfProblems) + self.tr(' feature(s) from ') + classAndGeom['lyrName'] + self.tr(' with cleaning errors. Check flags.'), "DSG Tools Plugin", QgsMessageLog.CRITICAL) else: QgsMessageLog.logMessage( self.tr('There are no cleaning errors on ') + classAndGeom['lyrName'] + '.', "DSG Tools Plugin", QgsMessageLog.CRITICAL) self.logLayerTime(classAndGeom['lyrName']) if error: self.setStatus( self.tr('There are cleaning errors. Check log.'), 4) #Finished with errors else: self.setStatus(self.tr('There are no cleaning errors.'), 1) #Finished return 1 except Exception as e: QgsMessageLog.logMessage(':'.join(e.args), "DSG Tools Plugin", QgsMessageLog.CRITICAL) self.finishedWithError() return 0
def processLoading(self): ''' Load all the layers in QGIS and apply corresponding style ''' self.startTime = datetime.now() QApplication.setOverrideCursor(Qt.WaitCursor) # default style to apply for Cadastre layers self.themeDir = unicode(self.dialog.liTheme.currentText()) if not os.path.exists( os.path.join(self.qc.plugin_dir, "styles/%s" % self.themeDir)): self.themeDir = self.defaultThemeDir # set Cadastre SVG path if not set cadastreSvgPath = os.path.join(self.qc.plugin_dir, "styles/%s/svg" % self.themeDir) s = QSettings() qgisSvgPaths = s.value("svg/searchPathsForSVG", 10, type=str) if not cadastreSvgPath in qgisSvgPaths: if qgisSvgPaths: qgisSvgPaths = u"%s|%s" % (qgisSvgPaths, cadastreSvgPath) else: qgisSvgPaths = u"%s" % cadastreSvgPath s.setValue("svg/searchPathsForSVG", qgisSvgPaths) self.qc.updateLog( u"* Le chemin contenant les SVG du plugin Cadastre a été ajouté dans les options de QGIS" ) # Get selected options providerName = self.dialog.dbpluginclass.providerName() qgisCadastreLayers = [] self.dialog.schema = unicode(self.dialog.liDbSchema.currentText()) self.dialog.totalSteps = len(self.qgisCadastreLayerList) # Run the loading self.updateTimer() self.qc.updateLog(u'Chargement des tables :') # Get database list of tables if self.dialog.dbType == 'postgis': schemaSearch = [ s for s in self.dialog.db.schemas() if s.name == self.dialog.schema ] schemaInst = schemaSearch[0] dbTables = self.dialog.db.tables(schemaInst) if self.dialog.dbType == 'spatialite': dbTables = self.dialog.db.tables() # Get commune filter by expression communeExpression = self.dialog.communeFilter.text() communeFilter = None cExp = QgsExpression(communeExpression) if not cExp.hasParserError(): self.qc.updateLog(u'Filtrage à partir des communes : %s' % communeExpression) cReq = QgsFeatureRequest(cExp) cTableList = [a for a in dbTables if a.name == 'geo_commune'] cTable = cTableList[0] cUniqueCol = 'ogc_fid' cSchema = self.dialog.schema cGeomCol = 'geom' cLayerUri = self.dialog.db.uri() cLayerUri.setDataSource(cSchema, cTable.name, cGeomCol, '', cUniqueCol) clayer = QgsVectorLayer(cLayerUri.uri(), 'com', providerName) cfeatures = clayer.getFeatures(cReq) cids = [a['commune'] for a in cfeatures] if len(cids): communeFilter = cids else: self.qc.updateLog( u'Filtrage à partir des communes : expression invalide !') # Loop throuhg qgisQastreLayerList and load each corresponding table for item in self.qgisCadastreLayerList: if item['label'] not in self.mainLayers and self.dialog.cbMainLayersOnly.isChecked( ): continue if item.has_key('dbType') and item['dbType'] != self.dialog.dbType: continue # update progress bar self.qc.updateLog(u'* %s' % item['label']) self.dialog.step += 1 self.qc.updateProgressBar() # Tables - Get db_manager table instance tableList = [a for a in dbTables if a.name == item['table']] if len(tableList) == 0 and not item.has_key('isView'): self.qc.updateLog(u' - Aucune table trouvée pour %s' % item['label']) continue if tableList: table = tableList[0] source = table.name uniqueField = table.getValidQGisUniqueFields(True) if uniqueField: uniqueCol = uniqueField.name else: uniqueCol = 'ogc_fid' schema = self.dialog.schema # View if item.has_key('isView'): if self.dialog.dbType == 'spatialite': schemaReplace = '' else: schemaReplace = '"%s".' % self.dialog.schema source = item['table'].replace('schema.', schemaReplace) uniqueCol = item['key'] schema = None sql = item['sql'] geomCol = item['geom'] if communeFilter: communeFilterText = "'" + "', '".join(communeFilter) + "'" nschema = '' if self.dialog.dbType == 'postgis': nschema = '"%s".' % schema if 'subset' in item: subset = item['subset'] sql += subset % communeFilterText else: itemcol = item['table'] if item['table'] == 'geo_label': itemcol = 'ogc_fid' subset = itemcol + ''' IN ( SELECT b.''' + itemcol + ''' FROM ''' + nschema + item['table'] + ''' b JOIN ''' + nschema + '''geo_commune c ON ST_Within(b.geom, c.geom) WHERE 2>1 AND c.geo_commune IN ( %s ) ) ''' if sql: sql += ' AND ' sql += subset % communeFilterText # Create vector layer alayerUri = self.dialog.db.uri() alayerUri.setDataSource(schema, source, geomCol, sql, uniqueCol) vlayer = QgsVectorLayer(alayerUri.uri(), item['label'], providerName) # apply style qmlPath = os.path.join( self.qc.plugin_dir, "styles/%s/%s.qml" % (self.themeDir, item['name'])) if os.path.exists(qmlPath): vlayer.loadNamedStyle(qmlPath) # append vector layer to the list qgisCadastreLayers.append(vlayer) self.updateTimer() # Get canvas and disable rendering from qgis.utils import iface canvas = iface.mapCanvas() canvas.freeze(True) # Add all layers to QGIS registry self.qc.updateLog(u'Ajout des couches dans le registre de QGIS') QgsMapLayerRegistry.instance().addMapLayers(qgisCadastreLayers) self.updateTimer() # Create a group "Cadastre" and move all layers into it self.qc.updateLog(u'Ajout des couches dans le groupe Cadastre') li = self.dialog.iface.legendInterface() groups = [] for group in li.groupLayerRelationship(): if group[0]: groups.append(group[0]) if u"Cadastre" in groups: g1 = self.getGroupIndex(u"Cadastre") if not u'Fond' in groups: gf = li.addGroup(u'Fond', True, g1) else: gf = self.getGroupIndex(u'Fond') if not u'Étiquettes cadastre' in groups: ge = li.addGroup(u'Étiquettes cadastre', True, gf) else: ge = self.getGroupIndex(u'Étiquettes cadastre') if not u'Données cadastre' in groups: gd = li.addGroup(u'Données cadastre', True, gf) else: gd = self.getGroupIndex(u"Données cadastre") else: g1 = li.addGroup("Cadastre") gf = li.addGroup("Fond", True, g1) ge = li.addGroup(u'Étiquettes cadastre', True, gf) gd = li.addGroup(u'Données cadastre', True, gf) for layer in qgisCadastreLayers: #~ layer.updateExtents() # Get layer options qlayer = [ a for a in self.qgisCadastreLayerList if a['label'] == layer.name() ] if qlayer: qlayer = qlayer[0] # Enable/Disable layer if not qlayer['active']: li.setLayerVisible(layer, False) # Move layer to proper group if qlayer['group'] == 'E': li.moveLayer(layer, ge) elif qlayer['group'] == 'D': li.moveLayer(layer, gd) else: li.moveLayer(layer, g1) else: # Move layer to Cadastre group li.moveLayer(layer, g1) # Do not expand layer legend li.setLayerExpanded(layer, False) # Close Cadastre group # li.setGroupExpanded(g1, False) self.updateTimer() # Zoom to full extent self.qc.updateLog(u'Zoom sur les couches') canvas.zoomToFullExtent() canvas.freeze(False) canvas.refresh() self.updateTimer() # progress bar self.dialog.step += 1 self.qc.updateProgressBar() # Emit signal self.qc.updateLog(u'Mise à jour des outils cadastre') self.cadastreLoadingFinished.emit() self.updateTimer() # Final message QApplication.restoreOverrideCursor() QMessageBox.information( self.dialog, u"Cadastre", u"Les données ont bien été chargées dans QGIS") self.dialog.pbProcess.setValue(0) QApplication.restoreOverrideCursor()
def closeEvent(self, evt): QgsMapLayerRegistry.instance().layerWasAdded.disconnect(self.mainWidget.layerAdded) QgsMapLayerRegistry.instance().layersWillBeRemoved.disconnect(self.mainWidget.layersWillBeRemoved) super(AlgorithmDialog, self).closeEvent(evt)
def run(item, action, mainwindow): db = item.database() uri = db.uri() iface = mainwindow.iface quoteId = db.connector.quoteId quoteStr = db.connector.quoteString # check if the selected item is a topology schema isTopoSchema = False if not hasattr(item, 'schema'): mainwindow.infoBar.pushMessage("Invalid topology", u'Select a topology schema to continue.', QgsMessageBar.INFO, mainwindow.iface.messageTimeout()) return False if item.schema() is not None: sql = u"SELECT srid FROM topology.topology WHERE name = %s" % quoteStr(item.schema().name) c = db.connector._get_cursor() db.connector._execute( c, sql ) res = db.connector._fetchone( c ) isTopoSchema = res is not None if not isTopoSchema: mainwindow.infoBar.pushMessage("Invalid topology", u'Schema "{0}" is not registered in topology.topology.'.format(item.schema().name), QgsMessageBar.WARNING, mainwindow.iface.messageTimeout()) return False if ( res[0] < 0 ): mainwindow.infoBar.pushMessage("WARNING", u'Topology "{0}" is registered as having a srid of {1} in topology.topology, we will assume 0 (for unknown)'.format(item.schema().name, res[0]), QgsMessageBar.WARNING, mainwindow.iface.messageTimeout()) toposrid = '0' else: toposrid = str(res[0]) # load layers into the current project toponame = item.schema().name template_dir = os.path.join(current_path, 'templates') registry = QgsMapLayerRegistry.instance() legend = iface.legendInterface() # do not refresh the canvas until all the layers are added prevRenderFlagState = iface.mapCanvas().renderFlag() iface.mapCanvas().setRenderFlag( False ) try: supergroup = legend.addGroup(u'Topology "%s"' % toponame, False) provider = db.dbplugin().providerName() uri = db.uri() # FACES group = legend.addGroup(u'Faces', False, supergroup) # face mbr uri.setDataSource(toponame, 'face', 'mbr', '', 'face_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBPolygon ) layer = QgsVectorLayer(uri.uri(), u'%s.face_mbr' % toponame, provider) layer.loadNamedStyle(os.path.join(template_dir, 'face_mbr.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) face_extent = layer.extent() # face geometry sql = u'SELECT face_id, topology.ST_GetFaceGeometry(%s, face_id) as geom ' \ 'FROM %s.face WHERE face_id > 0' % (quoteStr(toponame), quoteId(toponame)) uri.setDataSource('', u'(%s\n)' % sql, 'geom', '', 'face_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBPolygon ) layer = QgsVectorLayer(uri.uri(), u'%s.face' % toponame, provider) layer.setExtent(face_extent) layer.loadNamedStyle(os.path.join(template_dir, 'face.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # face_seed sql = u'SELECT face_id, ST_PointOnSurface(topology.ST_GetFaceGeometry(%s, face_id)) as geom ' \ 'FROM %s.face WHERE face_id > 0' % (quoteStr(toponame), quoteId(toponame)) uri.setDataSource('', u'(%s)' % sql, 'geom', '', 'face_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBPoint ) layer = QgsVectorLayer(uri.uri(), u'%s.face_seed' % toponame, provider) layer.setExtent(face_extent) layer.loadNamedStyle(os.path.join(template_dir, 'face_seed.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # TODO: add polygon0, polygon1 and polygon2 ? # NODES group = legend.addGroup(u'Nodes', False, supergroup) # node uri.setDataSource(toponame, 'node', 'geom', '', 'node_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBPoint ) layer = QgsVectorLayer(uri.uri(), u'%s.node' % toponame, provider) layer.loadNamedStyle(os.path.join(template_dir, 'node.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) node_extent = layer.extent() # node labels uri.setDataSource(toponame, 'node', 'geom', '', 'node_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBPoint ) layer = QgsVectorLayer(uri.uri(), u'%s.node_id' % toponame, provider) layer.setExtent(node_extent) layer.loadNamedStyle(os.path.join(template_dir, 'node_label.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # EDGES group = legend.addGroup(u'Edges', False, supergroup) # edge uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBLineString ) layer = QgsVectorLayer(uri.uri(), u'%s.edge' % toponame, provider) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) edge_extent = layer.extent() # directed edge uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBLineString ) layer = QgsVectorLayer(uri.uri(), u'%s.directed_edge' % toponame, provider) layer.setExtent(edge_extent) layer.loadNamedStyle(os.path.join(template_dir, 'edge.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # edge labels uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBLineString ) layer = QgsVectorLayer(uri.uri(), u'%s.edge_id' % toponame, provider) layer.setExtent(edge_extent) layer.loadNamedStyle(os.path.join(template_dir, 'edge_label.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # face_left uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBLineString ) layer = QgsVectorLayer(uri.uri(), u'%s.face_left' % toponame, provider) layer.setExtent(edge_extent) layer.loadNamedStyle(os.path.join(template_dir, 'face_left.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # face_right uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBLineString ) layer = QgsVectorLayer(uri.uri(), u'%s.face_right' % toponame, provider) layer.setExtent(edge_extent) layer.loadNamedStyle(os.path.join(template_dir, 'face_right.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # next_left uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBLineString ) layer = QgsVectorLayer(uri.uri(), u'%s.next_left' % toponame, provider) layer.setExtent(edge_extent) layer.loadNamedStyle(os.path.join(template_dir, 'next_left.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) # next_right uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id') uri.setSrid( toposrid ) uri.setWkbType( QGis.WKBLineString ) layer = QgsVectorLayer(uri.uri(), u'%s.next_right' % toponame, provider) layer.setExtent(edge_extent) layer.loadNamedStyle(os.path.join(template_dir, 'next_right.qml')) registry.addMapLayers([layer]) legend.moveLayer(layer, group) legend.setLayerVisible(layer, False) legend.setLayerExpanded(layer, False) finally: # Set canvas extent to topology extent, if not yet initialized canvas = iface.mapCanvas() if ( canvas.fullExtent().isNull() ): ext = node_extent ext.combineExtentWith(edge_extent) # Grow by 1/20 of largest side ext = ext.buffer(max(ext.width(),ext.height())/20) canvas.setExtent(ext) # restore canvas render flag iface.mapCanvas().setRenderFlag( prevRenderFlagState ) return True
def newProject(self): """Create new project.""" # noinspection PyArgumentList QgsMapLayerRegistry.instance().removeAllMapLayers()
def test_signalConnection(self): # remove all layers QgsMapLayerRegistry.instance().removeAllMapLayers() # set dependencies and add back layers self.pointsLayer = QgsVectorLayer( "dbname='%s' table=\"node\" (geom) sql=" % self.fn, "points", "spatialite") assert (self.pointsLayer.isValid()) self.linesLayer = QgsVectorLayer( "dbname='%s' table=\"section\" (geom) sql=" % self.fn, "lines", "spatialite") assert (self.linesLayer.isValid()) self.pointsLayer2 = QgsVectorLayer( "dbname='%s' table=\"node2\" (geom) sql=" % self.fn, "_points2", "spatialite") assert (self.pointsLayer2.isValid()) self.pointsLayer.setDependencies( [QgsMapLayerDependency(self.linesLayer.id())]) self.pointsLayer2.setDependencies( [QgsMapLayerDependency(self.pointsLayer.id())]) # this should update connections between layers QgsMapLayerRegistry.instance().addMapLayers([self.pointsLayer]) QgsMapLayerRegistry.instance().addMapLayers([self.linesLayer]) QgsMapLayerRegistry.instance().addMapLayers([self.pointsLayer2]) ms = QgsMapSettings() ms.setOutputSize(QSize(100, 100)) ms.setExtent(QgsRectangle(0, 0, 1, 1)) self.assertTrue(ms.hasValidSettings()) u = QgsSnappingUtils() u.setMapSettings(ms) cfg = u.config() cfg.setMode(QgsSnappingConfig.AdvancedConfiguration) cfg.setIndividualLayerSettings( self.pointsLayer, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels)) cfg.setIndividualLayerSettings( self.pointsLayer2, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels)) u.setConfig(cfg) # add another line f = QgsFeature(self.linesLayer.fields()) f.setFeatureId(4) geom = QgsGeometry.fromWkt("LINESTRING(0.5 0.2,0.6 0)") f.setGeometry(geom) self.linesLayer.startEditing() self.linesLayer.addFeatures([f]) self.linesLayer.commitChanges() # check the second snapped point is ok m = u.snapToMap(QPoint(75, 100 - 0)) self.assertTrue(m.isValid()) self.assertTrue(m.hasVertex()) self.assertEqual(m.point(), QgsPoint(0.8, 0.0)) self.pointsLayer.setDependencies([]) self.pointsLayer2.setDependencies([])
def CheckLayer(self,layerpath): for lyr in QgsMapLayerRegistry.instance().mapLayers().values(): if lyr.dataProvider().dataSourceUri() == layerpath: return False return True
def setup_and_run_analysis(self): """Execute analysis after the tab is displayed. Please check the code in dock.py accept(). It should follow approximately the same code. """ self.show_busy() # Read user's settings self.read_settings() # Prepare impact function from wizard dialog user input self.impact_function = self.prepare_impact_function() # Prepare impact function status, message = self.impact_function.prepare() # Check status if status == PREPARE_FAILED_BAD_INPUT: self.hide_busy() LOGGER.info( tr('The impact function will not be able to run because of the ' 'inputs.')) LOGGER.info(message.to_text()) send_error_message(self, message) return status, message if status == PREPARE_FAILED_BAD_CODE: self.hide_busy() LOGGER.exception( tr('The impact function was not able to be prepared because of a ' 'bug.')) LOGGER.info(message.to_text()) send_error_message(self, message) return status, message # Start the analysis status, message = self.impact_function.run() # Check status if status == ANALYSIS_FAILED_BAD_INPUT: self.hide_busy() LOGGER.info( tr('The impact function could not run because of the inputs.')) LOGGER.info(message.to_text()) send_error_message(self, message) return status, message elif status == ANALYSIS_FAILED_BAD_CODE: self.hide_busy() LOGGER.exception( tr('The impact function could not run because of a bug.')) LOGGER.exception(message.to_text()) send_error_message(self, message) return status, message LOGGER.info(tr('The impact function could run without errors.')) # Add result layer to QGIS add_impact_layers_to_canvas(self.impact_function, self.parent.iface) # Some if-s i.e. zoom, debug, hide exposure if self.zoom_to_impact_flag: self.iface.zoomToActiveLayer() qgis_exposure = (QgsMapLayerRegistry.instance().mapLayer( self.parent.exposure_layer.id())) if self.hide_exposure_flag: legend = self.iface.legendInterface() legend.setLayerVisible(qgis_exposure, False) # Generate impact report error_code, message = generate_impact_report(self.impact_function, self.parent.iface) if error_code == ImpactReport.REPORT_GENERATION_FAILED: self.hide_busy() LOGGER.info(tr('The impact report could not be generated.')) send_error_message(self, message) LOGGER.info(message.to_text()) return ANALYSIS_FAILED_BAD_CODE, message # Generate Impact Map Report error_code, message = generate_impact_map_report( self.impact_function, self.iface) if error_code == ImpactReport.REPORT_GENERATION_FAILED: self.hide_busy() LOGGER.info(tr('The impact report could not be generated.')) send_error_message(self, message) LOGGER.info(message.to_text()) return ANALYSIS_FAILED_BAD_CODE, message self.extent.set_last_analysis_extent( self.impact_function.analysis_extent, qgis_exposure.crs()) # Hide busy self.hide_busy() # Setup gui if analysis is done self.setup_gui_analysis_done() return ANALYSIS_SUCCESS, None
def test(self): # Skip if GDAL python bindings are not available try: from osgeo import gdal, ogr except: return version_num = int(gdal.VersionInfo('VERSION_NUM')) if version_num < GDAL_COMPUTE_VERSION(1, 11, 0): return dialog = QgsNewGeoPackageLayerDialog() dialog.setProperty("hideDialogs", True) mDatabaseEdit = dialog.findChild(QLineEdit, "mDatabaseEdit") buttonBox = dialog.findChild(QDialogButtonBox, "buttonBox") ok_button = buttonBox.button(QDialogButtonBox.Ok) mTableNameEdit = dialog.findChild(QLineEdit, "mTableNameEdit") mLayerIdentifierEdit = dialog.findChild(QLineEdit, "mLayerIdentifierEdit") mLayerDescriptionEdit = dialog.findChild(QLineEdit, "mLayerDescriptionEdit") mFeatureIdColumnEdit = dialog.findChild(QLineEdit, "mFeatureIdColumnEdit") mGeometryTypeBox = dialog.findChild(QComboBox, "mGeometryTypeBox") mGeometryColumnEdit = dialog.findChild(QLineEdit, "mGeometryColumnEdit") mFieldNameEdit = dialog.findChild(QLineEdit, "mFieldNameEdit") mFieldTypeBox = dialog.findChild(QComboBox, "mFieldTypeBox") mFieldLengthEdit = dialog.findChild(QLineEdit, "mFieldLengthEdit") mAddAttributeButton = dialog.findChild(QToolButton, "mAddAttributeButton") mRemoveAttributeButton = dialog.findChild(QToolButton, "mRemoveAttributeButton") mAttributeView = dialog.findChild(QTreeWidget, "mAttributeView") dialog.accepted.connect(self.accepted_slot) mGeometryTypeBox.setCurrentIndex( mGeometryTypeBox.findData(ogr.wkbPoint)) self.assertEqual(mGeometryTypeBox.currentText(), "Point") self.assertFalse(ok_button.isEnabled()) dbname = os.path.join(self.basetestpath, 'test.gpkg') mDatabaseEdit.setText(dbname) self.assertEqual(mTableNameEdit.text(), 'test') self.assertEqual(mLayerIdentifierEdit.text(), 'test') self.assertTrue(ok_button.isEnabled()) mGeometryColumnEdit.setText('my_geom') mFeatureIdColumnEdit.setText('my_fid') self.assertFalse(mAddAttributeButton.isEnabled()) self.assertFalse(mRemoveAttributeButton.isEnabled()) mFieldNameEdit.setText('strfield') self.assertTrue(mAddAttributeButton.isEnabled()) mFieldLengthEdit.setText('10') QTest.mouseClick(mAddAttributeButton, Qt.LeftButton) mFieldNameEdit.setText('intfield') mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('integer')) self.assertFalse(mFieldLengthEdit.isEnabled()) QTest.mouseClick(mAddAttributeButton, Qt.LeftButton) mFieldNameEdit.setText('realfield') mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('real')) self.assertFalse(mFieldLengthEdit.isEnabled()) QTest.mouseClick(mAddAttributeButton, Qt.LeftButton) mFieldNameEdit.setText('datefield') mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('date')) self.assertFalse(mFieldLengthEdit.isEnabled()) QTest.mouseClick(mAddAttributeButton, Qt.LeftButton) mFieldNameEdit.setText('datetimefield') mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('datetime')) self.assertFalse(mFieldLengthEdit.isEnabled()) QTest.mouseClick(mAddAttributeButton, Qt.LeftButton) if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0): mFieldNameEdit.setText('int64field') mFieldTypeBox.setCurrentIndex(mFieldTypeBox.findData('integer64')) self.assertFalse(mFieldLengthEdit.isEnabled()) QTest.mouseClick(mAddAttributeButton, Qt.LeftButton) # Add and remove field mFieldNameEdit.setText('dummy') self.assertFalse(mFieldLengthEdit.isEnabled()) QTest.mouseClick(mAddAttributeButton, Qt.LeftButton) index = mAttributeView.model().index( mAttributeView.model().rowCount() - 1, 0) mAttributeView.setCurrentIndex(index) QTest.mouseClick(mRemoveAttributeButton, Qt.LeftButton) self.accepted = False QTest.mouseClick(ok_button, Qt.LeftButton) self.assertTrue(self.accepted) layers = QgsMapLayerRegistry.instance().mapLayers() self.assertEqual(len(layers), 1) layer = layers[list(layers.keys())[0]] self.assertEqual(layer.name(), 'test') self.assertEqual(layer.geometryType(), QGis.Point) QgsMapLayerRegistry.instance().removeAllMapLayers() ds = ogr.Open(dbname) lyr = ds.GetLayer(0) self.assertEqual(lyr.GetFIDColumn(), 'my_fid') self.assertEqual(lyr.GetGeometryColumn(), 'my_geom') self.assertEqual(lyr.GetGeomType(), ogr.wkbPoint) if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0): self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 6) else: self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 5) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(0).GetNameRef(), 'strfield') self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(0).GetType(), ogr.OFTString) # Only GDAL 2.0 recognizes string field width if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0): self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(0).GetWidth(), 10) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(1).GetNameRef(), 'intfield') self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(1).GetType(), ogr.OFTInteger) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(1).GetWidth(), 0) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(2).GetNameRef(), 'realfield') self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(2).GetType(), ogr.OFTReal) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(2).GetWidth(), 0) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(3).GetNameRef(), 'datefield') self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(3).GetType(), ogr.OFTDate) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(3).GetWidth(), 0) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetNameRef(), 'datetimefield') if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0): self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetType(), ogr.OFTDateTime) else: # There's a bug in OGR 1.11. The field is probably declared as DATETIME in SQL # but OGR detects it as OFTDate self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetType(), ogr.OFTDate) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(4).GetWidth(), 0) if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0): self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(5).GetNameRef(), 'int64field') self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(5).GetType(), ogr.OFTInteger64) self.assertEqual(lyr.GetLayerDefn().GetFieldDefn(5).GetWidth(), 0) ds = None # Try re-adding with different table. It should ask if we want to # overwrite the DB, and we'll implicitly answer cancel, hence failure mTableNameEdit.setText('table2') self.accepted = False QTest.mouseClick(ok_button, Qt.LeftButton) self.assertFalse(self.accepted) # Retry, and ask to keep the DB self.accepted = False dialog.setProperty('question_existing_db_answer_add_new_layer', True) QTest.mouseClick(ok_button, Qt.LeftButton) dialog.setProperty('question_existing_db_answer_add_new_layer', None) self.assertTrue(self.accepted) QgsMapLayerRegistry.instance().removeAllMapLayers() ds = ogr.Open(dbname) self.assertEqual(ds.GetLayerCount(), 2) ds = None # Retry, and ask to overwrite the DB self.accepted = False dialog.setProperty('question_existing_db_answer_overwrite', True) QTest.mouseClick(ok_button, Qt.LeftButton) dialog.setProperty('question_existing_db_answer_overwrite', None) self.assertTrue(self.accepted) QgsMapLayerRegistry.instance().removeAllMapLayers() ds = ogr.Open(dbname) self.assertEqual(ds.GetLayerCount(), 1) ds = None # Try re-adding with same parameters. It should ask if we want to # overwrite the layer, and we'll implicitly answer no, hence failure # since it already exists with that name self.accepted = False dialog.setProperty('question_existing_db_answer_add_new_layer', True) QTest.mouseClick(ok_button, Qt.LeftButton) dialog.setProperty('question_existing_db_answer_add_new_layer', None) self.assertFalse(self.accepted) # Now answer yes, and change a few things mLayerIdentifierEdit.setText('my_identifier') mLayerDescriptionEdit.setText('my_description') dialog.setProperty('question_existing_db_answer_add_new_layer', True) dialog.setProperty('question_existing_layer_answer_overwrite', True) self.accepted = False QTest.mouseClick(ok_button, Qt.LeftButton) dialog.setProperty('question_existing_db_answer_add_new_layer', None) dialog.setProperty('question_existing_layer_answer_overwrite', None) self.assertTrue(self.accepted) # Only check with OGR 2.0 since the IDENTIFIER and DESCRIPTION creation options don't exist in OGR 1.11 if version_num >= GDAL_COMPUTE_VERSION(2, 0, 0): layers = QgsMapLayerRegistry.instance().mapLayers() self.assertEqual(len(layers), 1) layer = layers[list(layers.keys())[0]] self.assertEqual(layer.name(), 'my_identifier') QgsMapLayerRegistry.instance().removeAllMapLayers() ds = ogr.Open(dbname) sql_lyr = ds.ExecuteSQL('SELECT * FROM gpkg_contents') self.assertEqual(sql_lyr.GetFeatureCount(), 1) f = sql_lyr.GetNextFeature() identifier = f.GetField('identifier') description = f.GetField('description') f = None ds.ReleaseResultSet(sql_lyr) ds = None self.assertEqual(identifier, 'my_identifier') self.assertEqual(description, 'my_description') else: QgsMapLayerRegistry.instance().removeAllMapLayers() # Try invalid path mDatabaseEdit.setText('/this/is/invalid/test.gpkg') self.accepted = False QTest.mouseClick(ok_button, Qt.LeftButton) self.assertFalse(self.accepted)