Beispiel #1
0
	def setViewIndex(self, index):
		old_index = self.viewIndex()
		if index == old_index:
			return

		self.stacked.setCurrentIndex(index)
		if index == 0:
			self.setWindowTitle( "Filter/Plot panel" )
		elif index == 1:
			self.setWindowTitle( "Classification panel" )
		elif index == 2:
			self.setWindowTitle( "Processing panel" )
		else:
			self.setWindowTitle( "GEM-MT panel" )

		# show/hide layers
		QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
		prev_render_flag = Utils.iface.mapCanvas().renderFlag()
		Utils.iface.mapCanvas().setRenderFlag( False )
		try:
			if index in (1, 2):
				# add the layer with classified data
				Utils.addVectorLayer( Utils.classifiedVl() )
				# show or hide the events layer respectively when the classification or processing panel is shown
				Utils.iface.legendInterface().setLayerVisible( Utils.eventsVl(), index == 1 )
		finally:
			# restore render flag state and cursor
			Utils.iface.mapCanvas().setRenderFlag( prev_render_flag )
			QApplication.restoreOverrideCursor()
Beispiel #2
0
    def setViewIndex(self, index):
        old_index = self.viewIndex()
        if index == old_index:
            return

        self.stacked.setCurrentIndex(index)
        if index == 0:
            self.setWindowTitle("Filter/Plot panel")
        elif index == 1:
            self.setWindowTitle("Classification panel")
        elif index == 2:
            self.setWindowTitle("Processing panel")
        else:
            self.setWindowTitle("GEM-MT panel")

        # show/hide layers
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        prev_render_flag = Utils.iface.mapCanvas().renderFlag()
        Utils.iface.mapCanvas().setRenderFlag(False)
        try:
            if index in (1, 2):
                # add the layer with classified data
                Utils.addVectorLayer(Utils.classifiedVl())
                # show or hide the events layer respectively when the classification or processing panel is shown
                Utils.iface.legendInterface().setLayerVisible(
                    Utils.eventsVl(), index == 1)
        finally:
            # restore render flag state and cursor
            Utils.iface.mapCanvas().setRenderFlag(prev_render_flag)
            QApplication.restoreOverrideCursor()
Beispiel #3
0
	def addBasemapLayer(self):
		if self.basemapVl:
			return # already added

		current_dir = QFileInfo(__file__).absoluteDir()
		basemap = current_dir.absoluteFilePath( u"data/basemap/Countries.shp" )

		# load the basemap layer
		vl = QgsVectorLayer(basemap, QFileInfo(basemap).baseName(), "ogr")
		if not vl.isValid():
			vl.deleteLater()
			return

		# add the basemap layer to canvas
		LayerStyler.setBasemapStyle(vl)
		self.basemapVl = vl
		QObject.connect( self.basemapVl, SIGNAL("layerDeleted()"), self.basemapLayerDestroyed )
		Utils.addVectorLayer(vl)
Beispiel #4
0
    def addBasemapLayer(self):
        if self.basemapVl:
            return  # already added

        current_dir = QFileInfo(__file__).absoluteDir()
        basemap = current_dir.absoluteFilePath(u"data/basemap/Countries.shp")

        # load the basemap layer
        vl = QgsVectorLayer(basemap, QFileInfo(basemap).baseName(), "ogr")
        if not vl.isValid():
            vl.deleteLater()
            return

        # add the basemap layer to canvas
        LayerStyler.setBasemapStyle(vl)
        self.basemapVl = vl
        QObject.connect(self.basemapVl, SIGNAL("layerDeleted()"),
                        self.basemapLayerDestroyed)
        Utils.addVectorLayer(vl)
Beispiel #5
0
    def loadCsv(self):
        """ load the CSV file selected by the user """
        # ask for the csv file
        filename = QFileDialog.getOpenFileName(self.iface.mainWindow(),
                                               "Select a csv file", QString(),
                                               "CSV file (*.csv)")
        if filename.isEmpty():
            return  # cancel clicked

        # unset the render flag
        prev_render_flag = self.iface.mapCanvas().renderFlag()
        self.iface.mapCanvas().setRenderFlag(False)

        # set the waiting cursor
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        try:
            # import CSV file to SL database
            from importer import CsvToSL
            importer = CsvToSL(filename, self.iface.mainWindow())
            retCode, vl = importer.run()
            importer.deleteLater()
            del importer

            # ret code check
            if vl is None or retCode != CsvToSL.OK:
                if retCode == CsvToSL.INVALID_LATLON:
                    self.settings()  # show the settings dialog
                return

            # ok, the new layer can be used with the plugin
            # remove the previous loaded layer, then store the new one
            self.removeLayer()
            self.setLayer(vl)

            # add the basemap layer, then the new layer
            self.addBasemapLayer()
            Utils.addVectorLayer(self.vl)

        finally:
            # restore the cursor and render flag state
            QApplication.restoreOverrideCursor()
            self.iface.mapCanvas().setRenderFlag(prev_render_flag)
