def __init__(self, p1, p2, p3=None): if p3 is None: p3 = QgsPoint(p2) p2 = self.createMiddlePoint(p1, p3) self.p1 = QgsPoint(p1) self.p2 = QgsPoint(p2) self.p3 = QgsPoint(p3)
def canvasMoveEvent(self, event): if self.snapCursorRubberBand: self.snapCursorRubberBand.hide() self.snapCursorRubberBand.reset(geometryType=QGis.Point) self.snapCursorRubberBand = None oldPoint = QgsPoint(event.mapPoint()) event.snapPoint(QgsMapMouseEvent.SnapProjectConfig) point = QgsPoint(event.mapPoint()) if oldPoint != point: self.createSnapCursor(point) point = QgsPoint(event.mapPoint()) if self.qntPoint == 1: self.distanceToolTip.canvasMoveEvent(self.geometry[0], point) geom = QgsGeometry.fromPolyline([self.geometry[0], point]) self.rubberBand.setToGeometry(geom, None) elif self.qntPoint >= 2: self.distanceToolTip.canvasMoveEvent(self.geometry[-1], point) if self.free: geom = QgsGeometry.fromPolygon([self.geometry+[QgsPoint(point.x(), point.y())]]) self.rubberBand.setToGeometry(geom, None) else: if (self.qntPoint % 2 == 1): self.setAvoidStyleSnapRubberBand() else: self.setAllowedStyleSnapRubberBand() projectedMousePoint = self.projectPoint(self.geometry[-2], self.geometry[-1], point) if projectedMousePoint: geom, pf = self.completePolygon(self.geometry, projectedMousePoint) self.rubberBand.setToGeometry(geom, None)
def draw_position(self,Latitud,Longitud,v_layer,option): #create the provider and add the layer pr = v_layer.dataProvider() QgsMapLayerRegistry.instance().addMapLayers([v_layer]) seg = QgsFeature() #create the point and paint it try: point_A = QgsPoint((float(Longitud)-181-6.339908),(float(Latitud)-91+39.478360)) seg.setGeometry(QgsGeometry.fromPoint(point_A)) pr.addFeatures( [ seg ] ) v_layer.updateExtents() v_layer.triggerRepaint() label=None if option==1: label=self.dlg.label_6 elif option==2: label=self.dlg.label_7 elif option==3: label=self.dlg.label_8 if self.pointInLimits(point_A.x(),point_A.y())==True: label.setText("IN") self.distances(point_A.x(),point_A.y(),option) else: label.setText("OUT") self.deletePoints(v_layer) except: pass
def testSubstitutionMap(self): """Test that we can use degree symbols in substitutions. """ # Create a point and convert it to text containing a degree symbol. myPoint = QgsPoint(12.3, -33.33) myCoordinates = myPoint.toDegreesMinutesSeconds(2) myTokens = myCoordinates.split(',') myLongitude = myTokens[0] myLatitude = myTokens[1] myText = 'Latitude: %s, Longitude: %s' % (myLatitude, myLongitude) # Load the composition with the substitutions myComposition = QgsComposition(self.iface.mapCanvas().mapRenderer()) mySubstitutionMap = {'replace-me': myText} myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt') myTemplateFile = file(myFile, 'rt') myTemplateContent = myTemplateFile.read() myTemplateFile.close() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument, mySubstitutionMap) # We should be able to get map0 myMap = myComposition.getComposerMapById(0) myMessage = ('Map 0 could not be found in template %s', myFile) assert myMap is not None, myMessage
def _calc_north(self): extent = self.canvas.extent() if self.canvas.layerCount() == 0 or extent.isEmpty(): print "No layers or extent" return 0 outcrs = self.canvas.mapSettings().destinationCrs() if outcrs.isValid() and not outcrs.geographicFlag(): crs = QgsCoordinateReferenceSystem() crs.createFromOgcWmsCrs("EPSG:4326") transform = QgsCoordinateTransform(outcrs, crs) p1 = QgsPoint(extent.center()) p2 = QgsPoint(p1.x(), p1.y() + extent.height() * 0.25) try: pp1 = transform.transform(p1) pp2 = transform.transform(p2) except QgsCsException: roam.utils.warning("North arrow. Error transforming.") return None area = QgsDistanceArea() area.setEllipsoid(crs.ellipsoidAcronym()) area.setEllipsoidalMode(True) area.setSourceCrs(crs) distance, angle, _ = area.computeDistanceBearing(pp1, pp2) angle = math.degrees(angle) return angle else: return 0
class TestQgsPoint(unittest.TestCase): def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) def setUp(self): self.mPoint = QgsPoint(10.0, 10.0) def test_Point(self): myExpectedValue = 10.0 myActualValue = self.mPoint.x() myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue) assert myExpectedValue == myActualValue, myMessage def test_pointToString(self): myExpectedValue = '10, 10' myActualValue = self.mPoint.toString() myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue) assert myExpectedValue == myActualValue, myMessage def test_hash(self): a = QgsPoint(2.0, 1.0) b = QgsPoint(2.0, 2.0) c = QgsPoint(1.0, 2.0) d = QgsPoint(1.0, 1.0) e = QgsPoint(2.0, 1.0) assert a.__hash__() != b.__hash__() assert e.__hash__() == a.__hash__() mySet = set([a, b, c, d, e]) assert len(mySet) == 4
def calculateSquare(self, point): ''' point in layer coordinates(QgsPoint) ''' mapCrs = self.canvas.mapSettings().destinationCrs() utmCrs = QgsCoordinateReferenceSystem() utmCrs.createFromProj4(self.proj4Utm(point)) ctFwd = QgsCoordinateTransform(mapCrs, utmCrs) ctBwd = QgsCoordinateTransform(utmCrs, mapCrs) pointGeom = QgsGeometry.fromPoint(point) pointGeom.transform(ctFwd) pointUtm = QgsPoint(pointGeom.asPoint()) # calculate d d = self.diagonal/(2*(2**0.5)) l = pointUtm.x() - d b = pointUtm.y() - d r = pointUtm.x() + d t = pointUtm.y() + d p1 = QgsGeometry.fromPoint(QgsPoint(l, b)) p2 = QgsGeometry.fromPoint(QgsPoint(r, b)) p3 = QgsGeometry.fromPoint(QgsPoint(r, t)) p4 = QgsGeometry.fromPoint(QgsPoint(l, t)) p1.transform(ctBwd) p2.transform(ctBwd) p3.transform(ctBwd) p4.transform(ctBwd) mapPol = [p1.asPoint(), p2.asPoint(), p3.asPoint(), p4.asPoint(), p1.asPoint()] return mapPol
def normalizePoint(self, x, y): """Normalize given point. In result, lower-left is (0, 0) and upper-right is (1, 1).""" pt = QgsPoint(x, y) if self._rotation: pt = self.rotatePoint(pt, -self._rotation, self._center) rect = self._unrotated_rect return QgsPoint((pt.x() - rect.xMinimum()) / rect.width(), (pt.y() - rect.yMinimum()) / rect.height())
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) fields = source.fields() x_field_index = fields.lookupField(self.parameterAsString(parameters, self.XFIELD, context)) y_field_index = fields.lookupField(self.parameterAsString(parameters, self.YFIELD, context)) z_field_index = -1 if self.parameterAsString(parameters, self.ZFIELD, context): z_field_index = fields.lookupField(self.parameterAsString(parameters, self.ZFIELD, context)) m_field_index = -1 if self.parameterAsString(parameters, self.MFIELD, context): m_field_index = fields.lookupField(self.parameterAsString(parameters, self.MFIELD, context)) wkb_type = QgsWkbTypes.Point if z_field_index >= 0: wkb_type = QgsWkbTypes.addZ(wkb_type) if m_field_index >= 0: wkb_type = QgsWkbTypes.addM(wkb_type) target_crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, wkb_type, target_crs) request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry) features = source.getFeatures() total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, feature in enumerate(features): if feedback.isCanceled(): break feedback.setProgress(int(current * total)) attrs = feature.attributes() try: x = float(attrs[x_field_index]) y = float(attrs[y_field_index]) point = QgsPoint(x, y) if z_field_index >= 0: try: point.addZValue(float(attrs[z_field_index])) except: point.addZValue(0.0) if m_field_index >= 0: try: point.addMValue(float(attrs[m_field_index])) except: point.addMValue(0.0) feature.setGeometry(QgsGeometry(point)) except: pass # no geometry sink.addFeature(feature) return {self.OUTPUT: dest_id}
class Observation(): def __init__(self, iface, obsType, point, observation, precision): memoryLayers = MemoryLayers(iface) self.lineLayer = memoryLayers.line_layer() self.pointLayer = memoryLayers.point_layer() # generate ID; self.id = datetime.now().strftime("%Y%m%d%H%M%S%f") # obsservations are stored in the lineLayer layer attributes: # 0: id # 1: observation type # 2: x # 3: y # 4: observation # 5: precision self.obsType = obsType self.point = QgsPoint(point) self.observation = observation self.precision = precision def geometry(self): return QgsGeometry() def save(self): # observation f = QgsFeature() fields = self.lineLayer.dataProvider().fields() f.setFields(fields) f["id"] = self.id f["type"] = self.obsType f["x"] = self.point.x() f["y"] = self.point.y() f["observation"] = self.observation f["precision"] = self.precision f.setGeometry(self.geometry()) ok, l = self.lineLayer.dataProvider().addFeatures([f]) self.lineLayer.updateExtents() self.lineLayer.setCacheImage(None) self.lineLayer.triggerRepaint() self.lineLayer.featureAdded.emit(l[0].id()) # emit signal so feature is added to snapping index # center f = QgsFeature() fields = self.pointLayer.dataProvider().fields() f.setFields(fields) f["id"] = self.id f.setGeometry(QgsGeometry().fromPoint(self.point)) ok, l = self.pointLayer.dataProvider().addFeatures([f]) self.pointLayer.updateExtents() self.pointLayer.setCacheImage(None) self.pointLayer.triggerRepaint() self.pointLayer.featureAdded.emit(l[0].id()) # emit signal so feature is added to snapping index
def processAlgorithm(self, parameters, context, feedback): source = self.getParameterValue(self.INPUT) vlayer = QgsProcessingUtils.mapLayerFromString(source, context) output = self.getOutputFromName(self.OUTPUT) fields = vlayer.fields() x_field_index = fields.lookupField(self.getParameterValue(self.XFIELD)) y_field_index = fields.lookupField(self.getParameterValue(self.YFIELD)) z_field_index = None if self.getParameterValue(self.ZFIELD): z_field_index = fields.lookupField(self.getParameterValue(self.ZFIELD)) m_field_index = None if self.getParameterValue(self.MFIELD): m_field_index = fields.lookupField(self.getParameterValue(self.MFIELD)) wkb_type = QgsWkbTypes.Point if z_field_index is not None: wkb_type = QgsWkbTypes.addZ(wkb_type) if m_field_index is not None: wkb_type = QgsWkbTypes.addM(wkb_type) crsId = self.getParameterValue(self.TARGET_CRS) target_crs = QgsCoordinateReferenceSystem() target_crs.createFromUserInput(crsId) writer = output.getVectorWriter(fields, wkb_type, target_crs, context) features = QgsProcessingUtils.getFeatures(vlayer, context) total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context) for current, feature in enumerate(features): feedback.setProgress(int(current * total)) attrs = feature.attributes() try: x = float(attrs[x_field_index]) y = float(attrs[y_field_index]) point = QgsPoint(x, y) if z_field_index is not None: try: point.addZValue(float(attrs[z_field_index])) except: point.addZValue(0.0) if m_field_index is not None: try: point.addMValue(float(attrs[m_field_index])) except: point.addMValue(0.0) feature.setGeometry(QgsGeometry(point)) except: pass # no geometry writer.addFeature(feature) del writer
def event_dict(self): tz = pytz.timezone("Asia/Jakarta") timestamp = self.time.astimezone(tz=tz) time_format = "%-d-%b-%Y %H:%M:%S" timestamp_string = timestamp.strftime(time_format) point = QgsPoint(self.longitude, self.latitude) coordinates = point.toDegreesMinutesSeconds(2) tokens = coordinates.split(",") longitude_string = tokens[0] latitude_string = tokens[1] elapsed_time = datetime.datetime.utcnow().replace(tzinfo=pytz.utc) - self.time elapsed_hour = elapsed_time.seconds / 3600 elapsed_minute = (elapsed_time.seconds / 60) % 60 event = { "report-title": self.tr("Volcanic Ash Impact"), "report-timestamp": self.tr("Volcano: %s, Alert Level: %s %s") % (self.volcano_name, self.alert_level, timestamp_string), "report-province": self.tr("Province: %s") % (self.region,), "report-location": self.tr("Longitude %s Latitude %s;" " Eruption Column Height (a.s.l) - %d m") % (longitude_string, latitude_string, self.erupction_height), "report-elapsed": self.tr("Elapsed time since event %s hour(s) and %s minute(s)") % (elapsed_hour, elapsed_minute), "header-impact-table": self.tr("Potential impact at each fallout level"), "header-nearby-table": self.tr("Nearby places"), "header-landcover-table": self.tr("Land Cover Impact"), "content-disclaimer": self.tr( "The impact estimation is automatically generated and only " "takes into account the population, cities and land cover " "affected by different levels of volcanic ash fallout at " "surface level. The estimate is based on volcanic ash " "fallout data from Badan Geologi, population count data " "derived by DMInnovation from worldpop.org.uk, place " "information from geonames.org, land cover classification " "data provided by Indonesian Geospatial Portal at " "http://portal.ina-sdi.or.id and software developed by BNPB. " "Limitation in the estimates of surface fallout, population " "and place names datasets may result in significant " "misrepresentation of the on-the-surface situation in the " "figures shown here. Consequently decisions should not be " "made soley on the information presented here and should " "always be verified by ground truthing and other reliable " "information sources." ), "content-notes": self.tr( "This report was created using InaSAFE version %s. Visit " "http://inasafe.org for more information. " ) % get_version(), } return event
def cntr2bugs(self): mLayer = self.checklayer() if mLayer is not None: QApplication.setOverrideCursor(Qt.WaitCursor) dlg = editor.Dialog() dlg.setModal(True) dlg.setWindowTitle("Centroids in BUGS format") provider = mLayer.dataProvider() e = provider.featureCount() ids = [] x = "x = c(" y = "y = c(" feats = provider.getFeatures() dlg.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0) dlg.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, e)) ne = 0 feat = QgsFeature() while feats.nextFeature(feat): ne += 1 dlg.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne) ids.append(feat.id()) mod = min(ids) for ne in range(mod, e + mod): feat = QgsFeature() pt = QgsPoint() fiter = mLayer.getFeatures(QgsFeatureRequest(ne)) if fiter.nextFeature(feat): pt = QgsGeometry(feat.geometry().centroid()).asPoint() # pt = QgsGeometry(geom.centroid()).asPoint() x += '%s, ' % pt.x() y += '%s, ' % pt.y() dlg.plainTextEdit.appendPlainText(x[:-2]+')') dlg.plainTextEdit.appendPlainText(y[:-2]+')') QApplication.restoreOverrideCursor() dlg.exec_()
def test_hash(self): a = QgsPoint(2.0, 1.0) b = QgsPoint(2.0, 2.0) c = QgsPoint(1.0, 2.0) d = QgsPoint(1.0, 1.0) e = QgsPoint(2.0, 1.0) assert a.__hash__() != b.__hash__() assert e.__hash__() == a.__hash__() mySet = set([a, b, c, d, e]) assert len(mySet) == 4
class TestQgsPoint(TestCase): def __init__(self, methodName): """Run once on class initialisation.""" unittest.TestCase.__init__(self, methodName) def setUp(self): self.mPoint = QgsPoint(10.0, 10.0) def test_Point(self): myExpectedValue = 10.0 myActualValue = self.mPoint.x() myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue) assert myExpectedValue == myActualValue, myMessage def test_pointToString(self): myExpectedValue = '10, 10' myActualValue = self.mPoint.toString() myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue) assert myExpectedValue == myActualValue, myMessage
def processNewData(self, data): ''' Process incoming data from the data provider :param data: Positon or attitude data :type data: dict ''' if not self.enabled: return try: name = data['name'] if name in self.messageFilter.keys(): if data['id'] != self.messageFilter[name]: return except: pass self.extData.update(data) if 'lat' in data and 'lon' in data: self.position = QgsPoint(data['lon'], data['lat']) self.heading = data.get('heading', -9999.9) self.depth = data.get('depth', -9999.9) try: self.coordinates = self.crsXform.transform(self.position) self.marker.setMapPosition(self.coordinates) if 'time' in data: self.lastFix = data['time'] self.newPosition.emit(self.lastFix, self.position, self.extData.get('depth', -9999.9), self.extData.get('altitude', -9999.9)) self.timer.start(self.timeoutTime) self.timeoutCount = 0 except QgsCsException: pass elif self.position is not None: if 'depth' in data or 'altitude' in data: self.newPosition.emit(self.lastFix, self.position, self.extData.get('depth', -9999.9), self.extData.get('altitude', -9999.9)) if 'heading' in data: self.newAttitude.emit(data['heading'], data.get('pitch', 0.0), data.get('roll', 0.0)) self.marker.newHeading(data['heading'])
def __init__(self, iface, obsType, point, observation, precision): memoryLayers = MemoryLayers(iface) self.lineLayer = memoryLayers.line_layer() self.pointLayer = memoryLayers.point_layer() # generate ID; self.id = datetime.now().strftime("%Y%m%d%H%M%S%f") # obsservations are stored in the lineLayer layer attributes: # 0: id # 1: observation type # 2: x # 3: y # 4: observation # 5: precision self.obsType = obsType self.point = QgsPoint(point) self.observation = observation self.precision = precision
def __init__(self,parent = None,x=0,y=0): QWidget.__init__(self,parent) self.resize(270, 130) self._gridLayout = QGridLayout(self) self._sbYCoord = QDoubleSpinBox(self) self._sbYCoord.setMinimumSize(QSize(0, 30)) self._sbYCoord.setDecimals(5) self._sbYCoord.setMinimum(-180.0) self._sbYCoord.setMaximum(180.0) self._gridLayout.addWidget(self._sbYCoord, 2, 1, 1, 1) self._label_2 = QLabel(self) self._label_2.setText(QApplication.translate("CoordinatesWidget","Y-Coordinate")) self._gridLayout.addWidget(self._label_2, 2, 0, 1, 1) self._label = QLabel(self) self._label.setMaximumSize(QSize(80, 16777215)) self._label.setText(QApplication.translate("CoordinatesWidget","X-Coordinate")) self._gridLayout.addWidget(self._label, 1, 0, 1, 1) self._sbXCoord = QDoubleSpinBox(self) self._sbXCoord.setMinimumSize(QSize(0, 30)) self._sbXCoord.setDecimals(5) self._sbXCoord.setMinimum(-180.0) self._sbXCoord.setMaximum(180.0) self._gridLayout.addWidget(self._sbXCoord, 1, 1, 1, 1) self.vlNotification = QVBoxLayout() self._gridLayout.addLayout(self.vlNotification, 0, 0, 1, 2) #Set X and Y values self._sbXCoord.setValue(float(x)) self._sbYCoord.setValue(float(y)) self._geomPoint = QgsPoint(x,y) #Use default SRID self._srid = 4326 #Connect signals self._sbXCoord.valueChanged.connect(self.onXCoordValueChanged) self._sbYCoord.valueChanged.connect(self.onYCoordValueChanged)
def arc(p1, p2, offset=1): # point in middle mp = QgsPoint((p1.x()+p2.x())/2, (p1.y()+p2.y())/2) # distance between the two points d = sqrt(p1.sqrDist(p2)) # orthogonal direction to segment p1-p2 az = (p1.azimuth(p2)+90)*pi/180 # create point distant to segment of offset of segment length, will be center of circular arc cp = QgsPoint(mp.x()+d*offset*sin(az), mp.y()+d*offset*cos(az)) # radius r = d*sqrt(4*offset*offset+1)/2 # calculate start and end azimuth of circular arc az1 = cp.azimuth(p1) az2 = cp.azimuth(p2) if az2 < az1: az2 += 360 # draw arc vx = [cp.x()+r*sin(az*pi/180) for az in floatrange(az1, az2, 5)] vy = [cp.y()+r*cos(az*pi/180) for az in floatrange(az1, az2, 5)] arcLine = [QgsPoint(vx[i], vy[i]) for i in range(len(vx))] return QgsGeometry().fromPolyline(arcLine)
class MobileItem(QObject): ''' A Mobile Item that reveives its position from a dataprovider and is displayed on the canvas Could be everything liek vehicles or simple beacons ''' mobileItemCount = 0 newPosition = pyqtSignal(float, QgsPoint, float, float) newAttitude = pyqtSignal(float, float, float) # heading, pitch, roll timeout = pyqtSignal() def __init__(self, iface, params={}, parent=None): ''' Constructor :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface :param params: A dictionary defining all the properties of the item :type params: dictionary :param parent: Parent object for the new item. Defaults None. :type parent: QObject ''' super(MobileItem, self).__init__(parent) self.iface = iface self.canvas = iface.mapCanvas() MobileItem.mobileItemCount += 1 self.name = params.setdefault('Name', 'MobileItem_' + str(MobileItem.mobileItemCount)) self.marker = PositionMarker(self.canvas, params) self.marker.setToolTip(self.name) self.dataProvider = params.get('provider', dict()) self.messageFilter = dict() self.extData = dict() self.coordinates = None self.position = None self.heading = 0.0 self.depth = 0.0 self.lastFix = 0.0 self.crsXform = QgsCoordinateTransform() self.crsXform.setSourceCrs(QgsCoordinateReferenceSystem(4326)) self.onCrsChange() self.canvas.destinationCrsChanged.connect(self.onCrsChange) self.timer = QTimer(self) self.timer.timeout.connect(self.timeout) self.notifyCount = int(params.get('nofixNotify', 0)) if self.notifyCount: self.timer.timeout.connect(self.notifyTimeout) self.timeoutCount = 0 self.timeoutTime = int(params.get('timeout', 3000)) self.notifyDuration = int(params.get('NotifyDuration', 0)) self.enabled = True def removeFromCanvas(self): ''' Remove the item and its track from the canvas ''' self.marker.removeFromCanvas() def properties(self): ''' Return the items properties as dictionary :returns: Items properties :rtype: dict ''' d = {'Name' : self.name, 'timeout': self.timeoutTime, 'nofixNotify': self.notifyCount, 'enabled': self.enabled, 'provider' : self.dataProvider} d.update(self.marker.properties()) return d def subscribePositionProvider(self, provider, filterId=None): ''' Subscribe the provider for this item by connecting to the providers signals :param provider: Provider to connect to :type provider: DataProvider :param filterId: Filter Id for this item :type filterId: ''' provider.newDataReceived.connect(self.processNewData) if filterId is not None: self.messageFilter[provider.name] = filterId elif provider.name in self.messageFilter.keys(): self.messageFilter.pop(provider.name, None) def unsubscribePositionProvider(self, provider): ''' Unsubscribe provider by disconnecting the providers signals :param provider: Provider to diconnect from :type provider: DataProvider ''' try: provider.newDataReceived.disconnect(self.processData) self.messageFilter.pop(provider.name, None) except KeyError: pass @pyqtSlot(dict) def processNewData(self, data): ''' Process incoming data from the data provider :param data: Positon or attitude data :type data: dict ''' if not self.enabled: return try: name = data['name'] if name in self.messageFilter.keys(): if data['id'] != self.messageFilter[name]: return except: pass self.extData.update(data) if 'lat' in data and 'lon' in data: self.position = QgsPoint(data['lon'], data['lat']) self.heading = data.get('heading', -9999.9) self.depth = data.get('depth', -9999.9) try: self.coordinates = self.crsXform.transform(self.position) self.marker.setMapPosition(self.coordinates) if 'time' in data: self.lastFix = data['time'] self.newPosition.emit(self.lastFix, self.position, self.extData.get('depth', -9999.9), self.extData.get('altitude', -9999.9)) self.timer.start(self.timeoutTime) self.timeoutCount = 0 except QgsCsException: pass elif self.position is not None: if 'depth' in data or 'altitude' in data: self.newPosition.emit(self.lastFix, self.position, self.extData.get('depth', -9999.9), self.extData.get('altitude', -9999.9)) if 'heading' in data: self.newAttitude.emit(data['heading'], data.get('pitch', 0.0), data.get('roll', 0.0)) self.marker.newHeading(data['heading']) @pyqtSlot(float) def onScaleChange(self, scale): ''' Slot called when the map is zoomed :param scale: New scale :type scale: float ''' self.marker.updateSize() @pyqtSlot() def onCrsChange(self): ''' SLot called when the mapcanvas CRS is changed ''' crsDst = self.canvas.mapSettings().destinationCrs() self.crsXform.setDestCRS(crsDst) self.marker.updateSize() @pyqtSlot(bool) def setEnabled(self, enabled): ''' Hide or display the item and its track on the map :param enabled: what to do :type enabled: bool ''' self.enabled = enabled self.marker.setVisible(self.enabled) self.marker.resetPosition() if self.enabled: self.timer.start(self.timeoutTime) self.timeoutCount = 0 else: self.timer.stop() @pyqtSlot() def deleteTrack(self): ''' Delete the track all points ''' self.marker.deleteTrack() @pyqtSlot() def centerOnMap(self): ''' Center the item on the map ''' if self.coordinates is not None: self.canvas.setCenter(self.coordinates) self.canvas.refresh() def reportPosition(self): ''' Report the position of the item. Used for logging :returns: geographic postion, depth and altitude :rtype: float, float, float, float ''' if self.position is None: return -9999.9, -9999.9, -9999.9, 0.0 return self.position.y(), self.position.x(), self.depth, self.heading @pyqtSlot() def notifyTimeout(self): self.timeoutCount += 1 if self.timeoutCount == self.notifyCount: msg = self.tr(u'No fix for %s since more than %d seconds!') % (self.name, self.timeoutTime * self.timeoutCount / 1000) w = self.iface.messageBar().createMessage(self.tr(u'PosiView Attention'), msg) l = QLabel(w) m = QMovie(':/plugins/PosiView/hand.gif') m.setSpeed(75) l.setMovie(m) m.setParent(l) m.start() w.layout().addWidget(l) self.iface.messageBar().pushWidget(w, QgsMessageBar.CRITICAL, duration=self.notifyDuration)
def testQgsCircularstringRepr(self): cs = QgsCircularString(QgsPoint(1, 2), QgsPoint(2, 3), QgsPoint(3, 4)) self.assertEqual(cs.__repr__(), '<QgsCircularString: CircularString (1 2, 2 3, 3 4)>')
def testQgsCompoundcurveRepr(self): cs = QgsCircularString(QgsPoint(1, 2), QgsPoint(2, 3), QgsPoint(3, 4)) cc = QgsCompoundCurve() cc.addCurve(cs) self.assertEqual(cc.__repr__(), '<QgsCompoundCurve: CompoundCurve (CircularString (1 2, 2 3, 3 4))>')
def map(self, p): # move to origin (translation part 1) p = QgsPoint(p.x() - self.dx1, p.y() - self.dy1) # scale p = QgsPoint(self.ds * p.x(), self.ds * p.y()) # rotation p = QgsPoint( math.cos(self.da) * p.x() - math.sin(self.da) * p.y(), math.sin(self.da) * p.x() + math.cos(self.da) * p.y() ) # remove to right spot (translation part 2) p = QgsPoint(p.x() + self.dx2, p.y() + self.dy2) return p
def processAlgorithm(self, progress): extent = str(self.getParameterValue(self.EXTENT)).split(',') spacing = float(self.getParameterValue(self.SPACING)) inset = float(self.getParameterValue(self.INSET)) randomize = self.getParameterValue(self.RANDOMIZE) isSpacing = self.getParameterValue(self.IS_SPACING) extent = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) mapCRS = iface.mapCanvas().mapSettings().destinationCrs() writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, mapCRS) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 total = 100.0 / (area / pSpacing) y = extent.yMaximum() - inset extent_geom = QgsGeometry.fromRect(extent) extent_engine = QgsGeometry.createGeometryEngine( extent_geom.geometry()) extent_engine.prepareGeometry() while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if randomize: geom = QgsGeometry().fromPoint( QgsPoint( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)))) else: geom = QgsGeometry().fromPoint(QgsPoint(x, y)) if extent_engine.intersects(geom.geometry()): f.setAttribute('id', count) f.setGeometry(geom) writer.addFeature(f) x += pSpacing count += 1 progress.setPercentage(int(count * total)) y = y - pSpacing del writer
def testQgsCircleRepr(self): c = QgsCircle(QgsPoint(1, 1), 2.0) self.assertEqual(c.__repr__(), '<QgsCircle: Circle (Center: Point (1 1), Radius: 2, Azimuth: 0)>')
def processAlgorithm(self, context, feedback): layer = QgsProcessingUtils.mapLayerFromString( self.getParameterValue(self.INPUT_VECTOR), context) startPoint = self.getParameterValue(self.START_POINT) endPoint = self.getParameterValue(self.END_POINT) strategy = self.getParameterValue(self.STRATEGY) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) fields = QgsFields() fields.append(QgsField('start', QVariant.String, '', 254, 0)) fields.append(QgsField('end', QVariant.String, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 20, 7)) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( fields, QgsWkbTypes.LineString, layer.crs(), context) tmp = startPoint.split(',') startPoint = QgsPoint(float(tmp[0]), float(tmp[1])) tmp = endPoint.split(',') endPoint = QgsPoint(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor( distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) multiplier = 3600 director.addStrategy(strategy) builder = QgsGraphBuilder( iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance) feedback.pushInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, [startPoint, endPoint]) feedback.pushInfo(self.tr('Calculating shortest path...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) idxEnd = graph.findVertex(snappedPoints[1]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) if tree[idxEnd] == -1: raise GeoAlgorithmExecutionException( self.tr('There is no route from start point to end point.')) route = [] cost = 0.0 current = idxEnd while current != idxStart: cost += graph.edge(tree[current]).cost(0) route.append( graph.vertex(graph.edge(tree[current]).inVertex()).point()) current = graph.edge(tree[current]).outVertex() route.append(snappedPoints[0]) route.reverse() self.setOutputValue(self.TRAVEL_COST, cost / multiplier) feedback.pushInfo(self.tr('Writing results...')) geom = QgsGeometry.fromPolyline(route) feat = QgsFeature() feat.setFields(fields) feat['start'] = startPoint.toString() feat['end'] = endPoint.toString() feat['cost'] = cost / multiplier feat.setGeometry(geom) writer.addFeature(feat) del writer
def testExportFeatures(self): """ Test exporting feature collections """ fields = QgsFields() fields.append(QgsField("name", QVariant.String)) fields.append(QgsField("cost", QVariant.Double)) fields.append(QgsField("population", QVariant.Int)) feature = QgsFeature(fields, 5) feature.setGeometry(QgsGeometry(QgsPoint(5, 6))) feature.setAttributes(['Valsier Peninsula', 6.8, 198]) exporter = QgsJsonExporter() # single feature expected = """{ "type": "FeatureCollection", "features":[ { "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198 } } ]}""" self.assertEqual(exporter.exportFeatures([feature]), expected) # multiple features feature2 = QgsFeature(fields, 6) feature2.setGeometry(QgsGeometry(QgsPoint(7, 8))) feature2.setAttributes(['Henry Gale Island', 9.7, 38]) expected = """{ "type": "FeatureCollection", "features":[ { "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198 } }, { "type":"Feature", "id":6, "geometry": {"type": "Point", "coordinates": [7, 8]}, "properties":{ "name":"Henry Gale Island", "cost":9.7, "population":38 } } ]}""" self.assertEqual(exporter.exportFeatures([feature, feature2]), expected)
def testJSONExporter(self): """ test converting features to GeoJSON """ fields = QgsFields() fields.append(QgsField("name", QVariant.String)) fields.append(QgsField("cost", QVariant.Double)) fields.append(QgsField("population", QVariant.Int)) feature = QgsFeature(fields, 5) feature.setGeometry(QgsGeometry(QgsPoint(5, 6))) feature.setAttributes(['Valsier Peninsula', 6.8, 198]) exporter = QgsJsonExporter() expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198 } }""" self.assertEqual(exporter.exportFeature(feature), expected) # test with linestring for bbox inclusion l = QgsLineString() l.setPoints([QgsPoint(5, 6), QgsPoint(15, 16)]) feature.setGeometry(QgsGeometry(QgsLineString(l))) expected = """{ "type":"Feature", "id":5, "bbox":[5, 6, 15, 16], "geometry": {"type": "LineString", "coordinates": [ [5, 6], [15, 16]]}, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198 } }""" self.assertEqual(exporter.exportFeature(feature), expected) # test that precision is respected feature.setGeometry(QgsGeometry(QgsPoint(5.444444444, 6.333333333))) exporter.setPrecision(3) self.assertEqual(exporter.precision(), 3) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5.444, 6.333]}, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198 } }""" self.assertEqual(exporter.exportFeature(feature), expected) feature.setGeometry(QgsGeometry(QgsPoint(5, 6))) exporter.setPrecision(17) # test that attribute subset is respected exporter.setAttributes([0, 2]) self.assertEqual(exporter.attributes(), [0, 2]) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "name":"Valsier Peninsula", "population":198 } }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setAttributes([1]) self.assertEqual(exporter.attributes(), [1]) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "cost":6.8 } }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setAttributes([]) # text excluding attributes exporter.setExcludedAttributes([1]) self.assertEqual(exporter.excludedAttributes(), [1]) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "name":"Valsier Peninsula", "population":198 } }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setExcludedAttributes([1, 2]) self.assertEqual(exporter.excludedAttributes(), [1, 2]) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "name":"Valsier Peninsula" } }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setExcludedAttributes([0, 1, 2]) self.assertEqual(exporter.excludedAttributes(), [0, 1, 2]) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":null }""" self.assertEqual(exporter.exportFeature(feature), expected) # test that excluded attributes take precedence over included exporter.setAttributes([1, 2]) exporter.setExcludedAttributes([0, 1]) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":{ "population":198 } }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setAttributes([]) exporter.setExcludedAttributes([]) # test excluding geometry exporter.setIncludeGeometry(False) self.assertEqual(exporter.includeGeometry(), False) feature.setGeometry(QgsGeometry(QgsLineString(l))) expected = """{ "type":"Feature", "id":5, "geometry":null, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198 } }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setIncludeGeometry(True) feature.setGeometry(QgsGeometry(QgsPoint(5, 6))) # test excluding attributes exporter.setIncludeAttributes(False) self.assertEqual(exporter.includeAttributes(), False) expected = """{ "type":"Feature", "id":5, "geometry": {"type": "Point", "coordinates": [5, 6]}, "properties":null }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setIncludeGeometry(False) expected = """{ "type":"Feature", "id":5, "geometry":null, "properties":null }""" self.assertEqual(exporter.exportFeature(feature), expected) exporter.setIncludeAttributes(True) # test overriding ID expected = """{ "type":"Feature", "id":29, "geometry":null, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198 } }""" self.assertEqual(exporter.exportFeature(feature, id=29), expected) # test injecting extra attributes expected = """{ "type":"Feature", "id":5, "geometry":null, "properties":{ "name":"Valsier Peninsula", "cost":6.8, "population":198, "extra":"val1", "extra2":2 } }""" self.assertEqual(exporter.exportFeature(feature, extraProperties={"extra": "val1", "extra2": 2}), expected) exporter.setIncludeAttributes(False) expected = """{ "type":"Feature", "id":5, "geometry":null, "properties":{ "extra":"val1", "extra2":{"nested_map":5, "nested_map2":"val"}, "extra3":[1,2,3] } }""" expected2 = """{ "type":"Feature", "id":5, "geometry":null, "properties":{ "extra":"val1", "extra2":{"nested_map":5,"nested_map2":"val"}, "extra3":[1,2,3] } }""" exp_f = exporter.exportFeature(feature, extraProperties={"extra": "val1", "extra2": {"nested_map": 5, "nested_map2": "val"}, "extra3": [1, 2, 3]}) self.assertTrue(exp_f == expected or exp_f == expected2) exporter.setIncludeGeometry(True)
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) fields = source.fields() x_field_index = fields.lookupField( self.parameterAsString(parameters, self.XFIELD, context)) y_field_index = fields.lookupField( self.parameterAsString(parameters, self.YFIELD, context)) z_field_index = -1 if self.parameterAsString(parameters, self.ZFIELD, context): z_field_index = fields.lookupField( self.parameterAsString(parameters, self.ZFIELD, context)) m_field_index = -1 if self.parameterAsString(parameters, self.MFIELD, context): m_field_index = fields.lookupField( self.parameterAsString(parameters, self.MFIELD, context)) wkb_type = QgsWkbTypes.Point if z_field_index >= 0: wkb_type = QgsWkbTypes.addZ(wkb_type) if m_field_index >= 0: wkb_type = QgsWkbTypes.addM(wkb_type) target_crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, wkb_type, target_crs) request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry) features = source.getFeatures() total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, feature in enumerate(features): if feedback.isCanceled(): break feedback.setProgress(int(current * total)) attrs = feature.attributes() try: x = float(attrs[x_field_index]) y = float(attrs[y_field_index]) point = QgsPoint(x, y) if z_field_index >= 0: try: point.addZValue(float(attrs[z_field_index])) except: point.addZValue(0.0) if m_field_index >= 0: try: point.addMValue(float(attrs[m_field_index])) except: point.addMValue(0.0) feature.setGeometry(QgsGeometry(point)) except: pass # no geometry sink.addFeature(feature) return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback): uavImage = self.parameterAsRasterLayer(parameters, self.INPUT, context) feedback.pushInfo(self.tr('Processing image source: ')+self.tr(uavImage.source())) sourceCRS = self.parameterAsCrs(parameters, self.SOURCE_CRS, context) if sourceCRS is None or not sourceCRS.isValid(): sourceCRS = uavImage.crs() destinationCRS = self.parameterAsCrs(parameters, self.DESTINATION_CRS, context) if destinationCRS is None or not destinationCRS.isValid(): feedback.pushInfo(self.tr('Getting destination CRS from source image')) destinationCRS = sourceCRS feedback.pushInfo(self.tr('Source CRS is: ')+self.tr(sourceCRS.authid())) feedback.pushInfo(self.tr('Destination CRS is: ')+self.tr(destinationCRS.authid())) # set fields for footprint and nadir vectors fields = QgsFields() # fields.append(QgsField('gimball_pitch', QVariant.Double)) # fields.append(QgsField('gimball_roll', QVariant.Double)) # fields.append(QgsField('gimball_jaw', QVariant.Double)) # fields.append(QgsField('relative_altitude', QVariant.Double)) # fields.append(QgsField('image', QVariant.String)) # fields.append(QgsField('camera_model', QVariant.String)) # fields.append(QgsField('camera_vertical_FOV', QVariant.Double)) # fields.append(QgsField('camera_horizontal_FOV', QVariant.Double)) # (footprintSink, footprint_dest_id) = self.parameterAsSink( # parameters, # self.OUTPUT_FOOTPRINT, # context, # fields, # QgsWkbTypes.Polygon, # destinationCRS) # if footprintSink is None: # raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT_FOOTPRINT)) (nadirSink, nadir_dest_id) = self.parameterAsSink( parameters, self.OUTPUT_NADIR, context, fields, QgsWkbTypes.Point, destinationCRS) if nadirSink is None: raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT_NADIR)) horizontalFOV = self.parameterAsDouble(parameters, self.HORIZONTAL_FOV, context) verticalFOV = self.parameterAsDouble(parameters, self.VERTICAL_FOV, context) useImageRatio = self.parameterAsBoolean(parameters, self.USE_IMAGE_RATIO_FOR_VERTICAL_FOV, context) verticalFOV_multiplier = self.parameterAsDouble(parameters, self.VERTICAL_FOV_MULTIPLIER, context) nadirToBottomOffset = self.parameterAsDouble(parameters, self.NADIR_TO_BOTTOM_OFFSET, context) nadirToupperOffset = self.parameterAsDouble(parameters, self.NADIR_TO_UPPPER_OFFSET, context) # extract exif and XMP data try: gdal.UseExceptions() dataFrame = gdal.Open(uavImage.source(), gdal.GA_ReadOnly) domains = dataFrame.GetMetadataDomainList() # get exif metadata exifTags = dataFrame.GetMetadata() for key, value in exifTags.items(): #print(key, ':', value) pass # select metadata from XMP domain only droneMetadata = {} for domain in domains: metadata = dataFrame.GetMetadata(domain) # skip not relevant tags if isinstance(metadata, dict): for key, value in metadata.items(): #print(domain, "--", key, ":", value) pass # probably XMPs if isinstance(metadata, list): if domain == 'xml:XMP': # parse xml root = ElementTree.XML(metadata[0]) xmldict = XmlDictConfig(root) # skip first element containing only description and domain info subdict = list(xmldict.values())[0] # get XMP tags subdict = list(subdict.values())[0] # parse XMP stuffs removing head namespace in the key # e.g. # {http://www.dji.com/drone-dji/1.0/}AbsoluteAltitude # become # AbsoluteAltitude for key, value in subdict.items(): #print(domain, '--', key, value) key = key.split('}')[1] droneMetadata[key] = value except Exception as ex: raise QgsProcessingException(str(ex)) # extract all important tagged information about the image # get image lat/lon that will be the coordinates of nadir point # converted to destination CRS lat = _convert_to_degress(exifTags['EXIF_GPSLatitude']) emisphere = exifTags['EXIF_GPSLatitudeRef'] lon = _convert_to_degress(exifTags['EXIF_GPSLongitude']) lonReference = exifTags['EXIF_GPSLongitudeRef'] if emisphere == 'S': lat = -lat if lonReference == 'W': lon = -lon exifDateTime = exifTags['EXIF_DateTime'] feedback.pushInfo("EXIF_DateTime: "+exifDateTime) exifImageWidth = exifTags['EXIF_PixelXDimension'] exifImageLength = exifTags['EXIF_PixelYDimension'] imageRatio = float(exifImageWidth)/float(exifImageLength) feedback.pushInfo("EXIF_PixelXDimension: "+exifImageWidth) feedback.pushInfo("EXIF_PixelYDimension: "+exifImageLength) feedback.pushInfo("Image ratio: "+str(imageRatio)) # drone especific metadata droneMaker = exifTags['EXIF_Make'] droneModel = exifTags['EXIF_Model'] feedback.pushInfo("EXIF_Make: "+droneMaker) feedback.pushInfo("EXIF_Model: "+droneModel) # drone maker substitute XMP drone dictKey dictKey = droneMaker relativeAltitude = float(droneMetadata['RelativeAltitude']) feedback.pushInfo(self.tr("XMP {}:RelativeAltitude: ".format(dictKey))+str(relativeAltitude)) gimballRoll = float(droneMetadata['GimbalRollDegree']) gimballPitch = float(droneMetadata['GimbalPitchDegree']) gimballYaw = float(droneMetadata['GimbalYawDegree']) feedback.pushInfo("XMP {}:GimbalRollDegree: ".format(dictKey)+str(gimballRoll)) feedback.pushInfo("XMP {}:GimbalPitchDegree: ".format(dictKey)+str(gimballPitch)) feedback.pushInfo("XMP {}:GimbalYawDegree: ".format(dictKey)+str(gimballYaw)) flightRoll = float(droneMetadata['FlightRollDegree']) flightPitch = float(droneMetadata['FlightPitchDegree']) flightYaw = float(droneMetadata['FlightYawDegree']) feedback.pushInfo("XMP {}:FlightRollDegree: ".format(dictKey)+str(flightRoll)) feedback.pushInfo("XMP {}:FlightPitchDegree: ".format(dictKey)+str(flightPitch)) feedback.pushInfo("XMP {}:FlightYawDegree: ".format(dictKey)+str(flightYaw)) feedback.pushInfo(self.tr("Horizontal FOV: ")+str(horizontalFOV)) if useImageRatio: verticalFOV = (horizontalFOV/imageRatio)*verticalFOV_multiplier feedback.pushInfo(self.tr("Vertical FOV basing on image ratio: ")+str(verticalFOV)) else: feedback.pushInfo(self.tr("Vertical FOV: ")+str(verticalFOV)) # do calculation inspired by: # https://photo.stackexchange.com/questions/56596/how-do-i-calculate-the-ground-footprint-of-an-aerial-camera # distance of the nearest point to nadir (bottom distance) bottomDistance = relativeAltitude*(math.tan(math.radians(90 - gimballPitch - 0.5*verticalFOV))) # distance of the farest point to nadir (upper distance) upperDistance = relativeAltitude*(math.tan(math.radians(90 - gimballPitch + 0.5*verticalFOV))) feedback.pushInfo(self.tr("Northing (degree): ")+str(gimballYaw)) feedback.pushInfo(self.tr("Nadir to bottom distance (metre): ")+str(bottomDistance)) feedback.pushInfo(self.tr("Nadir to upper distance (metre): ")+str(upperDistance)) # populate nadir layer droneLocation = QgsPoint(lon, lat) tr = QgsCoordinateTransform(sourceCRS, destinationCRS, QgsProject.instance()) droneLocation.transform(tr) feedback.pushInfo(self.tr("Nadir coordinates (lon, lat): ")+'{}, {}'.format(droneLocation.x(), droneLocation.y())) nadirGeometry = QgsGeometry.fromPointXY(QgsPointXY(droneLocation.x(), droneLocation.y())) feature = QgsFeature() feature.setGeometry(nadirGeometry) nadirSink.addFeature(feature, QgsFeatureSink.FastInsert) # create a memory layer with nadir point to be input to "native:wedgebuffers" algorithm # it's not possible to use directly the FeatureSink becaseu can't be accepted by processing.run. # the reason is that a generic sink can be also NOT a layer but a more generic sink where features # can't be recovered. tempNadirLayer = QgsVectorLayer('Point?crs={}'.format(destinationCRS.authid()), 'tempNadirLayer', 'memory' ) provider = tempNadirLayer.dataProvider() feature = QgsFeature() feature.setGeometry(nadirGeometry) provider.addFeatures([feature]) # create polygon using wedge buffer processign algorithm parameters = { 'INPUT': tempNadirLayer, 'AZIMUTH': gimballYaw, 'WIDTH': horizontalFOV, 'OUTER_RADIUS': abs(bottomDistance) + nadirToBottomOffset, 'INNER_RADIUS': abs(upperDistance) + nadirToupperOffset, 'OUTPUT': parameters[self.OUTPUT_FOOTPRINT] } wedge_buffer_result = processing.run("native:wedgebuffers", parameters, is_child_algorithm=True, context = context, feedback = feedback) # Return the results results = { self.OUTPUT_FOOTPRINT: wedge_buffer_result['OUTPUT'], self.OUTPUT_NADIR: nadir_dest_id, } return results
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT_VECTOR, context) raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT_RASTER, context) rasterPath = raster_layer.source() rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly) geoTransform = rasterDS.GetGeoTransform() fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) fields.append(QgsField('poly_id', QVariant.Int, '', 10, 0)) fields.append(QgsField('point_id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, raster_layer.crs()) outFeature = QgsFeature() outFeature.setFields(fields) fid = 0 polyId = 0 pointId = 0 features = source.getFeatures(QgsFeatureRequest().setDestinationCrs( raster_layer.crs())) total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, f in enumerate(features): if feedback.isCanceled(): break if not f.hasGeometry(): continue geom = f.geometry() bbox = geom.boundingBox() xMin = bbox.xMinimum() xMax = bbox.xMaximum() yMin = bbox.yMinimum() yMax = bbox.yMaximum() (startRow, startColumn) = raster.mapToPixel(xMin, yMax, geoTransform) (endRow, endColumn) = raster.mapToPixel(xMax, yMin, geoTransform) # use prepared geometries for faster intersection tests engine = QgsGeometry.createGeometryEngine(geom.constGet()) engine.prepareGeometry() for row in range(startRow, endRow + 1): for col in range(startColumn, endColumn + 1): if feedback.isCanceled(): break (x, y) = raster.pixelToMap(row, col, geoTransform) point = QgsPoint(x, y) if engine.contains(point): outFeature.setGeometry(QgsGeometry(point)) outFeature['id'] = fid outFeature['poly_id'] = polyId outFeature['point_id'] = pointId fid += 1 pointId += 1 sink.addFeature(outFeature, QgsFeatureSink.FastInsert) pointId = 0 polyId += 1 feedback.setProgress(int(current * total)) return {self.OUTPUT: dest_id}
def testQgsPointRepr(self): p = QgsPoint(123.456, 987.654, 100) self.assertTrue(p.__repr__().startswith('<QgsPoint: PointZ (123.456'))
def run(self): """Run method that performs all the real work""" # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() GTFSDir = self.dlg.GTFSLocation.text() StopsFile = self.dlg.StopsFile.text() stopID = self.dlg.stopID.text() ###StopsShapefileName = self.dlg.StopsShapefileName.text() StopsShapefileName = "stops" AddToMapCanvas = False ##GenerateTransitServiceData = True SkipCalculationServiceData = False TrailheadData_shp = self.dlg.TrailheadData.text() BufferDistance = self.dlg.BufferDistance.text() th_id_field = self.dlg.th_id_field.text() th_name_field = self.dlg.th_name_field.text() outputGeoJSON = self.dlg.outputGeoJSON.text() PostGISExpr = self.dlg.tbPostGISExpr.text() AddToMapCanvas = self.dlg.cbAddToMapCanvas.isChecked() # returns True if checked SkipCalculationServiceData = self.dlg.SkipCalculationServiceData.isChecked() # returns True if checked ###trailBufferShpName = self.dlg.trailBufferShpName.text() #in_format = [] #in_format.append("Shapefile") #in_format.append("PostGIS") #self.dlg.comboBox.addItems(in_format) trailBufferShpName = "trailBuff" working_dir_name = self.dlg.working_dir.text() # ##shapefile_th = self.dlg.checkBoxShapefile.isChecked() # returns True if checked ##postGIS_th = self.dlg.checkBoxPostGIS.isChecked() # shapefile_th = self.dlg.radioButtonShapefile.isChecked() # returns True if checked postGIS_th = self.dlg.radioButtonPostGIS.isChecked() # host_name = self.dlg.host_name.text() port = self.dlg.port.text() database_name = self.dlg.database_name.text() uname = self.dlg.uname.text() password = self.dlg.password.text() postGIS_table_name = self.dlg.postGIS_table_name.text() # InputDataSpecified = False if shapefile_th: InputDataSpecified = True if postGIS_th: InputDataSpecified = True #postGIS_th = True #shapefile_th = True working_dir = os.path.join(GTFSDir, working_dir_name) #if working_dir doesn't exist, create it if not os.path.exists(working_dir): os.makedirs(working_dir) TATShp = os.path.join(working_dir, "TAToutput.shp") TATdShp = os.path.join(working_dir, "TATdoutput.shp") THShp = os.path.join(working_dir, "TH.shp") # DList_TrailsStops = defaultdict(list) # #####output_shp = ##output_file = open(filename, 'w') # See if OK was pressed if result: if InputDataSpecified: start_time = datetime.datetime.now().replace(microsecond=0) stop_id = "UNK" stop_name = "UNK" stop_lat = "UNK" stop_lon = "UNK" c_stop_id = 0 c_stop_name = 0 c_stop_lat = 0 c_stop_lon = 0 counter = 0 text_file = os.path.join(GTFSDir, StopsFile) #text_file = 'C:/UWGIS/Geog569/Data/Test/stops.txt' ## EPSG_code = 4326 EPSG_code_WM = 3857 crsSrc = QgsCoordinateReferenceSystem(4326) # WGS 84 crsDest = QgsCoordinateReferenceSystem(3857) # WGS 84 / Web Mercator xform = QgsCoordinateTransform(crsSrc, crsDest) rev_xform = QgsCoordinateTransform(crsDest, crsSrc) ## #StopsShapefilePath = os.path.join(GTFSDir, StopsShapefileName + ".shp") #StopsShapefileBufferPath = os.path.join(GTFSDir, StopsShapefileName + "BUFF.shp") #StopsShapefilePathWM = os.path.join(GTFSDir, StopsShapefileName + "WM.shp") StopsShapefilePath = os.path.join(working_dir, StopsShapefileName + ".shp") StopsShapefileBufferPath = os.path.join(working_dir, StopsShapefileName + "BUFF.shp") StopsShapefilePathWM = os.path.join(working_dir, StopsShapefileName + "WM.shp") ## spatialReference = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be spatialReference.ImportFromEPSG(int(EPSG_code)) #here we define this reference to be the EPSG code driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation. ## index = 0 spatialReferenceWM = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be spatialReferenceWM.ImportFromEPSG(int(EPSG_code_WM)) #here we define this reference to be the EPSG code driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation. # create layer #if shapefile_th_rb: # print "USING Shapefiles!" #if postGIS_th_rb: # print "USING PostGIS!" ##vl = QgsVectorLayer("Point", "stop_points", "memory") vl = QgsVectorLayer("Point?crs=EPSG:3857", "stop_points", "memory") ##vl.spatialReference pr = vl.dataProvider() # # changes are only possible when editing the layer vl.startEditing() # add fields pr.addAttributes([QgsField("stop_id", QVariant.String),QgsField("stop_name", QVariant.Int),QgsField("stop_lat", QVariant.Double),QgsField("stop_lon", QVariant.Double)]) index = 0 ###print "two" fieldnames = [] stop_lat = 0 stop_lon = 0 c_stop_id = 0 c_stop_name = 0 c_stop_lat = 0 c_stop_lon = 0 with open(text_file, 'r') as f: first_line = f.readline() fl = first_line.split(",") counter = 0 for f in fl: fieldnames.append(f) #for f in fl: #print f if f == "stop_id": c_stop_id = counter if f == "stop_name": c_stop_name = counter if f == "stop_lat": c_stop_lat = counter #print "stop_lat is in column ", c_stop_lat #print c_stop_lat if f == "stop_lon": c_stop_lon = counter #print "stop_lon is in column ", c_stop_lon ##print c_stop_lon ##print "three" counter = counter + 1 # with open(text_file, 'r') as f: lines = f.readlines() for line in lines: h = '"' if h in line: count = line.count(h) print "Removed quote from line" + str(count) while count > 0: #print [pos for pos, char in enumerate(line) if char == c] cc = [pos for pos, char in enumerate(line) if char == h] d = ',' #print [pos for pos, char in enumerate(line) if char == d] dd = [pos for pos, char in enumerate(line) if char == d] startP = cc[0] endP = cc[1] for ddd in dd: if (ddd > startP) and (ddd < endP): extraCommaPos = ddd line1 = line[0:startP] line2 = line[(startP + 1):extraCommaPos] line3 = line[(extraCommaPos + 1):(endP)] line4 = line[(endP + 1):-1] lineMod = line1 + line2 + line3 + line4 #print line #print "Comma removed" #print lineMod line = lineMod count = line.count(h) l = str(line).split(",") if l[c_stop_id] != "stop_id": stop_id = l[c_stop_id] if l[c_stop_name] != "stop_name": stop_name = l[c_stop_name] if l[c_stop_lat] != "stop_lat": stop_lat = float(l[c_stop_lat]) if l[c_stop_lon] != "stop_lon": stop_lon = float(l[c_stop_lon]) if type(stop_lat) == float: if type (stop_lon) == float: fet = QgsFeature() stop_pt_WM = xform.transform(QgsPoint(stop_lon,stop_lat)) ###print "Transformed point:", stop_pt_WM #fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(stop_lon, stop_lat))) fet.setGeometry(QgsGeometry.fromPoint(stop_pt_WM)) fet.setAttributes([stop_id, stop_name, stop_lat, stop_lon]) pr.addFeatures([fet]) vl.commitChanges() # # add layer to the legend stops_extent = vl.extent() xmin = stops_extent.xMinimum() ymin = stops_extent.yMinimum() xmax = stops_extent.xMaximum() ymax = stops_extent.yMaximum() ##QgsMapLayerRegistry.instance().addMapLayer(vl) # # Add trailheads from postGIS if postGIS_th = True # if postGIS_th: uri = QgsDataSourceURI() # set host name, port, database name, username and password #uri.setConnection("localhost", "5432", "dbname", "johny", "xxx") uri.setConnection(host_name, port, database_name, uname, password) print "made PostGIS connection successfully" # set database schema, table name, geometry column and optionally # subset (WHERE clause) #uri.setDataSource("public", "roads", "the_geom", "cityid = 2643") #uri.setDataSource("public", postGIS_table_name, "geom", PostGISExpr) uri.setDataSource("public", postGIS_table_name, "geom", PostGISExpr) # #vlayer = QgsVectorLayer(uri.uri(), "layer name you like", "postgres") DB_TH_layer = QgsVectorLayer(uri.uri(), "DB_TH_layer", "postgres") if AddToMapCanvas: QgsMapLayerRegistry.instance().addMapLayer(DB_TH_layer) # stop_extent = QgsVectorLayer("Polygon?crs=EPSG:4326", "stop_extent", "memory") pr = stop_extent.dataProvider() stop_extent.startEditing() # fet = QgsFeature() #fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(stop_lon, stop_lat))) # stop_ex_SW = rev_xform.transform(QgsPoint(xmin, ymin)) stop_ex_NW = rev_xform.transform(QgsPoint(xmin, ymax)) stop_ex_NE = rev_xform.transform(QgsPoint(xmax, ymax)) stop_ex_SE = rev_xform.transform(QgsPoint(xmax, ymin)) print "Stops layer extent (lower):", stop_ex_SW print "Stops layer extent (upper):", stop_ex_NE ##fet.setGeometry(QgsGeometry.fromPolygon([[QgsPoint(xmin,ymin),QgsPoint(xmin,ymax), QgsPoint(xmax,ymax), QgsPoint(xmax,ymin), QgsPoint(xmin,ymin)]])) fet.setGeometry(QgsGeometry.fromPolygon([[stop_ex_SW, stop_ex_NW, stop_ex_NE, stop_ex_SE, stop_ex_SW]])) pr.addFeatures([fet]) stop_extent.commitChanges() if AddToMapCanvas: QgsMapLayerRegistry.instance().addMapLayer(stop_extent) # print "overlay points! - using extent from stops" overlayAnalyzer = QgsOverlayAnalyzer() overlayAnalyzer.intersection(DB_TH_layer, stop_extent, THShp) TH_layer = QgsVectorLayer(THShp, "TH_layer", "ogr") if not TH_layer.isValid(): print "TH.shp layer failed to load!" ########## this adds trailheads to the map canvas ########QgsMapLayerRegistry.instance().addMapLayer(TH_layer) iter = TH_layer.getFeatures() #for feature in iter: # geomIn = feature.geometry() # #print geom.vectorType() # featgeom = geomIn.exportToWkt() # print featgeom # geom = QgsGeometry.fromWkt(featgeom) # #print geom2 #= QgsGeometry.fromWkt(featgeom) # #if geom.isMultipart: # # print "multi" # feature_name = feature['name'] # feature_id = feature['FEAT_ID'] # print "geom.asPoint()" # print geom.asPoint() # # add trailhead layer from shapefile if selected (assumes it is stored in WGS 84) # if shapefile_th: trailhead_layer = QgsVectorLayer(TrailheadData_shp, "trailhead_layer", "ogr") ######### this adds trailsheads to map canvas############QgsMapLayerRegistry.instance().addMapLayer(trailhead_layer) if not trailhead_layer.isValid(): print "trailhead layer failed to load!" # # create trailhead layer in Web Mercator # vltWM = QgsVectorLayer("Point?crs=EPSG:3857", "trailhead_points_WM", "memory") prtWM = vltWM.dataProvider() # # changes - including adding fields - are only possible when editing the layer vltWM.startEditing() prtWM.addAttributes([QgsField("name", QVariant.String),QgsField("FEAT_ID", QVariant.Int)]) # # Get the features from the trailhead layer that is loaded, from shp or db # and convert to a WM dataset # if shapefile_th: iter = trailhead_layer.getFeatures() print "using shape" for feature in iter: geom = feature.geometry() feature_name = feature['name'] feature_id = feature['FEAT_ID'] th_x = geom.asPoint().x() th_y = geom.asPoint().y() print th_x, th_y trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint())) fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM)) fet.setAttributes([feature_name, feature_id]) prtWM.addFeatures([fet]) vltWM.commitChanges() if postGIS_th: trailhead_layer = QgsVectorLayer(THShp, "trailhead_layer", "ogr") iter = trailhead_layer.getFeatures() print "using postGIS" for feature in iter: geomIn = feature.geometry() featgeom = geomIn.exportToWkt() #featgeom = featgeom.replace("MultiPoint", "POINT") #featgeom = featgeom.replace("((", "(") #featgeom = featgeom.replace("))", ")") #featgeom = '"' + str(featgeom) + '"' geoString1 = featgeom.split('((') geoString2 = geoString1[1].split('))') #geoString22 = geoString2[0] geoString = geoString2[0].split(' ') ptX = float(geoString[0]) ptY = float(geoString[1]) #ptX = geoString[0] #ptY = geoString[1] #geomString = '"POINT (' + str(ptX) + " " + str(ptY) + ')"' geomString = '"POINT (' + str(ptX) + " " + str(ptY) + ')"' #print geomString #geom = QgsGeometry.fromWkt(geomString) geom = QgsGeometry.fromPoint(QgsPoint(ptX, ptY)) #geom = QgsGeometry.fromWkt("POINT (-122.24501049999997804 47.86390650000004143)") ###geom = feature.geometry() ###feature_name = feature['name'] ###feature_id = feature['FEAT_ID'] feature_name = feature[th_name_field] feature_id = feature[th_id_field] trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint())) fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM)) fet.setAttributes([feature_name, feature_id]) prtWM.addFeatures([fet]) vltWM.commitChanges() ###fet = QgsFeature() #####feature.asPoint() ####print feature ###fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM)) ###fet.setAttributes([feature_name, feature_id]) ###prtWM.addFeatures([fet]) ###vltWM.commitChanges() ###fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM)) ###fet.setGeometry(geom) ###fet.setAttributes([feature_name, feature_id]) ####print "geom" ####print geom ###trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint())) ###prtWM.addFeatures([fet]) ###vltWM.commitChanges() # # Add WM trailheads to the map canvas # #print "PostGISExpr" #print PostGISExpr #if PostGISExpr == "": # print "NO EXPR!" if AddToMapCanvas: QgsMapLayerRegistry.instance().addMapLayer(vltWM) #QgsMapLayerRegistry.instance().addMapLayer(vltWM) # Buffer stops vltb = QgsVectorLayer("Point?crs=EPSG:3857", "trailhead_buffer_dissolved", "memory") # #QgsGeometryAnalyzer().dissolve(vlt, vltb, onlySelectedFeatures=False, uniqueIdField=-1, p=None) # Buffer stops geometryanalyzer = QgsGeometryAnalyzer() geometryanalyzer.buffer(vltWM, StopsShapefileBufferPath + ".shp", int(BufferDistance), False, False, -1) trailheadBuffer_layer = QgsVectorLayer(StopsShapefileBufferPath + ".shp", "trailhead_buffer_layer", "ogr") if AddToMapCanvas: QgsMapLayerRegistry.instance().addMapLayer(trailheadBuffer_layer) # geometryanalyzer.buffer(vltWM, StopsShapefileBufferPath + "d.shp", int(BufferDistance), False, True, -1) #trailheadBufferd_layer = QgsVectorLayer(StopsShapefileBufferPath + "d.shp", "trailhead_buffer_d", "ogr") trailheadBufferd_layer = QgsVectorLayer(StopsShapefileBufferPath + "d.shp", "trailhead_buffer_d", "ogr") if AddToMapCanvas: QgsMapLayerRegistry.instance().addMapLayer(trailheadBufferd_layer) # # overlay - using dissolved buffer # print "overlay points! - using dissolved buffers" overlayAnalyzer = QgsOverlayAnalyzer() #overlayAnalyzer.intersection(vl, vlt, "C:/UWGIS/Geog569/Data/Test/TAToutput.shp") overlayAnalyzer.intersection(vl, trailheadBufferd_layer, TATdShp) TATd_layer = QgsVectorLayer(TATdShp, "TransitStops_diss_layer", "ogr") ###TATd_layer = QgsVectorLayer(TATdShp, "TrAccTrailheads_diss_layer", "ogr") if not TATd_layer.isValid(): print "TATd layer failed to load!" if AddToMapCanvas: QgsMapLayerRegistry.instance().addMapLayer(TATd_layer) iter = TATd_layer.getFeatures() stopList = [] for feature in iter: # retrieve every feature with its geometry and attributes feature_id = feature[stopID] stopList.append(feature_id) #feature_id = feature['FEAT_ID'] #for s in stopList: # print s # # overlay - using the indivdual buffered points # this can be used to compute distance between trailhaeds and each stop in its buffer # print "overlay points! - using dissolved buffers" overlayAnalyzer = QgsOverlayAnalyzer() #overlayAnalyzer.intersection(vl, vlt, "C:/UWGIS/Geog569/Data/Test/TAToutput.shp") overlayAnalyzer.intersection(vl, trailheadBuffer_layer, TATShp) TAT_layer = QgsVectorLayer(TATShp, "TransitStops_NonDissolved_layer", "ogr") #TAT_layer = QgsVectorLayer(TATShp, "TrAccTrailheads_layer", "ogr") if not TAT_layer.isValid(): print "TAT layer failed to load!" if AddToMapCanvas: QgsMapLayerRegistry.instance().addMapLayer(TAT_layer) iter = TAT_layer.getFeatures() THstopList = [] for feature in iter: # retrieve every feature with its geometry and attributes ###trailhead_name = feature['name'] trailhead_id = feature[th_id_field] feature_id = feature[th_id_field] TH_Stop = str(trailhead_id) + ":" + str(feature_id) #print feature['stop_id'] THstopList.append(TH_Stop) DList_TrailsStops[trailhead_id].append(feature_id) #feature_id = feature['FEAT_ID'] #for s in THstopList: # print s #for s in DList_TrailsStops: # print s, DList_TrailsStops[s] # #print DList_TrailsStops[s] print xmin, ymin, xmax, ymax fet = QgsFeature() stop_pt_WM = rev_xform.transform(QgsPoint(xmin, ymin)) print "Stops layer extent (lower):", stop_pt_WM #fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(stop_lon, stop_lat))) stop_pt_WM = rev_xform.transform(QgsPoint(xmax, ymax)) print "Stops layer extent (upper):", stop_pt_WM print self.plugin_dir sys.argv = [GTFSDir, stopList] missing_files = [] all_files_present = True fn_stop_times = "stop_times.txt" f_stop_times = os.path.join(GTFSDir, fn_stop_times) if not os.path.exists(f_stop_times): all_files_present = False missing_files.append(fn_stop_times) fn_stops = "stops.txt" f_stops = os.path.join(GTFSDir, fn_stops) if not os.path.exists(f_stops): all_files_present = False missing_files.append(fn_stops) fn_trips = "trips.txt" f_trips = os.path.join(GTFSDir, fn_trips) if not os.path.exists(f_trips): all_files_present = False missing_files.append(fn_trips) fn_routes = "routes.txt" f_routes = os.path.join(GTFSDir, fn_routes) if not os.path.exists(f_routes): all_files_present = False missing_files.append(fn_routes) fn_agency = "agency.txt" f_agency = os.path.join(GTFSDir, fn_agency) if not os.path.exists(f_agency): all_files_present = False missing_files.append(fn_agency) #if working_dir doesn't exist, create it ###if os.path.exists(f_stop_times): if all_files_present: if not SkipCalculationServiceData: print "starting service analysis...this might take some time" SummarizeTransitService = os.path.join(self.plugin_dir, "SummarizeTransitService.py") execfile(SummarizeTransitService) else: print "The GTFS appears to be incomplete. The following files seem to be missing." #print "The GTFS appears to be incomplete. Check that all parts are present and try again." for f in missing_files: print f ##create empty dictionary ## BEGIN DISTANCE CODE! distance_dictionary = {} DList_TH_stops = defaultdict(list) ### (temporarily) set ref to TAT in case ##Enter data into Dictionary iter = vltWM.getFeatures() #iter = TAToutput.getFeatures() ##THstopList = [] for feature in iter: ##identifies attributes for future use #print "Feature ID %d: " % feature.id() trailhead_id = feature[str('FEAT_ID')] #print trailhead_id geom = feature.geometry() th_x = geom.asPoint().x() th_y = geom.asPoint().y() th_point = QgsPoint(th_x,th_y) #transit_stop_id = feature['stop_id'] iter_stops = TAT_layer.getFeatures() ###[new layer here?] for stop_feature in iter_stops: stop_id = stop_feature[str('stop_id')] th_id = stop_feature[str('FEAT_ID')] if th_id == trailhead_id: stop_geom = stop_feature.geometry() stop_id = stop_feature['stop_id'] DList_TH_stops[th_id].append(stop_id) stop_x = stop_geom.asPoint().x() stop_y = stop_geom.asPoint().y() s_point = QgsPoint(stop_x,stop_y) stop_distance = 0 a = numpy.array(th_point) b = numpy.array(s_point) ##stop_distance = numpy.sqrt(numpy.sum(a-b)**2) stop_distance = math.sqrt(th_point.sqrDist(s_point)) #print th_id #print stop_id #print stop_distance ####print math.sqrt(th_point.sqrDist(s_point)) th_stop = str(trailhead_id) + ":" + str(stop_id) distance_dictionary[th_stop] = stop_distance #if stop_distance < BufferDistance: # distance_dictionary[th_stop] = stop_distance ##outputGeoJSON vl_outTH = QgsVectorLayer("Point?crs=EPSG:4326", "stop_points", "memory") pr_outTH = vl_outTH.dataProvider() # # changes are only possible when editing the layer vl_outTH.startEditing() # add fields ##pr_outTH.addAttributes([QgsField(th_id_field, QVariant.Int),QgsField(th_name_field, QVariant.String),QgsField("number_stops_nearby", QVariant.Int),QgsField("stops_near", QVariant.String),QgsField("stops_near_dist", QVariant.String)]) pr_outTH.addAttributes([QgsField(th_id_field, QVariant.Int),QgsField(th_name_field, QVariant.String),QgsField("number_stops_nearby", QVariant.Int),QgsField("stops_near", QVariant.String),QgsField("stops_distances", QVariant.String)]) index = 0 iter = trailhead_layer.getFeatures() for feature in iter: geom = feature.geometry() feature_id = feature[th_id_field] feature_name = feature[th_name_field] #stops_near = str(DList_TH_stops[feature_id]) num_stops_near = 0 stops_near_in = DList_TH_stops[feature_id] stops_near = [] for t in stops_near_in: #print t if not t in stops_near: stops_near.append(t) stops_near.sort() num_stops_near = len(stops_near) stops_near = str(stops_near) stops_near = stops_near.replace("u'", "") stops_near = stops_near.replace("'", "") stops_near = stops_near.replace("[", "") stops_near = stops_near.replace("]", "") #print stops_near dist_list = [] stop_list = [] stop_dist_list = [] stops_near_L = DList_TH_stops[feature_id] stops_near_L.sort() for s in stops_near_L: #print s k = str(feature_id) + ":" + str(s) dist = distance_dictionary[k] dist = int(dist) #stop_list_data = str(s) + ', ' #dist_list_data = str(dist) + ', ' dist_list_data = '{stop_id: ' + str(s) + ', distance ' + str(dist) + '}' if not dist_list_data in dist_list: dist_list.append(dist_list_data) stop_list.append(s) stop_dist_list.append(dist) #dist_list.sort() #trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint())) #print "dist_list" #print dist_list #dist_list = dist_list.replace("u'", "") #dist_list = dist_list.replace("'", "") dist_list = str(dist_list) dist_list = dist_list.replace("[", "") dist_list = dist_list.replace("]", "") dist_list = dist_list.replace("'", "") fet = QgsFeature() fet.setGeometry(geom) stop_list = str(stop_list) stop_list = stop_list.replace("u'", "'") stop_dist_list = str(stop_dist_list) #fet.setGeometry(QgsGeometry.fromPoint(geom)) #fet.setAttributes([feature_id, feature_name, num_stops_near, stops_near, dist_list]) fet.setAttributes([feature_id, feature_name, num_stops_near, stop_list, stop_dist_list]) pr_outTH.addFeatures([fet]) vl_outTH.commitChanges() GeoJSONfile = os.path.join(GTFSDir, outputGeoJSON) writeString = "" QgsVectorFileWriter.writeAsVectorFormat(vl_outTH, GeoJSONfile, "utf-8", None, "GeoJSON") #file = open(GeoJSONfile, "w") ##file.write(fieldnames + "\n") #iter = vltWM.getFeatures() #for feature in iter: # ##identifies attributes for future use # #print "Feature ID %d: " % feature.id() # trailhead_id = feature[str('FEAT_ID')] # #trailhead_id = feature['FEAT_ID'] # geom = feature.geometry() # th_x = geom.asPoint().x() # th_y = geom.asPoint().y() # writeLine = '' # writeLine = '{ "type": "Feature", "properties": { "FEAT_ID": ' + str(trailhead_id) # + '\n' # #writeLine = writeLine + ' "STOPS_NEARBY": ' + str(DList_TH_stops[trailhead_id]) ###'\n' # writeLine = writeLine + ' "STOPS_NEARBY": ' + DList_TH_stops[trailhead_id] ###'\n' # writeLine = writeLine + ' }, "geometry": { "type": "Point", "coordinates": [ ' # writeLine = writeLine + str(th_x) + ' ' + str(th_x) + ' ] } }' # writeLine = writeLine + ', \n' # writeString = writeString + writeLine #file.write(writeString) #file.close() end_time = datetime.datetime.now().replace(microsecond=0) print(end_time-start_time) print "done" else: print "Input trailhead data was not specified"
def centroid_intersection_stats(band, geometry, pixel_offset_x, pixel_offset_y, cells_x, cells_y, cell_size_x, cell_size_y, raster_box, no_data): """Stats where centroid of each cell must intersect the polygon. :param band: A valid band from a raster layer. :type band: GDALRasterBand :param geometry: A valid polygon geometry. :type geometry: QgsGeometry :param pixel_offset_x: Left offset for raster window. :type pixel_offset_x: int :param pixel_offset_y: Offset from bottom for raster window. :type pixel_offset_y: int :param cells_x: Width of the raster window. :type cells_x: int :param cells_y: Height of the raster window. :type cells_y: int :param cell_size_x: Size in the x direction of a single cell. :type cell_size_x: float :param cell_size_y: Size in the y direction of a single cell. :type cell_size_y: float :param raster_box: Box defining the extents of the raster. :type raster_box: QgsRectangle :param no_data: Value for no data in the raster. :type no_data: int, float :returns: Sum, Count - sum of the values of all pixels and the count of pixels that intersect with the geometry. :rtype: (float, int) """ cell_center_x = (raster_box.yMaximum() - pixel_offset_y * cell_size_y - cell_size_y / 2) count = 0 geometry_sum = 0 buffer_x_size = cells_x buffer_y_size = 1 # read in a single row at a time cells_to_read_x = cells_x cells_to_read_y = 1 # read in a single row at a time for i in range(0, cells_y): scanline = band.ReadRaster(pixel_offset_x, pixel_offset_y + i, cells_to_read_x, cells_to_read_y, buffer_x_size, buffer_y_size, gdal.GDT_Float32) # Note that the returned scanline is of type string, and contains # xsize*4 bytes of raw binary floating point data. This can be # converted to Python values using the struct module from the standard # library: values = struct.unpack('f' * cells_to_read_x, scanline) # print values if values is None: continue cell_center_y = (raster_box.xMinimum() + pixel_offset_x * cell_size_x + cell_size_x / 2) for j in range(0, cells_x): point = QgsPoint(cell_center_y, cell_center_x) if geometry.contains(point): if values[j] != no_data: geometry_sum += values[j] count += 1 cell_center_y += cell_size_x # Move down one row cell_center_x -= cell_size_y return geometry_sum, count
from qgis.core import ( QgsFeature, QgsGeometry, QgsPoint, QgsFeatureRequest, QgsExpression, QgsProject, QgsOfflineEditing, ) # Tet features, fields: [id, name, geometry] # "id" is used as a pk to retriev features by attribute TEST_FEATURES = [ (1, 'name 1', QgsPoint(9, 45)), (2, 'name 2', QgsPoint(9.5, 45.5)), (3, 'name 3', QgsPoint(9.5, 46)), (4, 'name 4', QgsPoint(10, 46.5)), ] # Additional features for insert test TEST_FEATURES_INSERT = [ (5, 'name 5', QgsPoint(9.7, 45.7)), (6, 'name 6', QgsPoint(10.6, 46.6)), ] class OfflineTestBase(object): """Generic test methods for all online providers"""
def __init__(self, parent, rnavType, category, position_0, position_1, position_List, flagStr = None): QDialog.__init__(self, parent) self.flagStrName = flagStr # self.resize(326, 310) self.verticalLayout = QVBoxLayout(self) self.verticalLayout.setSpacing(6) self.verticalLayout.setMargin(3) self.verticalLayout.setObjectName(("verticalLayout")) self.groupBox = QGroupBox(self) self.groupBox.setTitle(("")) self.groupBox.setObjectName(("groupBox")) self.verticalLayout_2 = QVBoxLayout(self.groupBox) self.verticalLayout_2.setSpacing(0) self.verticalLayout_2.setMargin(3) self.verticalLayout_2.setObjectName(("verticalLayout_2")) self.groupBox_5 = QGroupBox(self.groupBox) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.groupBox_5.sizePolicy().hasHeightForWidth()) self.groupBox_5.setSizePolicy(sizePolicy) font = QFont() font.setFamily(("Arial")) self.groupBox_5.setFont(font) self.groupBox_5.setObjectName(("groupBox_5")) self.horizontalLayout_19 = QHBoxLayout(self.groupBox_5) self.horizontalLayout_19.setSpacing(0) self.horizontalLayout_19.setMargin(0) self.horizontalLayout_19.setObjectName(("horizontalLayout_19")) self.frame_18 = QFrame(self.groupBox_5) self.frame_18.setFrameShape(QFrame.StyledPanel) self.frame_18.setFrameShadow(QFrame.Raised) self.frame_18.setObjectName(("frame_18")) self.verticalLayout_13 = QVBoxLayout(self.frame_18) self.verticalLayout_13.setSpacing(0) self.verticalLayout_13.setContentsMargins(-1, -1, 0, -1) self.verticalLayout_13.setObjectName(("verticalLayout_13")) self.frame_19 = QFrame(self.frame_18) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_19.sizePolicy().hasHeightForWidth()) self.frame_19.setSizePolicy(sizePolicy) self.frame_19.setFrameShape(QFrame.StyledPanel) self.frame_19.setFrameShadow(QFrame.Raised) self.frame_19.setObjectName(("frame_19")) self.horizontalLayout_20 = QHBoxLayout(self.frame_19) self.horizontalLayout_20.setSpacing(0) self.horizontalLayout_20.setMargin(0) self.horizontalLayout_20.setObjectName(("horizontalLayout_20")) self.label_9 = QLabel(self.frame_19) self.label_9.setMaximumSize(QSize(60, 16777215)) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.label_9.setFont(font) self.label_9.setObjectName(("label_9")) self.horizontalLayout_20.addWidget(self.label_9) self.txtTHR_X = QLineEdit(self.frame_19) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.txtTHR_X.sizePolicy().hasHeightForWidth()) self.txtTHR_X.setSizePolicy(sizePolicy) self.txtTHR_X.setMaximumSize(QSize(16777215, 16777215)) font = QFont() font.setFamily(("Arial")) self.txtTHR_X.setFont(font) self.txtTHR_X.setObjectName(("txtTHR_X")) self.horizontalLayout_20.addWidget(self.txtTHR_X) self.verticalLayout_13.addWidget(self.frame_19) self.frame_20 = QFrame(self.frame_18) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_20.sizePolicy().hasHeightForWidth()) self.frame_20.setSizePolicy(sizePolicy) self.frame_20.setFrameShape(QFrame.StyledPanel) self.frame_20.setFrameShadow(QFrame.Raised) self.frame_20.setObjectName(("frame_20")) self.horizontalLayout_21 = QHBoxLayout(self.frame_20) self.horizontalLayout_21.setSpacing(0) self.horizontalLayout_21.setMargin(0) self.horizontalLayout_21.setObjectName(("horizontalLayout_21")) self.label_10 = QLabel(self.frame_20) self.label_10.setMaximumSize(QSize(60, 16777215)) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.label_10.setFont(font) self.label_10.setObjectName(("label_10")) self.horizontalLayout_21.addWidget(self.label_10) self.txtTHR_Y = QLineEdit(self.frame_20) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.txtTHR_Y.sizePolicy().hasHeightForWidth()) self.txtTHR_Y.setSizePolicy(sizePolicy) self.txtTHR_Y.setMaximumSize(QSize(16777215, 16777215)) font = QFont() font.setFamily(("Arial")) self.txtTHR_Y.setFont(font) self.txtTHR_Y.setObjectName(("txtTHR_Y")) self.horizontalLayout_21.addWidget(self.txtTHR_Y) self.verticalLayout_13.addWidget(self.frame_20) self.horizontalLayout_19.addWidget(self.frame_18) self.frame_21 = QFrame(self.groupBox_5) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_21.sizePolicy().hasHeightForWidth()) self.frame_21.setSizePolicy(sizePolicy) self.frame_21.setMaximumSize(QSize(30, 70)) self.frame_21.setFrameShape(QFrame.StyledPanel) self.frame_21.setFrameShadow(QFrame.Raised) self.frame_21.setObjectName(("frame_21")) self.verticalLayout_14 = QVBoxLayout(self.frame_21) self.verticalLayout_14.setSpacing(0) self.verticalLayout_14.setMargin(0) self.verticalLayout_14.setObjectName(("verticalLayout_14")) self.btnCaptureRunwayTHR = QToolButton(self.frame_21) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.btnCaptureRunwayTHR.sizePolicy().hasHeightForWidth()) self.btnCaptureRunwayTHR.setSizePolicy(sizePolicy) self.btnCaptureRunwayTHR.setMaximumSize(QSize(16777215, 47)) icon = QIcon() icon.addPixmap(QPixmap(("Resource/coordinate_capture.png")), QIcon.Normal, QIcon.Off) self.btnCaptureRunwayTHR.setIcon(icon) self.btnCaptureRunwayTHR.setObjectName(("btnCaptureRunwayTHR")) self.verticalLayout_14.addWidget(self.btnCaptureRunwayTHR) # self.btnToolTHR = QToolButton(self.frame_21) # sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) # sizePolicy.setHorizontalStretch(0) # sizePolicy.setVerticalStretch(0) # sizePolicy.setHeightForWidth(self.btnToolTHR.sizePolicy().hasHeightForWidth()) # self.btnToolTHR.setSizePolicy(sizePolicy) # self.btnToolTHR.setMaximumSize(QSize(16777215, 20)) # icon1 = QIcon() # icon1.addPixmap(QPixmap(("Resource/sort2.png")), QIcon.Normal, QIcon.Off) # self.btnToolTHR.setIcon(icon1) # self.btnToolTHR.setObjectName(("btnToolTHR")) # self.verticalLayout_14.addWidget(self.btnToolTHR) self.horizontalLayout_19.addWidget(self.frame_21) self.verticalLayout_2.addWidget(self.groupBox_5) self.groupBox_4 = QGroupBox(self.groupBox) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.groupBox_4.sizePolicy().hasHeightForWidth()) self.groupBox_4.setSizePolicy(sizePolicy) font = QFont() font.setFamily(("Arial")) self.groupBox_4.setFont(font) self.groupBox_4.setObjectName(("groupBox_4")) self.horizontalLayout_16 = QHBoxLayout(self.groupBox_4) self.horizontalLayout_16.setSpacing(0) self.horizontalLayout_16.setMargin(0) self.horizontalLayout_16.setObjectName(("horizontalLayout_16")) self.frame_14 = QFrame(self.groupBox_4) self.frame_14.setFrameShape(QFrame.StyledPanel) self.frame_14.setFrameShadow(QFrame.Raised) self.frame_14.setObjectName(("frame_14")) self.verticalLayout_11 = QVBoxLayout(self.frame_14) self.verticalLayout_11.setSpacing(0) self.verticalLayout_11.setContentsMargins(-1, -1, 0, -1) self.verticalLayout_11.setObjectName(("verticalLayout_11")) self.frame_15 = QFrame(self.frame_14) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_15.sizePolicy().hasHeightForWidth()) self.frame_15.setSizePolicy(sizePolicy) self.frame_15.setFrameShape(QFrame.StyledPanel) self.frame_15.setFrameShadow(QFrame.Raised) self.frame_15.setObjectName(("frame_15")) self.horizontalLayout_17 = QHBoxLayout(self.frame_15) self.horizontalLayout_17.setSpacing(0) self.horizontalLayout_17.setMargin(0) self.horizontalLayout_17.setObjectName(("horizontalLayout_17")) self.label_7 = QLabel(self.frame_15) self.label_7.setMaximumSize(QSize(60, 16777215)) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.label_7.setFont(font) self.label_7.setObjectName(("label_7")) self.horizontalLayout_17.addWidget(self.label_7) self.txtEND_X = QLineEdit(self.frame_15) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.txtEND_X.sizePolicy().hasHeightForWidth()) self.txtEND_X.setSizePolicy(sizePolicy) self.txtEND_X.setMaximumSize(QSize(16777215, 16777215)) font = QFont() font.setFamily(("Arial")) self.txtEND_X.setFont(font) self.txtEND_X.setObjectName(("txtEND_X")) self.horizontalLayout_17.addWidget(self.txtEND_X) self.verticalLayout_11.addWidget(self.frame_15) self.frame_16 = QFrame(self.frame_14) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_16.sizePolicy().hasHeightForWidth()) self.frame_16.setSizePolicy(sizePolicy) self.frame_16.setFrameShape(QFrame.StyledPanel) self.frame_16.setFrameShadow(QFrame.Raised) self.frame_16.setObjectName(("frame_16")) self.horizontalLayout_18 = QHBoxLayout(self.frame_16) self.horizontalLayout_18.setSpacing(0) self.horizontalLayout_18.setMargin(0) self.horizontalLayout_18.setObjectName(("horizontalLayout_18")) self.label_8 = QLabel(self.frame_16) self.label_8.setMaximumSize(QSize(60, 16777215)) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.label_8.setFont(font) self.label_8.setObjectName(("label_8")) self.horizontalLayout_18.addWidget(self.label_8) self.txtEND_Y = QLineEdit(self.frame_16) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.txtEND_Y.sizePolicy().hasHeightForWidth()) self.txtEND_Y.setSizePolicy(sizePolicy) self.txtEND_Y.setMaximumSize(QSize(16777215, 16777215)) font = QFont() font.setFamily(("Arial")) self.txtEND_Y.setFont(font) self.txtEND_Y.setObjectName(("txtEND_Y")) self.horizontalLayout_18.addWidget(self.txtEND_Y) self.verticalLayout_11.addWidget(self.frame_16) self.horizontalLayout_16.addWidget(self.frame_14) self.frame_17 = QFrame(self.groupBox_4) self.frame_17.setMaximumSize(QSize(30, 16777215)) self.frame_17.setFrameShape(QFrame.StyledPanel) self.frame_17.setFrameShadow(QFrame.Raised) self.frame_17.setObjectName(("frame_17")) self.verticalLayout_12 = QVBoxLayout(self.frame_17) self.verticalLayout_12.setSpacing(0) self.verticalLayout_12.setMargin(0) self.verticalLayout_12.setObjectName(("verticalLayout_12")) self.btnCaptureRunwayEND = QToolButton(self.frame_17) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.btnCaptureRunwayEND.sizePolicy().hasHeightForWidth()) self.btnCaptureRunwayEND.setSizePolicy(sizePolicy) self.btnCaptureRunwayEND.setMaximumSize(QSize(16777215, 47)) self.btnCaptureRunwayEND.setIcon(icon) self.btnCaptureRunwayEND.setObjectName(("btnCaptureRunwayEND")) self.verticalLayout_12.addWidget(self.btnCaptureRunwayEND) # self.btnToolEND = QToolButton(self.frame_17) # sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) # sizePolicy.setHorizontalStretch(0) # sizePolicy.setVerticalStretch(0) # sizePolicy.setHeightForWidth(self.btnToolEND.sizePolicy().hasHeightForWidth()) # self.btnToolEND.setSizePolicy(sizePolicy) # self.btnToolEND.setMaximumSize(QSize(16777215, 20)) # self.btnToolEND.setIcon(icon1) # self.btnToolEND.setObjectName(("btnToolEND")) # self.verticalLayout_12.addWidget(self.btnToolEND) self.horizontalLayout_16.addWidget(self.frame_17) self.verticalLayout_2.addWidget(self.groupBox_4) self.lbl1 = QLabel(self.groupBox) font = QFont() font.setFamily(("Arial")) self.lbl1.setFont(font) self.lbl1.setText(("")) self.lbl1.setAlignment(Qt.AlignCenter) self.lbl1.setWordWrap(False) self.lbl1.setMargin(0) self.lbl1.setObjectName(("lbl1")) self.verticalLayout_2.addWidget(self.lbl1) self.lbl2 = QLabel(self.groupBox) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.lbl2.setFont(font) self.lbl2.setText(("")) self.lbl2.setAlignment(Qt.AlignCenter) self.lbl2.setObjectName(("lbl2")) self.verticalLayout_2.addWidget(self.lbl2) self.frame_22 = QFrame(self.groupBox) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_22.sizePolicy().hasHeightForWidth()) self.frame_22.setSizePolicy(sizePolicy) self.frame_22.setFrameShape(QFrame.StyledPanel) self.frame_22.setFrameShadow(QFrame.Raised) self.frame_22.setObjectName(("frame_22")) self.horizontalLayout_22 = QHBoxLayout(self.frame_22) self.horizontalLayout_22.setSpacing(0) self.horizontalLayout_22.setMargin(0) self.horizontalLayout_22.setObjectName(("horizontalLayout_22")) self.label_11 = QLabel(self.frame_22) self.label_11.setMinimumSize(QSize(170, 0)) self.label_11.setMaximumSize(QSize(180, 16777215)) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.label_11.setFont(font) self.label_11.setObjectName(("label_11")) self.horizontalLayout_22.addWidget(self.label_11) self.txtForm = QLineEdit(self.frame_22) self.txtForm.setEnabled(False) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.txtForm.sizePolicy().hasHeightForWidth()) self.txtForm.setSizePolicy(sizePolicy) self.txtForm.setMaximumSize(QSize(16777215, 16777215)) font = QFont() font.setFamily(("Arial")) self.txtForm.setFont(font) self.txtForm.setObjectName(("txtForm")) self.horizontalLayout_22.addWidget(self.txtForm) self.verticalLayout_2.addWidget(self.frame_22) self.frame_23 = QFrame(self.groupBox) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_23.sizePolicy().hasHeightForWidth()) self.frame_23.setSizePolicy(sizePolicy) self.frame_23.setFrameShape(QFrame.StyledPanel) self.frame_23.setFrameShadow(QFrame.Raised) self.frame_23.setObjectName(("frame_23")) self.horizontalLayout_23 = QHBoxLayout(self.frame_23) self.horizontalLayout_23.setSpacing(0) self.horizontalLayout_23.setMargin(0) self.horizontalLayout_23.setObjectName(("horizontalLayout_23")) self.label_12 = QLabel(self.frame_23) self.label_12.setMinimumSize(QSize(170, 0)) self.label_12.setMaximumSize(QSize(180, 16777215)) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.label_12.setFont(font) self.label_12.setObjectName(("label_12")) self.horizontalLayout_23.addWidget(self.label_12) self.txtBearing = QLineEdit(self.frame_23) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.txtBearing.sizePolicy().hasHeightForWidth()) self.txtBearing.setSizePolicy(sizePolicy) self.txtBearing.setMaximumSize(QSize(16777215, 16777215)) font = QFont() font.setFamily(("Arial")) self.txtBearing.setFont(font) self.txtBearing.setObjectName(("txtBearing")) self.horizontalLayout_23.addWidget(self.txtBearing) self.btnCaptureBearing = QToolButton(self.frame_23) sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.btnCaptureBearing.sizePolicy().hasHeightForWidth()) self.btnCaptureBearing.setSizePolicy(sizePolicy) self.btnCaptureBearing.setMaximumSize(QSize(16777215, 25)) self.btnCaptureBearing.setStyleSheet(("")) self.btnCaptureBearing.setIcon(icon) self.btnCaptureBearing.setObjectName(("btnCaptureBearing")) self.horizontalLayout_23.addWidget(self.btnCaptureBearing) self.verticalLayout_2.addWidget(self.frame_23) self.frame_24 = QFrame(self.groupBox) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.frame_24.sizePolicy().hasHeightForWidth()) self.frame_24.setSizePolicy(sizePolicy) self.frame_24.setFrameShape(QFrame.StyledPanel) self.frame_24.setFrameShadow(QFrame.Raised) self.frame_24.setObjectName(("frame_24")) self.horizontalLayout_24 = QHBoxLayout(self.frame_24) self.horizontalLayout_24.setSpacing(0) self.horizontalLayout_24.setMargin(0) self.horizontalLayout_24.setObjectName(("horizontalLayout_24")) self.lblDistance = QLabel(self.frame_24) self.lblDistance.setMinimumSize(QSize(170, 0)) self.lblDistance.setMaximumSize(QSize(180, 16777215)) font = QFont() font.setFamily(("Arial")) font.setBold(False) font.setWeight(50) self.lblDistance.setFont(font) self.lblDistance.setObjectName(("lblDistance")) self.horizontalLayout_24.addWidget(self.lblDistance) self.txtDistance = QLineEdit(self.frame_24) self.txtDistance.setEnabled(False) sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.txtDistance.sizePolicy().hasHeightForWidth()) self.txtDistance.setSizePolicy(sizePolicy) self.txtDistance.setMaximumSize(QSize(16777215, 16777215)) font = QFont() font.setFamily(("Arial")) self.txtDistance.setFont(font) self.txtDistance.setObjectName(("txtDistance")) self.horizontalLayout_24.addWidget(self.txtDistance) self.btnCaptureDistance = QToolButton(self.frame_24) sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.btnCaptureDistance.sizePolicy().hasHeightForWidth()) self.btnCaptureDistance.setSizePolicy(sizePolicy) self.btnCaptureDistance.setMaximumSize(QSize(16777215, 23)) self.btnCaptureDistance.setStyleSheet(("")) self.btnCaptureDistance.setIcon(icon) self.btnCaptureDistance.setObjectName(("btnCaptureDistance")) self.horizontalLayout_24.addWidget(self.btnCaptureDistance) self.verticalLayout_2.addWidget(self.frame_24) self.verticalLayout.addWidget(self.groupBox) self.buttonBox = QDialogButtonBox(self) self.buttonBox.setOrientation(Qt.Horizontal) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok) self.buttonBox.setObjectName(("buttonBox")) self.verticalLayout.addWidget(self.buttonBox) self.btnCaptureDistance.clicked.connect(self.method_9) self.btnCaptureBearing.clicked.connect(self.method_8) self.txtEND_X.textChanged.connect(self.method_4) self.txtEND_Y.textChanged.connect(self.method_4) self.txtTHR_X.textChanged.connect(self.method_4) self.txtTHR_Y.textChanged.connect(self.method_4) self.type = rnavType self.category = category self.resultPosionList = position_List self.MinBearing2 = 0 self.MaxBearing2= 0 self.waypoint = None self.distanceMeasureTool = MeasureTool(define._canvas, self.txtDistance, DistanceUnits.NM) self.bearingTool = CaptureBearingTool(define._canvas, self.txtBearing) self.CaptureTHRCoordTool = CaptureCoordinateTool(define._canvas, self.txtTHR_X, self.txtTHR_Y) self.CaptureTHRCoordTool.rubberBandClick.setColor(Qt.green) self.CaptureENDCoordTool = CaptureCoordinateTool(define._canvas, self.txtEND_X, self.txtEND_Y) self.CaptureENDCoordTool.rubberBandClick.setColor(Qt.blue) if rnavType == RnavCommonWaypoint.FAWP or rnavType == RnavCommonWaypoint.MAWP: self.from1 = position_0 self.resize(326, 310) if position_List[0] != None: self.setThrPosition(position_List[0].x(),position_List[0].y()) self.CaptureTHRCoordTool.rubberBandClick.addPoint(QgsPoint(position_List[0].x(),position_List[0].y())) # self.CaptureTHRCoordTool.rubberBandClick.show() if position_List[1] != None: self.setEndPosition(position_List[1].x(),position_List[1].y()) self.CaptureENDCoordTool.rubberBandClick.addPoint(QgsPoint(position_List[1].x(),position_List[1].y())) # self.setWaypoint(position_List[2]) else: self.from1 = position_1 num = RnavWaypoints.smethod_0(position_0, position_1) self.MinBearing = RnavWaypoints.smethod_7(rnavType, category, num) self.MaxBearing= RnavWaypoints.smethod_8(rnavType, category, num) self.MinDistance = RnavWaypoints.smethod_4(rnavType, category) if flagStr == "Y-Bar": if (rnavType == RnavCommonWaypoint.IAWP1): self.setBearing(self.MaxBearing) elif (rnavType != RnavCommonWaypoint.IAWP3): self.setBearing(num) else: self.setBearing(self.MinBearing) else: if (rnavType == RnavCommonWaypoint.IAWP1): self.setBearing(self.MinBearing) elif (rnavType != RnavCommonWaypoint.IAWP3): self.setBearing(num) else: self.setBearing(self.MaxBearing) # if self.txtDistance.isEnabled(): # self.setDistance(RnavWaypoints.smethod_6(rnavType, category).NauticalMiles) # self.setWaypoint(position_List.pop(0)) self.method_4() self.retranslateUi() QObject.connect(self.buttonBox, SIGNAL(("accepted()")), self.btnCalculate_Click) QObject.connect(self.buttonBox, SIGNAL(("rejected()")), self.reject) # QMetaObject.connectSlotsByName(Dialog) # self.btnToolEND.clicked.connect(self.removeEnd) # self.btnToolTHR.clicked.connect(self.removeThr) self.btnCaptureRunwayTHR.clicked.connect(self.captureTHR) self.btnCaptureRunwayEND.clicked.connect(self.captureEND)
def testQgsEllipseRepr(self): e = QgsEllipse(QgsPoint(1, 2), 2.0, 3.0) self.assertEqual(e.__repr__(), '<QgsEllipse: Ellipse (Center: Point (1 2), Semi-Major Axis: 3, Semi-Minor Axis: 2, Azimuth: 180)>')
def processAlgorithm(self, feedback): layer = dataobjects.getLayerFromString( self.getParameterValue(self.POINTS)) weightField = self.getParameterValue(self.WEIGHT) uniqueField = self.getParameterValue(self.UID) if weightField is None: weightIndex = -1 else: weightIndex = layer.fields().lookupField(weightField) if uniqueField is None: uniqueIndex = -1 else: uniqueIndex = layer.fields().lookupField(uniqueField) fieldList = [ QgsField('MEAN_X', QVariant.Double, '', 24, 15), QgsField('MEAN_Y', QVariant.Double, '', 24, 15), QgsField('UID', QVariant.String, '', 255) ] writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fieldList, QgsWkbTypes.Point, layer.crs()) features = vector.features(layer) total = 100.0 / len(features) means = {} for current, feat in enumerate(features): feedback.setProgress(int(current * total)) if uniqueIndex == -1: clazz = "Single class" else: clazz = str(feat.attributes()[uniqueIndex]).strip() if weightIndex == -1: weight = 1.00 else: try: weight = float(feat.attributes()[weightIndex]) except: weight = 1.00 if weight < 0: raise GeoAlgorithmExecutionException( self. tr('Negative weight value found. Please fix your data and try again.' )) if clazz not in means: means[clazz] = (0, 0, 0) (cx, cy, totalweight) = means[clazz] geom = QgsGeometry(feat.geometry()) geom = vector.extractPoints(geom) for i in geom: cx += i.x() * weight cy += i.y() * weight totalweight += weight means[clazz] = (cx, cy, totalweight) current = 0 total = 100.0 / len(means) for (clazz, values) in list(means.items()): outFeat = QgsFeature() cx = values[0] / values[2] cy = values[1] / values[2] meanPoint = QgsPoint(cx, cy) outFeat.setGeometry(QgsGeometry.fromPoint(meanPoint)) outFeat.setAttributes([cx, cy, clazz]) writer.addFeature(outFeat) current += 1 feedback.setProgress(int(current * total)) del writer
def testQgsCurvepolygonRepr(self): cp = QgsCurvePolygon() cs = QgsCircularString(QgsPoint(1, 10), QgsPoint(2, 11), QgsPoint(1, 10)) cp.setExteriorRing(cs) self.assertEqual(cp.__repr__(), '<QgsCurvePolygon: CurvePolygon (CircularString (1 10, 2 11, 1 10))>')
def testMeasureMultiPolygon(self): # +-+-+ +-+-+ # | | | | # + +-+ +-+ + # | | | | # +-+ +-+ polygon = QgsGeometry.fromMultiPolygon([[[ QgsPoint(0, 0), QgsPoint(1, 0), QgsPoint(1, 1), QgsPoint(2, 1), QgsPoint(2, 2), QgsPoint(0, 2), QgsPoint(0, 0), ]], [[ QgsPoint(4, 0), QgsPoint(5, 0), QgsPoint(5, 2), QgsPoint(3, 2), QgsPoint(3, 1), QgsPoint(4, 1), QgsPoint(4, 0), ]]]) da = QgsDistanceArea() area = da.measureArea(polygon) assert area == 6, 'Expected:\n%f\nGot:\n%f\n' % (6, area) perimeter = da.measurePerimeter(polygon) assert perimeter == 16, "Expected:\n%f\nGot:\n%f\n" % (16, perimeter)
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.INPUT_VECTOR)) startPoint = self.getParameterValue(self.START_POINT) strategy = self.getParameterValue(self.STRATEGY) travelCost = self.getParameterValue(self.TRAVEL_COST) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) tmp = startPoint.split(',') startPoint = QgsPoint(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) director.addStrategy(strategy) builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(), iface.mapCanvas().hasCrsTransformEnabled(), tolerance) progress.setInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, [startPoint]) progress.setInfo(self.tr('Calculating service area...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) vertices = [] for i, v in enumerate(cost): if v > travelCost and tree[i] != -1: vertexId = graph.edge(tree [i]).outVertex() if cost[vertexId] <= travelCost: vertices.append(i) upperBoundary = [] lowerBoundary = [] for i in vertices: upperBoundary.append(graph.vertex(graph.edge(tree[i]).inVertex()).point()) lowerBoundary.append(graph.vertex(graph.edge(tree[i]).outVertex()).point()) progress.setInfo(self.tr('Writting results...')) fields = QgsFields() fields.append(QgsField('type', QVariant.String, '', 254, 0)) fields.append(QgsField('start', QVariant.String, '', 254, 0)) feat = QgsFeature() feat.setFields(fields) geomUpper = QgsGeometry.fromMultiPoint(upperBoundary) geomLower = QgsGeometry.fromMultiPoint(lowerBoundary) writer = self.getOutputFromName( self.OUTPUT_POINTS).getVectorWriter( fields, QgsWkbTypes.MultiPoint, layer.crs()) feat.setGeometry(geomUpper) feat['type'] = 'upper' feat['start'] = startPoint.toString() writer.addFeature(feat) feat.setGeometry(geomLower) feat['type'] = 'lower' feat['start'] = startPoint.toString() writer.addFeature(feat) del writer writer = self.getOutputFromName( self.OUTPUT_POLYGON).getVectorWriter( fields, QgsWkbTypes.Polygon, layer.crs()) geom = geomUpper.convexHull() feat.setGeometry(geom) feat['type'] = 'upper' feat['start'] = startPoint.toString() writer.addFeature(feat) geom = geomLower.convexHull() feat.setGeometry(geom) feat['type'] = 'lower' feat['start'] = startPoint.toString() writer.addFeature(feat) del writer
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.INPUT_VECTOR)) startPoint = self.getParameterValue(self.START_POINT) endPoints = dataobjects.getObjectFromUri( self.getParameterValue(self.END_POINTS)) strategy = self.getParameterValue(self.STRATEGY) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) fields = QgsFields() fields.append(QgsField('start', QVariant.String, '', 254, 0)) fields.append(QgsField('end', QVariant.String, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 20, 7)) feat = QgsFeature() feat.setFields(fields) writer = self.getOutputFromName( self.OUTPUT_LAYER).getVectorWriter( fields.toList(), QgsWkbTypes.LineString, layer.crs()) tmp = startPoint.split(',') startPoint = QgsPoint(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) multiplier = 3600 director.addStrategy(strategy) builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(), iface.mapCanvas().hasCrsTransformEnabled(), tolerance) progress.setInfo(self.tr('Loading end points...')) request = QgsFeatureRequest() request.setFlags(request.flags() ^ QgsFeatureRequest.SubsetOfAttributes) features = vector.features(endPoints, request) count = len(features) points = [startPoint] for f in features: points.append(f.geometry().asPoint()) progress.setInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, points) progress.setInfo(self.tr('Calculating shortest paths...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) route = [] total = 100.0 / count for i in range(1, count + 1): idxEnd = graph.findVertex(snappedPoints[i]) if tree[idxEnd] == -1: msg = self.tr('There is no route from start point ({}) to end point ({}).'.format(startPoint.toString(), points[i].toString())) progress.setText(msg) ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, msg) continue cost = 0.0 current = idxEnd while current != idxStart: cost += graph.edge(tree[current]).cost(0) route.append(graph.vertex(graph.edge(tree[current]).inVertex()).point()) current = graph.edge(tree[current]).outVertex() route.append(snappedPoints[0]) route.reverse() geom = QgsGeometry.fromPolyline(route) feat.setGeometry(geom) feat['start'] = startPoint.toString() feat['end'] = points[i].toString() feat['cost'] = cost / multiplier writer.addFeature(feat) route[:] = [] progress.setPercentage(int(i * total)) del writer
def valRaster(x, y, rLayer): z = rLayer.dataProvider().identify(QgsPoint( x, y), QgsRaster.IdentifyFormatValue).results()[1] return z
def processAlgorithm(self, feedback): layer = dataobjects.getLayerFromString( self.getParameterValue(self.INPUT_VECTOR)) startPoint = self.getParameterValue(self.START_POINT) endPoints = dataobjects.getLayerFromString( self.getParameterValue(self.END_POINTS)) strategy = self.getParameterValue(self.STRATEGY) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) fields = QgsFields() fields.append(QgsField('start', QVariant.String, '', 254, 0)) fields.append(QgsField('end', QVariant.String, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 20, 7)) feat = QgsFeature() feat.setFields(fields) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( fields.toList(), QgsWkbTypes.LineString, layer.crs()) tmp = startPoint.split(',') startPoint = QgsPoint(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor( distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) multiplier = 3600 director.addStrategy(strategy) builder = QgsGraphBuilder( iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance) feedback.pushInfo(self.tr('Loading end points...')) request = QgsFeatureRequest() request.setFlags(request.flags() ^ QgsFeatureRequest.SubsetOfAttributes) features = vector.features(endPoints, request) count = len(features) points = [startPoint] for f in features: points.append(f.geometry().asPoint()) feedback.pushInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, points) feedback.pushInfo(self.tr('Calculating shortest paths...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) route = [] total = 100.0 / count for i in range(1, count + 1): idxEnd = graph.findVertex(snappedPoints[i]) if tree[idxEnd] == -1: msg = self.tr( 'There is no route from start point ({}) to end point ({}).' .format(startPoint.toString(), points[i].toString())) feedback.setProgressText(msg) ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, msg) continue cost = 0.0 current = idxEnd while current != idxStart: cost += graph.edge(tree[current]).cost(0) route.append( graph.vertex(graph.edge(tree[current]).inVertex()).point()) current = graph.edge(tree[current]).outVertex() route.append(snappedPoints[0]) route.reverse() geom = QgsGeometry.fromPolyline(route) feat.setGeometry(geom) feat['start'] = startPoint.toString() feat['end'] = points[i].toString() feat['cost'] = cost / multiplier writer.addFeature(feat) route[:] = [] feedback.setProgress(int(i * total)) del writer
def clip_voronoi(self, edges, c, width, height, extent, exX, exY): """Clip voronoi function based on code written for Inkscape. Copyright (C) 2010 Alvin Penner, [email protected] """ def clip_line(x1, y1, x2, y2, w, h, x, y): if x1 < 0 - x and x2 < 0 - x: return [0, 0, 0, 0] if x1 > w + x and x2 > w + x: return [0, 0, 0, 0] if x1 < 0 - x: y1 = (y1 * x2 - y2 * x1) / (x2 - x1) x1 = 0 - x if x2 < 0 - x: y2 = (y1 * x2 - y2 * x1) / (x2 - x1) x2 = 0 - x if x1 > w + x: y1 = y1 + (w + x - x1) * (y2 - y1) / (x2 - x1) x1 = w + x if x2 > w + x: y2 = y1 + (w + x - x1) * (y2 - y1) / (x2 - x1) x2 = w + x if y1 < 0 - y and y2 < 0 - y: return [0, 0, 0, 0] if y1 > h + y and y2 > h + y: return [0, 0, 0, 0] if x1 == x2 and y1 == y2: return [0, 0, 0, 0] if y1 < 0 - y: x1 = (x1 * y2 - x2 * y1) / (y2 - y1) y1 = 0 - y if y2 < 0 - y: x2 = (x1 * y2 - x2 * y1) / (y2 - y1) y2 = 0 - y if y1 > h + y: x1 = x1 + (h + y - y1) * (x2 - x1) / (y2 - y1) y1 = h + y if y2 > h + y: x2 = x1 + (h + y - y1) * (x2 - x1) / (y2 - y1) y2 = h + y return [x1, y1, x2, y2] lines = [] hasXMin = False hasYMin = False hasXMax = False hasYMax = False for edge in edges: if edge[1] >= 0 and edge[2] >= 0: # Two vertices [x1, y1, x2, y2] = clip_line( c.vertices[edge[1]][0], c.vertices[edge[1]][1], c.vertices[edge[2]][0], c.vertices[edge[2]][1], width, height, exX, exY, ) elif edge[1] >= 0: # Only one vertex if c.lines[edge[0]][1] == 0: # Vertical line xtemp = c.lines[edge[0]][2] / c.lines[edge[0]][0] if c.vertices[edge[1]][1] > (height + exY) / 2: ytemp = height + exY else: ytemp = 0 - exX else: xtemp = width + exX ytemp = (c.lines[edge[0]][2] - (width + exX) * c.lines[edge[0]][0]) / c.lines[edge[0]][1] [x1, y1, x2, y2] = clip_line( c.vertices[edge[1]][0], c.vertices[edge[1]][1], xtemp, ytemp, width, height, exX, exY, ) elif edge[2] >= 0: # Only one vertex if c.lines[edge[0]][1] == 0: # Vertical line xtemp = c.lines[edge[0]][2] / c.lines[edge[0]][0] if c.vertices[edge[2]][1] > (height + exY) / 2: ytemp = height + exY else: ytemp = 0.0 - exY else: xtemp = 0.0 - exX ytemp = c.lines[edge[0]][2] / c.lines[edge[0]][1] [x1, y1, x2, y2] = clip_line( xtemp, ytemp, c.vertices[edge[2]][0], c.vertices[edge[2]][1], width, height, exX, exY, ) if x1 or x2 or y1 or y2: lines.append(QgsPoint(x1 + extent.xMinimum(), y1 + extent.yMinimum())) lines.append(QgsPoint(x2 + extent.xMinimum(), y2 + extent.yMinimum())) if 0 - exX in (x1, x2): hasXMin = True if 0 - exY in (y1, y2): hasYMin = True if height + exY in (y1, y2): hasYMax = True if width + exX in (x1, x2): hasXMax = True if hasXMin: if hasYMax: lines.append(QgsPoint(extent.xMinimum() - exX, height + extent.yMinimum() + exY)) if hasYMin: lines.append(QgsPoint(extent.xMinimum() - exX, extent.yMinimum() - exY)) if hasXMax: if hasYMax: lines.append(QgsPoint(width + extent.xMinimum() + exX, height + extent.yMinimum() + exY)) if hasYMin: lines.append(QgsPoint(width + extent.xMinimum() + exX, extent.yMinimum() - exY)) return lines
def mouseMove(self, currentPos): if self.isEditing == 1: self.myRubberBand.movePoint(QgsPoint(currentPos))
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_VECTOR)) rasterPath = unicode(self.getParameterValue(self.INPUT_RASTER)) rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly) geoTransform = rasterDS.GetGeoTransform() rasterDS = None fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) fields.append(QgsField('poly_id', QVariant.Int, '', 10, 0)) fields.append(QgsField('point_id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( fields.toList(), QGis.WKBPoint, layer.crs()) outFeature = QgsFeature() outFeature.setFields(fields) point = QgsPoint() fid = 0 polyId = 0 pointId = 0 current = 0 features = vector.features(layer) total = 100.0 / len(features) for f in features: geom = f.geometry() bbox = geom.boundingBox() xMin = bbox.xMinimum() xMax = bbox.xMaximum() yMin = bbox.yMinimum() yMax = bbox.yMaximum() (startRow, startColumn) = raster.mapToPixel(xMin, yMax, geoTransform) (endRow, endColumn) = raster.mapToPixel(xMax, yMin, geoTransform) for row in xrange(startRow, endRow + 1): for col in xrange(startColumn, endColumn + 1): (x, y) = raster.pixelToMap(row, col, geoTransform) point.setX(x) point.setY(y) if geom.contains(point): outFeature.setGeometry(QgsGeometry.fromPoint(point)) outFeature['id'] = fid outFeature['poly_id'] = polyId outFeature['point_id'] = pointId fid += 1 pointId += 1 writer.addFeature(outFeature) pointId = 0 polyId += 1 current += 1 progress.setPercentage(int(current * total)) del writer
def _lineGrid(self, sink, bbox, hSpacing, vSpacing, hOverlay, vOverlay, feedback): feat = QgsFeature() if hOverlay > 0: hSpace = [hSpacing - hOverlay, hOverlay] else: hSpace = [hSpacing, hSpacing] if vOverlay > 0: vSpace = [vSpacing - vOverlay, vOverlay] else: vSpace = [vSpacing, vSpacing] count = 0 id = 1 # latitude lines count_max = bbox.height() / vSpacing count_update = count_max * 0.10 y = bbox.yMaximum() while y >= bbox.yMinimum(): if feedback.isCanceled(): break pt1 = QgsPoint(bbox.xMinimum(), y) pt2 = QgsPoint(bbox.xMaximum(), y) line = QgsLineString([pt1, pt2]) feat.setGeometry(QgsGeometry(line)) feat.setAttributes([bbox.xMinimum(), y, bbox.xMaximum(), y, id, y]) sink.addFeature(feat, QgsFeatureSink.FastInsert) y = y - vSpace[count % 2] id += 1 count += 1 if int(math.fmod(count, count_update)) == 0: feedback.setProgress(int(count / count_max * 50)) feedback.setProgress(50) # longitude lines # counters for progressbar - update every 5% count = 0 count_max = bbox.width() / hSpacing count_update = count_max * 0.10 x = bbox.xMinimum() while x <= bbox.xMaximum(): if feedback.isCanceled(): break pt1 = QgsPoint(x, bbox.yMaximum()) pt2 = QgsPoint(x, bbox.yMinimum()) line = QgsLineString([pt1, pt2]) feat.setGeometry(QgsGeometry(line)) feat.setAttributes([x, bbox.yMaximum(), x, bbox.yMinimum(), id, x]) sink.addFeature(feat, QgsFeatureSink.FastInsert) x = x + hSpace[count % 2] id += 1 count += 1 if int(math.fmod(count, count_update)) == 0: feedback.setProgress(50 + int(count / count_max * 50))
def do_operation(self): """ perform create mapping scheme operation """ # input/output verification already performed during set input/ouput fp_layer = self.inputs[0].value zone_field = self.inputs[1].value # aggregate footprint into grids logAPICall.log('aggregate statistic for grid ...', logAPICall.DEBUG) total_features = fp_layer.dataProvider().featureCount() if total_features > MAX_FEATURES_IN_MEMORY: # use bsddb to store temporary lat/lon tmp_db_file = '%sdb_%s.db' % (self._tmp_dir, get_unique_filename()) db = bsddb.btopen(tmp_db_file, 'c') use_db = True else: db = {} use_db = False zone_idx = layer_field_index(fp_layer, zone_field) for f in layer_features(fp_layer): geom = f.geometry() zone_str = str(f.attributeMap()[zone_idx].toString()) centroid = geom.centroid().asPoint() # use floor, this truncates all points within grid to grid's # bottom-left corner x = math.floor(centroid.x() / DEFAULT_GRID_SIZE) y = math.floor(centroid.y() / DEFAULT_GRID_SIZE) key = '%s %d %d' % (zone_str, x,y) if db.has_key(key): db[key] = str(int(db[key]) + 1) else: db[key] = '1' # output grid logAPICall.log('create grid ...', logAPICall.DEBUG) fields = { 0 : QgsField(self._lon_field, QVariant.Double), 1 : QgsField(self._lat_field, QVariant.Double), 2 : QgsField(CNT_FIELD_NAME, QVariant.Double), 3 : QgsField(zone_field, QVariant.String), } grid_layername = 'grid_%s' % get_unique_filename() grid_file = '%s%s.shp' % (self._tmp_dir, grid_layername) try: writer = QgsVectorFileWriter(grid_file, "utf-8", fields, QGis.WKBPoint , self._crs, "ESRI Shapefile") f = QgsFeature() for key, val in db.iteritems(): (zone_str, x, y) = key.split(' ') # point were aggregated to grid's bottom-left corner # add half grid size to place point at center of grid point = QgsPoint(int(x)*DEFAULT_GRID_SIZE+(DEFAULT_GRID_SIZE/2.0), int(y)*DEFAULT_GRID_SIZE+(DEFAULT_GRID_SIZE/2.0)) f.setGeometry(QgsGeometry.fromPoint(point)) f.addAttribute(0, QVariant(point.x())) f.addAttribute(1, QVariant(point.y())) f.addAttribute(2, QVariant(val)) f.addAttribute(3, QVariant(zone_str)) writer.addFeature(f) del writer except Exception as err: remove_shapefile(grid_file) raise OperatorError("error creating joined grid: " % err, self.__class__) grid_layer = load_shapefile(grid_file, grid_layername) if not grid_layer: raise OperatorError('Error loading created grid file' % (grid_file), self.__class__) # clean up if use_db: db.close() os.remove(tmp_db_file) # done self.outputs[0].value = grid_layer self.outputs[1].value = grid_file
def processAlgorithm(self, parameters, context, feedback): spacing = self.parameterAsDouble(parameters, self.SPACING, context) inset = self.parameterAsDouble(parameters, self.INSET, context) randomize = self.parameterAsBool(parameters, self.RANDOMIZE, context) isSpacing = self.parameterAsBool(parameters, self.IS_SPACING, context) crs = self.parameterAsCrs(parameters, self.CRS, context) extent = self.parameterAsExtent(parameters, self.EXTENT, context, crs) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, crs) if sink is None: raise QgsProcessingException( self.invalidSinkError(parameters, self.OUTPUT)) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 id = 0 total = 100.0 / (area / pSpacing) y = extent.yMaximum() - inset extent_geom = QgsGeometry.fromRect(extent) extent_engine = QgsGeometry.createGeometryEngine( extent_geom.constGet()) extent_engine.prepareGeometry() while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if feedback.isCanceled(): break if randomize: geom = QgsGeometry( QgsPoint( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)))) else: geom = QgsGeometry(QgsPoint(x, y)) if extent_engine.intersects(geom.constGet()): f.setAttributes([id]) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) x += pSpacing id += 1 count += 1 feedback.setProgress(int(count * total)) y = y - pSpacing return {self.OUTPUT: dest_id}
def snapGeometry(self, geometry, snapTolerance, mode=PreferNodes): """ Snaps a QgsGeometry in the reference layer :param geometry: QgsGeometry :param snapTolerance: float :param mode: DsgGeometrySnapper.PreferNodes or DsgGeometrySnapper.PreferClosest :return: """ center = QgsPointV2(geometry.boundingBox().center()) # Get potential reference features and construct snap index refGeometries = [] searchBounds = geometry.boundingBox() searchBounds.grow(snapTolerance) # filter by bounding box to get candidates refFeatureIds = self.index.intersects(searchBounds) # End here in case we don't find candidates if len(refFeatureIds) == 0: return geometry # speeding up the process to consider only intersecting geometries refFeatureRequest = QgsFeatureRequest().setFilterFids(refFeatureIds) for refFeature in self.referenceLayer.getFeatures(refFeatureRequest): refGeometry = refFeature.geometry() segments = self.breakQgsGeometryIntoSegments(refGeometry) # testing intersection for segment in segments: if segment.intersects(searchBounds): refGeometries.append(segment) # End here in case we don't find geometries if len(refGeometries) == 0: return geometry # building geometry index refDict, index = self.buildReferenceIndex(refGeometries) refSnapIndex = DsgSnapIndex(center, 10*snapTolerance) for geom in refGeometries: refSnapIndex.addGeometry(geom.geometry()) # Snap geometries subjGeom = geometry.geometry().clone() subjPointFlags = [] # Pass 1: snap vertices of subject geometry to reference vertices for iPart in xrange(subjGeom.partCount()): subjPointFlags.append([]) for iRing in xrange(subjGeom.ringCount(iPart)): subjPointFlags[iPart].append([]) for iVert in xrange(self.polyLineSize(subjGeom, iPart, iRing)): vidx = QgsVertexId(iPart, iRing, iVert, QgsVertexId.SegmentVertex) p = QgsPointV2(subjGeom.vertexAt(vidx)) pF = QgsPoint(p.toQPointF()) snapPoint, snapSegment = refSnapIndex.getSnapItem(p, snapTolerance) success = snapPoint or snapSegment if not success: subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.Unsnapped ) else: if mode == DsgGeometrySnapper.PreferNodes: # Prefer snapping to point if snapPoint: subjGeom.moveVertex(vidx, snapPoint.getSnapPoint(p)) subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefNode) elif snapSegment: subjGeom.moveVertex( vidx, snapSegment.getSnapPoint(p)) subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefSegment) elif mode == DsgGeometrySnapper.PreferClosest: nodeSnap = None segmentSnap = None distanceNode = sys.float_info.max distanceSegment = sys.float_info.max if snapPoint: nodeSnap = snapPoint.getSnapPoint(p) nodeSnapF = QgsPoint(nodeSnap.toQPointF()) distanceNode = nodeSnapF.sqrDist(pF) if snapSegment: segmentSnap = snapSegment.getSnapPoint(p) segmentSnapF = QgsPoint(segmentSnap.toQPointF()) distanceSegment = segmentSnapF.sqrDist(pF) if snapPoint and (distanceNode < distanceSegment): subjGeom.moveVertex( vidx, nodeSnap ) subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefNode) elif snapSegment: subjGeom.moveVertex(vidx, segmentSnap) subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefSegment) #nothing more to do for points if isinstance(subjGeom, QgsPointV2): return QgsGeometry(subjGeom) # SnapIndex for subject feature subjSnapIndex = DsgSnapIndex(center, 10*snapTolerance) subjSnapIndex.addGeometry(subjGeom) origSubjGeom = subjGeom.clone() origSubjSnapIndex = DsgSnapIndex(center, 10*snapTolerance) origSubjSnapIndex.addGeometry(origSubjGeom) # Pass 2: add missing vertices to subject geometry for refGeom in refGeometries: for iPart in xrange(refGeom.geometry().partCount()): for iRing in xrange(refGeom.geometry().ringCount(iPart)): for iVert in xrange(self.polyLineSize(refGeom.geometry(), iPart, iRing)): point = refGeom.geometry().vertexAt(QgsVertexId(iPart, iRing, iVert, QgsVertexId.SegmentVertex)) # QgsPoint used to calculate squared distance pointF = QgsPoint(point.toQPointF()) snapPoint, snapSegment = subjSnapIndex.getSnapItem(point, snapTolerance) success = snapPoint or snapSegment if success: # Snap to segment, unless a subject point was already snapped to the reference point if snapPoint and (QgsPoint(snapPoint.getSnapPoint(point).toQPointF()).sqrDist(pointF) < 1E-16): continue elif snapSegment: # Look if there is a closer reference segment, if so, ignore this point pProj = snapSegment.getSnapPoint(point) pProjF = QgsPoint(pProj.toQPointF()) closest = refSnapIndex.getClosestSnapToPoint(point, pProj) closestF = QgsPoint(closest.toQPointF()) if pProjF.sqrDist(pointF) > pProjF.sqrDist(closestF): continue # If we are too far away from the original geometry, do nothing if not origSubjSnapIndex.getSnapItem(point, snapTolerance): continue idx = snapSegment.idxFrom subjGeom.insertVertex(QgsVertexId(idx.vidx.part, idx.vidx.ring, idx.vidx.vertex + 1, QgsVertexId.SegmentVertex), point) subjPointFlags[idx.vidx.part][idx.vidx.ring].insert(idx.vidx.vertex + 1, DsgGeometrySnapper.SnappedToRefNode ) subjSnapIndex = DsgSnapIndex(center, 10*snapTolerance) subjSnapIndex.addGeometry(subjGeom) # Pass 3: remove superfluous vertices: all vertices which are snapped to a segment and not preceded or succeeded by an unsnapped vertex for iPart in xrange(subjGeom.partCount()): for iRing in xrange(subjGeom.ringCount(iPart)): ringIsClosed = subjGeom.vertexAt(QgsVertexId(iPart, iRing, 0, QgsVertexId.SegmentVertex)) == subjGeom.vertexAt(QgsVertexId(iPart, iRing, subjGeom.vertexCount( iPart, iRing ) - 1, QgsVertexId.SegmentVertex)) nVerts = self.polyLineSize(subjGeom, iPart, iRing) iVert = 0 while iVert < nVerts: iPrev = ( iVert - 1 + nVerts ) % nVerts iNext = ( iVert + 1 ) % nVerts pMid = subjGeom.vertexAt(QgsVertexId( iPart, iRing, iVert, QgsVertexId.SegmentVertex)) pPrev = subjGeom.vertexAt(QgsVertexId( iPart, iRing, iPrev, QgsVertexId.SegmentVertex)) pNext = subjGeom.vertexAt(QgsVertexId( iPart, iRing, iNext, QgsVertexId.SegmentVertex)) pointOnSeg = self.projPointOnSegment( pMid, pPrev, pNext) pointOnSegF = QgsPoint(pointOnSeg.toQPointF()) pMidF = QgsPoint(pMid.toQPointF()) dist = pointOnSegF.sqrDist(pMidF) if subjPointFlags[iPart][iRing][iVert] == DsgGeometrySnapper.SnappedToRefSegment \ and subjPointFlags[iPart][iRing][iPrev] != DsgGeometrySnapper.Unsnapped \ and subjPointFlags[iPart][iRing][iNext] != DsgGeometrySnapper.Unsnapped \ and dist < 1E-12: if (ringIsClosed and nVerts > 3 ) or ( not ringIsClosed and nVerts > 2 ): subjGeom.deleteVertex(QgsVertexId(iPart, iRing, iVert, QgsVertexId.SegmentVertex)) del subjPointFlags[iPart][iRing][iVert] iVert -= 1 nVerts -= 1 else: # Don't delete vertices if this would result in a degenerate geometry break iVert += 1 return QgsGeometry(subjGeom)
def setUp(self): self.mPoint = QgsPoint(10.0, 10.0)
def UpdateBeamsData(packet, cornerPointUL, cornerPointUR, cornerPointLR, cornerPointLL, ele): ''' Update Beams Values ''' lat = packet.SensorLatitude lon = packet.SensorLongitude alt = packet.SensorTrueAltitude beamsLyr = qgsu.selectLayerByName(Beams_lyr) try: if all(v is not None for v in [ beamsLyr, lat, lon, alt, cornerPointUL, cornerPointUR, cornerPointLR, cornerPointLL ]) and all(v >= 2 for v in [ len(cornerPointUL), len(cornerPointUR), len(cornerPointLR), len(cornerPointLL) ]): beamsLyr.startEditing() if beamsLyr.featureCount() == 0: # UL featureUL = QgsFeature() featureUL.setAttributes( [lon, lat, alt, cornerPointUL[1], cornerPointUL[0]]) featureUL.setGeometry( QgsLineString(QgsPoint(lon, lat, alt), QgsPoint(cornerPointUL[1], cornerPointUL[0]))) beamsLyr.addFeatures([featureUL]) # UR featureUR = QgsFeature() featureUR.setAttributes( [lon, lat, alt, cornerPointUR[1], cornerPointUR[0]]) featureUR.setGeometry( QgsLineString(QgsPoint(lon, lat, alt), QgsPoint(cornerPointUR[1], cornerPointUR[0]))) beamsLyr.addFeatures([featureUR]) # LR featureLR = QgsFeature() featureLR.setAttributes( [lon, lat, alt, cornerPointLR[1], cornerPointLR[0]]) featureLR.setGeometry( QgsLineString(QgsPoint(lon, lat, alt), QgsPoint(cornerPointLR[1], cornerPointLR[0]))) beamsLyr.addFeatures([featureLR]) # LL featureLL = QgsFeature() featureLL.setAttributes( [lon, lat, alt, cornerPointLL[1], cornerPointLL[0]]) featureLL.setGeometry( QgsLineString(QgsPoint(lon, lat, alt), QgsPoint(cornerPointLL[1], cornerPointLL[0]))) beamsLyr.addFeatures([featureLL]) else: # UL beamsLyr.dataProvider().changeAttributeValues({ 1: { 0: lon, 1: lat, 2: alt, 3: cornerPointUL[1], 4: cornerPointUL[0] } }) beamsLyr.dataProvider().changeGeometryValues({ 1: QgsGeometry( QgsLineString( QgsPoint(lon, lat, alt), QgsPoint(cornerPointUL[1], cornerPointUL[0]))) }) # UR beamsLyr.dataProvider().changeAttributeValues({ 2: { 0: lon, 1: lat, 2: alt, 3: cornerPointUR[1], 4: cornerPointUR[0] } }) beamsLyr.dataProvider().changeGeometryValues({ 2: QgsGeometry( QgsLineString( QgsPoint(lon, lat, alt), QgsPoint(cornerPointUR[1], cornerPointUR[0]))) }) # LR beamsLyr.dataProvider().changeAttributeValues({ 3: { 0: lon, 1: lat, 2: alt, 3: cornerPointLR[1], 4: cornerPointLR[0] } }) beamsLyr.dataProvider().changeGeometryValues({ 3: QgsGeometry( QgsLineString( QgsPoint(lon, lat, alt), QgsPoint(cornerPointLR[1], cornerPointLR[0]))) }) # LL beamsLyr.dataProvider().changeAttributeValues({ 4: { 0: lon, 1: lat, 2: alt, 3: cornerPointLL[1], 4: cornerPointLL[0] } }) beamsLyr.dataProvider().changeGeometryValues({ 4: QgsGeometry( QgsLineString( QgsPoint(lon, lat, alt), QgsPoint(cornerPointLL[1], cornerPointLL[0]))) }) CommonLayer(beamsLyr) # 3D Style if ele: SetDefaultBeams3DStyle(beamsLyr) except Exception as e: qgsu.showUserAndLogMessage( QCoreApplication.translate("QgsFmvUtils", "Failed Update Beams Layer! : "), str(e)) return
def processAlgorithm(self, feedback): radius = self.getParameterValue(self.DISTANCE) horizontal = self.getParameterValue(self.HORIZONTAL) output = self.getOutputFromName(self.OUTPUT_LAYER) layer = dataobjects.getLayerFromString( self.getParameterValue(self.INPUT_LAYER)) writer = output.getVectorWriter(layer.fields(), layer.wkbType(), layer.crs()) features = vector.features(layer) total = 100.0 / len(features) duplicates = dict() for current, f in enumerate(features): wkt = f.geometry().exportToWkt() if wkt not in duplicates: duplicates[wkt] = [f.id()] else: duplicates[wkt].extend([f.id()]) feedback.setProgress(int(current * total)) current = 0 total = 100.0 / len(duplicates) feedback.setProgress(0) fullPerimeter = 2 * math.pi for (geom, fids) in list(duplicates.items()): count = len(fids) if count == 1: f = next( layer.getFeatures(QgsFeatureRequest().setFilterFid( fids[0]))) writer.addFeature(f) else: angleStep = fullPerimeter / count if count == 2 and horizontal: currentAngle = math.pi / 2 else: currentAngle = 0 old_point = QgsGeometry.fromWkt(geom).asPoint() request = QgsFeatureRequest().setFilterFids(fids).setFlags( QgsFeatureRequest.NoGeometry) for f in layer.getFeatures(request): sinusCurrentAngle = math.sin(currentAngle) cosinusCurrentAngle = math.cos(currentAngle) dx = radius * sinusCurrentAngle dy = radius * cosinusCurrentAngle new_point = QgsPoint(old_point.x() + dx, old_point.y() + dy) out_feature = QgsFeature() out_feature.setGeometry(QgsGeometry.fromPoint(new_point)) out_feature.setAttributes(f.attributes()) writer.addFeature(out_feature) currentAngle += angleStep current += 1 feedback.setProgress(int(current * total)) del writer
def testQgsLineStringRepr(self): ls = QgsLineString([QgsPoint(10, 2), QgsPoint(10, 1), QgsPoint(5, 1)]) self.assertEqual(ls.__repr__(), '<QgsLineString: LineString (10 2, 10 1, 5 1)>')
def testLengthMeasureAndUnits(self): """Test a variety of length measurements in different CRS and ellipsoid modes, to check that the calculated lengths and units are always consistent """ da = QgsDistanceArea() da.setSourceCrs(3452) da.setEllipsoidalMode(False) da.setEllipsoid("NONE") daCRS = QgsCoordinateReferenceSystem() daCRS = da.sourceCrs() # We check both the measured length AND the units, in case the logic regarding # ellipsoids and units changes in future distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3)) units = da.lengthUnits() print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))) assert ((abs(distance - 2.23606797) < 0.00000001 and units == QgsUnitTypes.DistanceDegrees) or (abs(distance - 248.52) < 0.01 and units == QgsUnitTypes.DistanceMeters)) da.setEllipsoid("WGS84") distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3)) units = da.lengthUnits() print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))) assert ((abs(distance - 2.23606797) < 0.00000001 and units == QgsUnitTypes.DistanceDegrees) or (abs(distance - 248.52) < 0.01 and units == QgsUnitTypes.DistanceMeters)) da.setEllipsoidalMode(True) distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3)) units = da.lengthUnits() print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))) # should always be in Meters self.assertAlmostEqual(distance, 247555.57, delta=0.01) self.assertEqual(units, QgsUnitTypes.DistanceMeters) # test converting the resultant length distance = da.convertLengthMeasurement( distance, QgsUnitTypes.DistanceNauticalMiles) self.assertAlmostEqual(distance, 133.669, delta=0.01) # now try with a source CRS which is in feet da.setSourceCrs(27469) da.setEllipsoidalMode(False) # measurement should be in feet distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3)) units = da.lengthUnits() print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))) self.assertAlmostEqual(distance, 2.23606797, delta=0.000001) self.assertEqual(units, QgsUnitTypes.DistanceFeet) # test converting the resultant length distance = da.convertLengthMeasurement(distance, QgsUnitTypes.DistanceMeters) self.assertAlmostEqual(distance, 0.6815, delta=0.001) da.setEllipsoidalMode(True) # now should be in Meters again distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3)) units = da.lengthUnits() print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))) self.assertAlmostEqual(distance, 0.67953772, delta=0.000001) self.assertEqual(units, QgsUnitTypes.DistanceMeters) # test converting the resultant length distance = da.convertLengthMeasurement(distance, QgsUnitTypes.DistanceFeet) self.assertAlmostEqual(distance, 2.2294, delta=0.001)
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.VECTOR)) fieldName = self.getParameterValue(self.FIELD) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) strategy = self.getParameterValue(self.STRATEGY) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, layer.crs()) da = QgsDistanceArea() features = vector.features(layer) for current, f in enumerate(features): fGeom = f.geometry() bbox = fGeom.boundingBox() if strategy == 0: pointCount = int(f[fieldName]) else: pointCount = int(round(f[fieldName] * da.measureArea(fGeom))) if strategy == 0 and pointCount == 0: continue index = QgsSpatialIndex() points = dict() nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount random.seed() while nIterations < maxIterations and nPoints < pointCount: rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() pnt = QgsPoint(rx, ry) geom = QgsGeometry.fromPoint(pnt) if geom.within(fGeom) and \ vector.checkMinDistance(pnt, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 progress.setPercentage(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: ProcessingLog.addToLog( ProcessingLog.LOG_INFO, self.tr('Can not generate requested number of random ' 'points. Maximum number of attempts exceeded.')) progress.setPercentage(0) del writer
def processAlgorithm(self, feedback): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.INPUT_VECTOR)) startPoint = self.getParameterValue(self.START_POINT) endPoint = self.getParameterValue(self.END_POINT) strategy = self.getParameterValue(self.STRATEGY) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) fields = QgsFields() fields.append(QgsField('start', QVariant.String, '', 254, 0)) fields.append(QgsField('end', QVariant.String, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 20, 7)) writer = self.getOutputFromName( self.OUTPUT_LAYER).getVectorWriter( fields.toList(), QgsWkbTypes.LineString, layer.crs()) tmp = startPoint.split(',') startPoint = QgsPoint(float(tmp[0]), float(tmp[1])) tmp = endPoint.split(',') endPoint = QgsPoint(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) multiplier = 3600 director.addStrategy(strategy) builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(), iface.mapCanvas().hasCrsTransformEnabled(), tolerance) feedback.pushInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, [startPoint, endPoint]) feedback.pushInfo(self.tr('Calculating shortest path...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) idxEnd = graph.findVertex(snappedPoints[1]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) if tree[idxEnd] == -1: raise GeoAlgorithmExecutionException( self.tr('There is no route from start point to end point.')) route = [] cost = 0.0 current = idxEnd while current != idxStart: cost += graph.edge(tree[current]).cost(0) route.append(graph.vertex(graph.edge(tree[current]).inVertex()).point()) current = graph.edge(tree[current]).outVertex() route.append(snappedPoints[0]) route.reverse() self.setOutputValue(self.TRAVEL_COST, cost / multiplier) feedback.pushInfo(self.tr('Writing results...')) geom = QgsGeometry.fromPolyline(route) feat = QgsFeature() feat.setFields(fields) feat['start'] = startPoint.toString() feat['end'] = endPoint.toString() feat['cost'] = cost / multiplier feat.setGeometry(geom) writer.addFeature(feat) del writer
def testAreaMeasureAndUnits(self): """Test a variety of area measurements in different CRS and ellipsoid modes, to check that the calculated areas and units are always consistent """ da = QgsDistanceArea() da.setSourceCrs(3452) da.setEllipsoidalMode(False) da.setEllipsoid("NONE") daCRS = QgsCoordinateReferenceSystem() daCRS = da.sourceCrs() polygon = QgsGeometry.fromPolygon([[ QgsPoint(0, 0), QgsPoint(1, 0), QgsPoint(1, 1), QgsPoint(2, 1), QgsPoint(2, 2), QgsPoint(0, 2), QgsPoint(0, 0), ]]) # We check both the measured area AND the units, in case the logic regarding # ellipsoids and units changes in future area = da.measureArea(polygon) units = da.areaUnits() print(("measured {} in {}".format(area, QgsUnitTypes.toString(units)))) assert ((abs(area - 3.0) < 0.00000001 and units == QgsUnitTypes.AreaSquareDegrees) or (abs(area - 37176087091.5) < 0.1 and units == QgsUnitTypes.AreaSquareMeters)) da.setEllipsoid("WGS84") area = da.measureArea(polygon) units = da.areaUnits() print(("measured {} in {}".format(area, QgsUnitTypes.toString(units)))) assert ((abs(area - 3.0) < 0.00000001 and units == QgsUnitTypes.AreaSquareDegrees) or (abs(area - 37176087091.5) < 0.1 and units == QgsUnitTypes.AreaSquareMeters)) da.setEllipsoidalMode(True) area = da.measureArea(polygon) units = da.areaUnits() print(("measured {} in {}".format(area, QgsUnitTypes.toString(units)))) # should always be in Meters Squared self.assertAlmostEqual(area, 37416879192.9, delta=0.1) self.assertEqual(units, QgsUnitTypes.AreaSquareMeters) # test converting the resultant area area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareMiles) self.assertAlmostEqual(area, 14446.7378, delta=0.001) # now try with a source CRS which is in feet polygon = QgsGeometry.fromPolygon([[ QgsPoint(1850000, 4423000), QgsPoint(1851000, 4423000), QgsPoint(1851000, 4424000), QgsPoint(1852000, 4424000), QgsPoint(1852000, 4425000), QgsPoint(1851000, 4425000), QgsPoint(1850000, 4423000) ]]) da.setSourceCrs(27469) da.setEllipsoidalMode(False) # measurement should be in square feet area = da.measureArea(polygon) units = da.areaUnits() print(("measured {} in {}".format(area, QgsUnitTypes.toString(units)))) self.assertAlmostEqual(area, 2000000, delta=0.001) self.assertEqual(units, QgsUnitTypes.AreaSquareFeet) # test converting the resultant area area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards) self.assertAlmostEqual(area, 222222.2222, delta=0.001) da.setEllipsoidalMode(True) # now should be in Square Meters again area = da.measureArea(polygon) units = da.areaUnits() print(("measured {} in {}".format(area, QgsUnitTypes.toString(units)))) self.assertAlmostEqual(area, 184149.37, delta=1.0) self.assertEqual(units, QgsUnitTypes.AreaSquareMeters) # test converting the resultant area area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards) self.assertAlmostEqual(area, 220240.8172549, delta=1.0)