Beispiel #6
0
	def loadCsv(self):
		""" load the CSV file selected by the user """
		# ask for the csv file
		filename = QFileDialog.getOpenFileName(self.iface.mainWindow(), "Select a csv file", QString(), "CSV file (*.csv)")
		if filename.isEmpty():
			return	# cancel clicked

		# unset the render flag
		prev_render_flag = self.iface.mapCanvas().renderFlag()
		self.iface.mapCanvas().setRenderFlag( False )

		# set the waiting cursor
		QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
		try:
			# import CSV file to SL database
			from importer import CsvToSL
			importer = CsvToSL(filename, self.iface.mainWindow())
			retCode, vl = importer.run()
			importer.deleteLater()
			del importer

			# ret code check
			if vl is None or retCode != CsvToSL.OK:
				if retCode == CsvToSL.INVALID_LATLON:
					self.settings()	# show the settings dialog
				return
			
			# ok, the new layer can be used with the plugin
			# remove the previous loaded layer, then store the new one
			self.removeLayer()
			self.setLayer(vl)

			# add the basemap layer, then the new layer
			self.addBasemapLayer()
			Utils.addVectorLayer(self.vl)

		finally:
			# restore the cursor and render flag state
			QApplication.restoreOverrideCursor()
			self.iface.mapCanvas().setRenderFlag( prev_render_flag )
Beispiel #7
0
    def _loadClassifiedData(self):
        # get the geometry which defines the area of interest
        areaGeom = self.areaDrawer.geometry()
        if not areaGeom or areaGeom.isGeosEmpty():
            QMessageBox.warning(
                self, "No Area of interest",
                "Define an Area of interest and then try again.")
            return

        # convert the spatial filter to the layer CRS
        toLayerCrsTransform = QgsCoordinateTransform(
            self.canvas.mapRenderer().destinationCrs(), self.vl.crs())
        ret = areaGeom.transform(toLayerCrsTransform)
        if ret != 0:
            QMessageBox.warning(
                self, "Invalid area",
                "Unable to tranform the selected area to the layer CRS.")
            return

        # update the classification
        self.updateClassification()

        classifiedVl = Utils.classifiedVl()
        outpr = classifiedVl.dataProvider()

        # remove all the features in the classified events layer
        classifiedVl.removeSelection()
        classifiedVl.invertSelection()
        outpr.deleteFeatures(classifiedVl.selectedFeaturesIds())

        # fetch and loop through the features
        inpr = self.vl.dataProvider()
        inpr.select(self.vl.pendingAllAttributesList(), areaGeom.boundingBox(),
                    True)

        betweenLayersCrsTransform = QgsCoordinateTransform(
            self.vl.crs(), classifiedVl.crs())
        f = QgsFeature()
        while inpr.nextFeature(f):
            geom = f.geometry()

            # filter features by spatial filter
            if not areaGeom.contains(geom):
                continue

            # skip unclassified data
            if f.id() not in self._sharedData:
                continue
            classType = self._sharedData[f.id()]

            # transform to classified layer CRS
            if geom.transform(betweenLayersCrsTransform) != 0:
                continue
            f.setGeometry(QgsGeometry.fromPoint(geom.asPoint()))

            # set feature attributes
            attrs = {}
            for index, attr in sorted(f.attributeMap().iteritems()):
                attrs[len(attrs)] = attr
            attrs[len(attrs)] = 'shallow' if classType == 0 else 'deep'
            f.setAttributeMap(attrs)

            # add the feature
            outpr.addFeatures([f])

        # update layer's extent when new features have been added
        # because change of extent in provider is not propagated to the layer
        classifiedVl.updateExtents()

        # add the layer to the map
        Utils.addVectorLayer(classifiedVl)
Beispiel #8
0
	def _loadClassifiedData(self):
		# get the geometry which defines the area of interest
		areaGeom = self.areaDrawer.geometry()
		if not areaGeom or areaGeom.isGeosEmpty():
			QMessageBox.warning(self, "No Area of interest", "Define an Area of interest and then try again.")
			return

		# convert the spatial filter to the layer CRS
		toLayerCrsTransform = QgsCoordinateTransform( self.canvas.mapRenderer().destinationCrs(), self.vl.crs() )
		ret = areaGeom.transform( toLayerCrsTransform )
		if ret != 0:
			QMessageBox.warning(self, "Invalid area", "Unable to tranform the selected area to the layer CRS.")
			return

		# update the classification
		self.updateClassification()

		classifiedVl = Utils.classifiedVl()
		outpr = classifiedVl.dataProvider()

		# remove all the features in the classified events layer
		classifiedVl.removeSelection()
		classifiedVl.invertSelection()
		outpr.deleteFeatures( classifiedVl.selectedFeaturesIds() )

		# fetch and loop through the features
		inpr = self.vl.dataProvider()
		inpr.select(self.vl.pendingAllAttributesList(), areaGeom.boundingBox(), True)

		betweenLayersCrsTransform = QgsCoordinateTransform( self.vl.crs(), classifiedVl.crs() )
		f = QgsFeature()
		while inpr.nextFeature( f ):
			geom = f.geometry()

			# filter features by spatial filter
			if not areaGeom.contains( geom ):
				continue

			# skip unclassified data
			if f.id() not in self._sharedData:
				continue
			classType = self._sharedData[ f.id() ]

			# transform to classified layer CRS
			if geom.transform( betweenLayersCrsTransform ) != 0:
				continue
			f.setGeometry( QgsGeometry.fromPoint(geom.asPoint()) )

			# set feature attributes
			attrs = {}
			for index, attr in sorted(f.attributeMap().iteritems()):
				attrs[ len(attrs) ] = attr
			attrs[ len(attrs) ] =  'shallow' if classType == 0 else 'deep'
			f.setAttributeMap( attrs )

			# add the feature
			outpr.addFeatures( [f] )

		# update layer's extent when new features have been added
		# because change of extent in provider is not propagated to the layer
		classifiedVl.updateExtents()

		# add the layer to the map
		Utils.addVectorLayer( classifiedVl )