def testInteger64WriteTabfile(self): """Check writing Integer64 fields to an MapInfo tabfile (which does not support that type).""" ml = QgsVectorLayer(("Point?crs=epsg:4326&field=int8:int8"), "test", "memory") self.assertIsNotNone(ml, "Provider not initialized") self.assertTrue(ml.isValid(), "Source layer not valid") provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setAttributes([2123456789]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) dest_file_name = os.path.join(str(QDir.tempPath()), "integer64.tab") crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat(ml, dest_file_name, "utf-8", crs, "MapInfo File") self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer = QgsVectorLayer("{}|layerid=0".format(dest_file_name), "test", "ogr") fields = created_layer.dataProvider().fields() self.assertEqual(fields.at(fields.indexFromName("int8")).type(), QVariant.Double) f = next(created_layer.getFeatures(QgsFeatureRequest())) int8_idx = created_layer.fields().lookupField("int8") self.assertEqual(f.attributes()[int8_idx], 2123456789)
def extent_to_geoarray(extent, source_crs): """Convert the supplied extent to geographic and return as as array. :param extent: QgsRectangle to be transformed to geocrs. :type extent: :param source_crs: QgsCoordinateReferenceSystem representing the original extent's CRS. :type source_crs: :returns: Transformed extents in EPSG:4326 in the form [xmin, ymin, xmax, ymax] """ myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform( source_crs, myGeoCrs) # Get the clip area in the layer's crs myTransformedExtent = myXForm.transformBoundingBox(extent) myGeoExtent = [myTransformedExtent.xMinimum(), myTransformedExtent.yMinimum(), myTransformedExtent.xMaximum(), myTransformedExtent.yMaximum()] return myGeoExtent
def extentToGeoArray(theExtent, theSourceCrs): """Convert the supplied extent to geographic and return as as array. Args: theExtent: QgsRectangle to be transformed to geocrs. theSourceCrs: QgsCoordinateReferenceSystem representing the original extent's CRS. Returns: list: Transformed extents in EPSG:4326 in the form [xmin, ymin, xmix, ymax] Raises: None """ myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform( theSourceCrs, myGeoCrs) # Get the clip area in the layer's crs myTransformedExtent = myXForm.transformBoundingBox(theExtent) myGeoExtent = [myTransformedExtent.xMinimum(), myTransformedExtent.yMinimum(), myTransformedExtent.xMaximum(), myTransformedExtent.yMaximum()] return myGeoExtent
def processCommand(alg): # Creates a new location with the CRS crsParam = alg.getParameterFromName('crs') crsId = int(crsParam.value[5:]) #QgsMessageLog.logMessage('crs = {}'.format(crs), 'DEBUG', QgsMessageLog.INFO) crs = QgsCoordinateReferenceSystem() crs.createFromId(crsId, QgsCoordinateReferenceSystem.EpsgCrsId) command = "g.proj proj4=\"{}\" location=TARGET".format(crs.toProj4()) alg.commands.append(command) alg.parameters.remove(crsParam) # Regroup rasters rasters = alg.getParameterFromName('rasters') rastersList = rasters.value.split(';') alg.parameters.remove(rasters) # Insert a i.group command group = getParameterFromString("ParameterString|group|group of rasters|None|False|False") group.value = alg.getTempFilename() alg.addParameter(group) command = 'i.group group={} input={}'.format( group.value, ','.join([alg.exportedLayers[f] for f in rastersList]) ) alg.commands.append(command) # Handle POINT File gcp = alg.getParameterFromName('gcp') extFileName = gcp.value destPath = path.join(Grass7Utils.grassMapsetFolder(), 'PERMANENT', 'group', group.value, 'POINTS') copyFile(alg, extFileName, destPath) alg.parameters.remove(gcp) # Add a target destination for our group command = "i.target group={} location=TARGET mapset=PERMANENT".format(group.value) alg.commands.append(command) # remove output output = alg.getOutputFromName('output') alg.removeOutputFromName('output') # Add an extension #extension = getParameterFromString("ParameterString|extension|Output raster map(s) suffix|None|False|False") #extension.value = "rectified" #alg.addParameter(extension) # modify parameters values alg.processCommand() # Re-add input rasters alg.addParameter(rasters) alg.addParameter(gcp) alg.addParameter(crs) # Re-add output alg.addOutput(output)
def testWriteShapefileWithMultiConversion(self): """Check writing geometries to an ESRI shapefile with conversion to multi.""" ml = QgsVectorLayer(("Point?crs=epsg:4326&field=id:int"), "test", "memory") self.assertIsNotNone(ml, "Provider not initialized") self.assertTrue(ml.isValid(), "Source layer not valid") provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromWkt("Point (1 2)")) ft.setAttributes([1]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) dest_file_name = os.path.join(str(QDir.tempPath()), "to_multi.shp") crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, "utf-8", crs, "ESRI Shapefile", forceMulti=True ) self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer = QgsVectorLayer("{}|layerid=0".format(dest_file_name), "test", "ogr") f = next(created_layer.getFeatures(QgsFeatureRequest())) g = f.geometry() wkt = g.exportToWkt() expWkt = "MultiPoint ((1 2))" self.assertTrue( compareWkt(expWkt, wkt), "saving geometry with multi conversion failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt), )
def extent_to_geo_array(extent, source_crs): """Convert the supplied extent to geographic and return as an array. :param extent: Rectangle defining a spatial extent in any CRS. :type extent: QgsRectangle :param source_crs: Coordinate system used for extent. :type source_crs: QgsCoordinateReferenceSystem :returns: a list in the form [xmin, ymin, xmax, ymax] where all coordinates provided are in Geographic / EPSG:4326. :rtype: list """ myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform(source_crs, myGeoCrs) # Get the clip area in the layer's crs myTransformedExtent = myXForm.transformBoundingBox(extent) myGeoExtent = [myTransformedExtent.xMinimum(), myTransformedExtent.yMinimum(), myTransformedExtent.xMaximum(), myTransformedExtent.yMaximum()] return myGeoExtent
def testDateTimeWriteShapefile(self): """Check writing date and time fields to an ESRI shapefile.""" ml = QgsVectorLayer( ('Point?crs=epsg:4326&field=id:int&' 'field=date_f:date&field=time_f:time&field=dt_f:datetime'), 'test', 'memory') assert ml is not None, 'Provider not initialized' assert ml.isValid(), 'Source layer not valid' provider = ml.dataProvider() assert provider is not None ft = QgsFeature() ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10))) ft.setAttributes([1, QDate(2014, 3, 5), QTime(13, 45, 22), QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))]) res, features = provider.addFeatures([ft]) assert res assert len(features) > 0 dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp') print(dest_file_name) crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile') self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr') fields = created_layer.dataProvider().fields() self.assertEqual(fields.at(fields.indexFromName('date_f')).type(), QVariant.Date) #shapefiles do not support time types, result should be string self.assertEqual(fields.at(fields.indexFromName('time_f')).type(), QVariant.String) #shapefiles do not support datetime types, result should be string self.assertEqual(fields.at(fields.indexFromName('dt_f')).type(), QVariant.String) f = created_layer.getFeatures(QgsFeatureRequest()).next() date_idx = created_layer.fieldNameIndex('date_f') assert isinstance(f.attributes()[date_idx], QDate) self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5)) time_idx = created_layer.fieldNameIndex('time_f') #shapefiles do not support time types assert isinstance(f.attributes()[time_idx], basestring) self.assertEqual(f.attributes()[time_idx], '13:45:22') #shapefiles do not support datetime types datetime_idx = created_layer.fieldNameIndex('dt_f') assert isinstance(f.attributes()[datetime_idx], basestring) self.assertEqual(f.attributes()[datetime_idx], QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)).toString("yyyy/MM/dd hh:mm:ss.zzz"))
def zoomToAddress(self): # get x,y from data of record self.removePointer() data = self.dlg.geocoderResultView.selectedIndexes()[0].data(Qt.UserRole) if 'centroide_rd' in data: # free OR lookup service geom = QgsGeometry.fromWkt(data['centroide_rd']) adrestekst = data['adrestekst'] else: # no centroid yet, probably only object id, retrieve it via lookup service id = data['id'] data = self.pdokgeocoder.lookup(id) geom = QgsGeometry.fromWkt(data['centroide_rd']) adrestekst = data['adrestekst'] lookup_data= data['data'] lis = '' for key in lookup_data.keys(): lis = lis + '<li>{}: {}</li>'.format(key, lookup_data[key]) self.dlg.ui.lookupinfo.setHtml( '<h4>{}</h4><lu>{}</lu>'.format(adrestekst, lis)) # just always transform from 28992 to mapcanvas crs crs = self.iface.mapCanvas().mapSettings().destinationCrs() crs28992 = QgsCoordinateReferenceSystem() crs28992.createFromId(28992) crsTransform = QgsCoordinateTransform(crs28992, crs, QgsProject.instance()) z = 1587 if adrestekst.lower().startswith('adres'): z = 794 elif adrestekst.lower().startswith('perceel'): z = 794 elif adrestekst.lower().startswith('hectometer'): z = 1587 elif adrestekst.lower().startswith('straat'): z = 3175 elif adrestekst.lower().startswith('postcode'): z = 6350 elif adrestekst.lower().startswith('woonplaats'): z = 25398 elif adrestekst.lower().startswith('gemeente'): z = 50797 elif adrestekst.lower().startswith('provincie'): z = 812750 geom.transform(crsTransform) center = geom.asPoint() self.setPointer(center) # zoom to with center is actually setting a point rectangle and then zoom rect = QgsRectangle(center, center) self.iface.mapCanvas().setExtent(rect) self.iface.mapCanvas().zoomScale(z) self.iface.mapCanvas().refresh()
def testDateTimeWriteShapefile(self): """Check writing date and time fields to an ESRI shapefile.""" ml = QgsVectorLayer( ("Point?crs=epsg:4326&field=id:int&" "field=date_f:date&field=time_f:time&field=dt_f:datetime"), "test", "memory", ) assert ml is not None, "Provider not initialised" assert ml.isValid(), "Source layer not valid" provider = ml.dataProvider() assert provider is not None ft = QgsFeature() ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10))) ft.setAttributes( [1, QDate(2014, 0o3, 0o5), QTime(13, 45, 22), QDateTime(QDate(2014, 0o3, 0o5), QTime(13, 45, 22))] ) res, features = provider.addFeatures([ft]) assert res assert len(features) > 0 dest_file_name = os.path.join(str(QDir.tempPath()), "datetime.shp") print(dest_file_name) crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat(ml, dest_file_name, "utf-8", crs, "ESRI Shapefile") self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer = QgsVectorLayer(u"{}|layerid=0".format(dest_file_name), u"test", u"ogr") fields = created_layer.dataProvider().fields() self.assertEqual(fields.at(fields.indexFromName("date_f")).type(), QVariant.Date) # shapefiles do not support time types, result should be string self.assertEqual(fields.at(fields.indexFromName("time_f")).type(), QVariant.String) # shapefiles do not support datetime types, result should be date self.assertEqual(fields.at(fields.indexFromName("dt_f")).type(), QVariant.Date) f = created_layer.getFeatures(QgsFeatureRequest()).next() date_idx = created_layer.fieldNameIndex("date_f") assert isinstance(f.attributes()[date_idx], QDate) self.assertEqual(f.attributes()[date_idx], QDate(2014, 0o3, 0o5)) time_idx = created_layer.fieldNameIndex("time_f") # shapefiles do not support time types assert isinstance(f.attributes()[time_idx], basestring) self.assertEqual(f.attributes()[time_idx], "13:45:22") # shapefiles do not support datetime types datetime_idx = created_layer.fieldNameIndex("dt_f") assert isinstance(f.attributes()[datetime_idx], QDate) self.assertEqual(f.attributes()[datetime_idx], QDate(2014, 0o3, 0o5))
def testDateTimeWriteShapefile(self): """Check writing date and time fields to an ESRI shapefile.""" ml = QgsVectorLayer( ("Point?crs=epsg:4326&field=id:int&" "field=date_f:date&field=time_f:time&field=dt_f:datetime"), "test", "memory", ) self.assertTrue(ml.isValid()) provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10))) ft.setAttributes([1, QDate(2014, 3, 5), QTime(13, 45, 22), QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) dest_file_name = os.path.join(str(QDir.tempPath()), "datetime.shp") crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat(ml, dest_file_name, "utf-8", crs, "ESRI Shapefile") self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer = QgsVectorLayer("{}|layerid=0".format(dest_file_name), "test", "ogr") fields = created_layer.dataProvider().fields() self.assertEqual(fields.at(fields.indexFromName("date_f")).type(), QVariant.Date) # shapefiles do not support time types, result should be string self.assertEqual(fields.at(fields.indexFromName("time_f")).type(), QVariant.String) # shapefiles do not support datetime types, result should be string self.assertEqual(fields.at(fields.indexFromName("dt_f")).type(), QVariant.String) f = next(created_layer.getFeatures(QgsFeatureRequest())) date_idx = created_layer.fields().lookupField("date_f") self.assertIsInstance(f.attributes()[date_idx], QDate) self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5)) time_idx = created_layer.fields().lookupField("time_f") # shapefiles do not support time types self.assertIsInstance(f.attributes()[time_idx], str) self.assertEqual(f.attributes()[time_idx], "13:45:22") # shapefiles do not support datetime types datetime_idx = created_layer.fields().lookupField("dt_f") self.assertIsInstance(f.attributes()[datetime_idx], str) self.assertEqual( f.attributes()[datetime_idx], QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)).toString("yyyy/MM/dd hh:mm:ss.zzz"), )
def testDateTimeWriteTabfile(self): """Check writing date and time fields to an MapInfo tabfile.""" ml = QgsVectorLayer( ('Point?crs=epsg:4326&field=id:int&' 'field=date_f:date&field=time_f:time&field=dt_f:datetime'), 'test', 'memory') self.assertIsNotNone(ml, 'Provider not initialized') self.assertTrue(ml.isValid(), 'Source layer not valid') provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(10, 10))) ft.setAttributes([1, QDate(2014, 3, 5), QTime(13, 45, 22), QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.tab') crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'MapInfo File') self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') fields = created_layer.dataProvider().fields() self.assertEqual(fields.at(fields.indexFromName('date_f')).type(), QVariant.Date) self.assertEqual(fields.at(fields.indexFromName('time_f')).type(), QVariant.Time) self.assertEqual(fields.at(fields.indexFromName('dt_f')).type(), QVariant.DateTime) f = next(created_layer.getFeatures(QgsFeatureRequest())) date_idx = created_layer.fields().lookupField('date_f') self.assertIsInstance(f.attributes()[date_idx], QDate) self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5)) time_idx = created_layer.fields().lookupField('time_f') self.assertIsInstance(f.attributes()[time_idx], QTime) self.assertEqual(f.attributes()[time_idx], QTime(13, 45, 22)) datetime_idx = created_layer.fields().lookupField('dt_f') self.assertIsInstance(f.attributes()[datetime_idx], QDateTime) self.assertEqual(f.attributes()[datetime_idx], QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)))
def testTransformBoundingBox(self): """Test that we can transform a rectangular bbox from utm56s to LonLat""" myExtent = QgsRectangle(242270, 6043737, 246330, 6045897) myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myUtmCrs = QgsCoordinateReferenceSystem() myUtmCrs.createFromId(32756, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform(myUtmCrs, myGeoCrs) myProjectedExtent = myXForm.transformBoundingBox(myExtent) myExpectedExtent = ('150.1509239873580270,-35.7176936443908772 : ' '150.1964384662953194,-35.6971885216629090') myMessage = ('Expected:\n%s\nGot:\n%s\n' % ( myExpectedExtent, myProjectedExtent.toString())) self.assertEquals(myExpectedExtent, myProjectedExtent.toString(), myMessage)
def set_destination_coordinate_system(self, srid_val): """ :return: """ spRef = QgsCoordinateReferenceSystem() return spRef.createFromId(srid_val)
def default_coordinate_system(self): """ Create the default google projection returns a projection :return:Projection """ spRef = QgsCoordinateReferenceSystem() return spRef.createFromId(4326)
def testTransformBoundingBox(self): """Test that we can transform a rectangular bbox from utm56s to LonLat""" myExtent = QgsRectangle(242270, 6043737, 246330, 6045897) myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myUtmCrs = QgsCoordinateReferenceSystem() myUtmCrs.createFromId(32756, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform(myUtmCrs, myGeoCrs) myProjectedExtent = myXForm.transformBoundingBox(myExtent) myExpectedExtent = "150.1509239873580270,-35.7176936443908772 : " "150.1964384662953194,-35.6971885216629090" myExpectedValues = [150.1509239873580270, -35.7176936443908772, 150.1964384662953194, -35.6971885216629090] myMessage = "Expected:\n%s\nGot:\n%s\n" % (myExpectedExtent, myProjectedExtent.toString()) self.assertAlmostEqual(myExpectedValues[0], myProjectedExtent.xMinimum(), msg=myMessage) self.assertAlmostEqual(myExpectedValues[1], myProjectedExtent.yMinimum(), msg=myMessage) self.assertAlmostEqual(myExpectedValues[2], myProjectedExtent.xMaximum(), msg=myMessage) self.assertAlmostEqual(myExpectedValues[3], myProjectedExtent.yMaximum(), msg=myMessage)
def testDateTimeWriteTabfile(self): """Check writing date and time fields to an MapInfo tabfile.""" ml = QgsVectorLayer( ("Point?crs=epsg:4326&field=id:int&" "field=date_f:date&field=time_f:time&field=dt_f:datetime"), "test", "memory", ) self.assertIsNotNone(ml, "Provider not initialized") self.assertTrue(ml.isValid(), "Source layer not valid") provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10))) ft.setAttributes([1, QDate(2014, 3, 5), QTime(13, 45, 22), QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) dest_file_name = os.path.join(str(QDir.tempPath()), "datetime.tab") crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat(ml, dest_file_name, "utf-8", crs, "MapInfo File") self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer = QgsVectorLayer("{}|layerid=0".format(dest_file_name), "test", "ogr") fields = created_layer.dataProvider().fields() self.assertEqual(fields.at(fields.indexFromName("date_f")).type(), QVariant.Date) self.assertEqual(fields.at(fields.indexFromName("time_f")).type(), QVariant.Time) self.assertEqual(fields.at(fields.indexFromName("dt_f")).type(), QVariant.DateTime) f = next(created_layer.getFeatures(QgsFeatureRequest())) date_idx = created_layer.fields().lookupField("date_f") self.assertIsInstance(f.attributes()[date_idx], QDate) self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5)) time_idx = created_layer.fields().lookupField("time_f") self.assertIsInstance(f.attributes()[time_idx], QTime) self.assertEqual(f.attributes()[time_idx], QTime(13, 45, 22)) datetime_idx = created_layer.fields().lookupField("dt_f") self.assertIsInstance(f.attributes()[datetime_idx], QDateTime) self.assertEqual(f.attributes()[datetime_idx], QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)))
def setCanvasCrs(theEpsgId, theOtfpFlag=False): """Helper to set the crs for the CANVAS before a test is run. Args: * theEpsgId - Valid EPSG identifier (int) * theOtfpFlag - whether on the fly projections should be enabled on the CANVAS. Default to False. """ # Enable on-the-fly reprojection CANVAS.mapRenderer().setProjectionsEnabled(theOtfpFlag) # Create CRS Instance myCrs = QgsCoordinateReferenceSystem() myCrs.createFromId(theEpsgId, QgsCoordinateReferenceSystem.E) # Reproject all layers to WGS84 geographic CRS CANVAS.mapRenderer().setDestinationCrs(myCrs)
def getWGS84resolution(layer): """Return resolution of raster layer in EPSG:4326. If input layer is already in EPSG:4326, simply return the resolution If not, work it out based on EPSG:4326 representations of its extent. :param layer: Raster layer :type layer: QgsRasterLayer :returns: The resolution of the given layer. :rtype: float """ msg = tr( 'Input layer to getWGS84resolution must be a raster layer. ' 'I got: %s' % str(layer.type())[1:-1]) if not layer.type() == QgsMapLayer.RasterLayer: raise RuntimeError(msg) if layer.crs().authid() == 'EPSG:4326': # If it is already in EPSG:4326, simply use the native resolution if qgis_version() > 10800: myCellSize = layer.rasterUnitsPerPixelX() else: myCellSize = layer.rasterUnitsPerPixel() else: # Otherwise, work it out based on EPSG:4326 representations of # its extent # Reproject extent to EPSG:4326 myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform(layer.crs(), myGeoCrs) myExtent = layer.extent() myProjectedExtent = myXForm.transformBoundingBox(myExtent) # Estimate cell size myColumns = layer.width() myGeoWidth = abs(myProjectedExtent.xMaximum() - myProjectedExtent.xMinimum()) myCellSize = myGeoWidth / myColumns return myCellSize
def testWrite(self): """Check we can write a vector file.""" self.mMemoryLayer = QgsVectorLayer( ('Point?crs=epsg:4326&field=name:string(20)&' 'field=age:integer&field=size:double&index=yes'), 'test', 'memory') assert self.mMemoryLayer is not None, 'Provider not initialised' myProvider = self.mMemoryLayer.dataProvider() assert myProvider is not None ft = QgsFeature() ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10,10))) ft.setAttributeMap({0 : QVariant('Johny'), 1 : QVariant(20), 2 : QVariant(0.3)}) myResult, myFeatures = myProvider.addFeatures([ft]) assert myResult == True assert len(myFeatures) > 0 myFileName = os.path.join(str(QDir.tempPath()), 'writetest.shp') print myFileName # Explicitly giving all options, not really needed but nice for clarity myErrorMessage = QString() myOptions = QStringList() myLayerOptions = QStringList() mySelectedOnlyFlag = False mySkipAttributesFlag = False myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myResult = QgsVectorFileWriter.writeAsVectorFormat( self.mMemoryLayer, myFileName, 'utf-8', myGeoCrs, 'ESRI Shapefile', mySelectedOnlyFlag, myErrorMessage, myOptions, myLayerOptions, mySkipAttributesFlag) assert myResult == QgsVectorFileWriter.NoError
def testWriteWithBoolField(self): # init connection string dbconn = 'dbname=\'qgis_test\'' if 'QGIS_PGTEST_DB' in os.environ: dbconn = os.environ['QGIS_PGTEST_DB'] # create a vector layer vl = QgsVectorLayer('{} table="qgis_test"."boolean_table" sql='.format(dbconn), "testbool", "postgres") self.assertTrue(vl.isValid()) # check that 1 of its fields is a bool fields = vl.fields() self.assertEqual(fields.at(fields.indexFromName('fld1')).type(), QVariant.Bool) # write a gpkg package with a bool field crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) filename = os.path.join(str(QDir.tempPath()), 'with_bool_field') rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(vl, filename, 'utf-8', crs, 'GPKG') self.assertEqual(rc, QgsVectorFileWriter.NoError) # open the resulting geopackage vl = QgsVectorLayer(filename + '.gpkg', '', 'ogr') self.assertTrue(vl.isValid()) fields = vl.fields() # test type of converted field idx = fields.indexFromName('fld1') self.assertEqual(fields.at(idx).type(), QVariant.Bool) # test values self.assertEqual(vl.getFeature(1).attributes()[idx], 1) self.assertEqual(vl.getFeature(2).attributes()[idx], 0) del vl os.unlink(filename + '.gpkg')
def set_canvas_crs(epsg_id, enable_projection=False): """Helper to set the crs for the CANVAS before a test is run. :param epsg_id: Valid EPSG identifier :type epsg_id: int :param enable_projection: whether on the fly projections should be enabled on the CANVAS. Default to False. :type enable_projection: bool """ # Enable on-the-fly reprojection CANVAS.mapRenderer().setProjectionsEnabled(enable_projection) # Create CRS Instance myCrs = QgsCoordinateReferenceSystem() myCrs.createFromId(epsg_id, QgsCoordinateReferenceSystem.EpsgCrsId) # Reproject all layers to WGS84 geographic CRS CANVAS.mapRenderer().setDestinationCrs(myCrs)
def testWriteWithLongLongField(self): ml = QgsVectorLayer('NoGeometry?crs=epsg:4326&field=fldlonglong:long', 'test2', 'memory') provider = ml.dataProvider() feat = QgsFeature() feat.setAttributes([2262000000]) provider.addFeatures([feat]) filename = os.path.join(str(QDir.tempPath()), 'with_longlong_field') crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(ml, filename, 'utf-8', crs, 'GPKG') # open the resulting geopackage vl = QgsVectorLayer(filename + '.gpkg', '', 'ogr') self.assertTrue(vl.isValid()) # test values idx = vl.fields().indexFromName('fldlonglong') self.assertEqual(vl.getFeature(1).attributes()[idx], 2262000000)
def testWriteShapefileWithMultiConversion(self): """Check writing geometries to an ESRI shapefile with conversion to multi.""" ml = QgsVectorLayer( ('Point?crs=epsg:4326&field=id:int'), 'test', 'memory') self.assertIsNotNone(ml, 'Provider not initialized') self.assertTrue(ml.isValid(), 'Source layer not valid') provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromWkt('Point (1 2)')) ft.setAttributes([1]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) dest_file_name = os.path.join(str(QDir.tempPath()), 'to_multi.shp') crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', forceMulti=True) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') f = next(created_layer.getFeatures(QgsFeatureRequest())) g = f.geometry() wkt = g.asWkt() expWkt = 'MultiPoint ((1 2))' self.assertTrue(compareWkt(expWkt, wkt), "saving geometry with multi conversion failed: mismatch Expected:\n%s\nGot:\n%s\n" % ( expWkt, wkt))
def writeShape(theMemoryLayer, theFileName): myFileName = os.path.join(str(QDir.tempPath()), theFileName) print(myFileName) # Explicitly giving all options, not really needed but nice for clarity myErrorMessage = '' myOptions = [] myLayerOptions = [] mySelectedOnlyFlag = False mySkipAttributesFlag = False myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myResult = QgsVectorFileWriter.writeAsVectorFormat( theMemoryLayer, myFileName, 'utf-8', myGeoCrs, 'ESRI Shapefile', mySelectedOnlyFlag, myErrorMessage, myOptions, myLayerOptions, mySkipAttributesFlag) assert myResult == QgsVectorFileWriter.NoError
def testTransformQgsRectangle_Regression17600(self): """Test that rectangle transform is in the bindings""" myExtent = QgsRectangle(-1797107, 4392148, 6025926, 6616304) myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myUtmCrs = QgsCoordinateReferenceSystem() myUtmCrs.createFromId(3857, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform(myUtmCrs, myGeoCrs, QgsProject.instance()) myTransformedExtent = myXForm.transform(myExtent) myTransformedExtentForward = myXForm.transform(myExtent, QgsCoordinateTransform.ForwardTransform) self.assertAlmostEquals(myTransformedExtentForward.xMaximum(), myTransformedExtent.xMaximum()) self.assertAlmostEquals(myTransformedExtentForward.xMinimum(), myTransformedExtent.xMinimum()) self.assertAlmostEquals(myTransformedExtentForward.yMaximum(), myTransformedExtent.yMaximum()) self.assertAlmostEquals(myTransformedExtentForward.yMinimum(), myTransformedExtent.yMinimum()) self.assertAlmostEquals(myTransformedExtentForward.xMaximum(), 54.13181426773211) self.assertAlmostEquals(myTransformedExtentForward.xMinimum(), -16.14368685298181) self.assertAlmostEquals(myTransformedExtentForward.yMaximum(), 50.971783118386895) self.assertAlmostEquals(myTransformedExtentForward.yMinimum(), 36.66235970825241) myTransformedExtentReverse = myXForm.transform(myTransformedExtent, QgsCoordinateTransform.ReverseTransform) self.assertAlmostEquals(myTransformedExtentReverse.xMaximum(), myExtent.xMaximum()) self.assertAlmostEquals(myTransformedExtentReverse.xMinimum(), myExtent.xMinimum()) self.assertAlmostEquals(myTransformedExtentReverse.yMaximum(), myExtent.yMaximum()) self.assertAlmostEquals(myTransformedExtentReverse.yMinimum(), myExtent.yMinimum())
def testCreateDGN(self): ml = QgsVectorLayer('Point?crs=epsg:4326', 'test', 'memory') provider = ml.dataProvider() feat = QgsFeature() feat.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(10, 10))) provider.addFeatures([feat]) filename = os.path.join(str(QDir.tempPath()), 'testCreateDGN.dgn') crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(ml, filename, 'utf-8', crs, 'DGN') # open the resulting file vl = QgsVectorLayer(filename, '', 'ogr') self.assertTrue(vl.isValid()) self.assertEqual(vl.featureCount(), 1) del vl # append options = QgsVectorFileWriter.SaveVectorOptions() options.driverName = 'DGN' options.layerName = 'test' options.actionOnExistingFile = QgsVectorFileWriter.AppendToLayerNoNewFields write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, filename, options) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # open the resulting file vl = QgsVectorLayer(filename, '', 'ogr') self.assertTrue(vl.isValid()) self.assertEqual(vl.featureCount(), 2) del vl os.unlink(filename)
def getWGS84resolution(theLayer): """Return resolution of raster layer in EPSG:4326 Input theLayer: Raster layer Output resolution. If input layer is already in EPSG:4326, simply return the resolution If not, work it out based on EPSG:4326 representations of its extent """ msg = tr("Input layer to getWGS84resolution must be a raster layer. " "I got: %s" % str(theLayer.type())[1:-1]) if not theLayer.type() == QgsMapLayer.RasterLayer: raise RuntimeError(msg) if theLayer.crs().authid() == "EPSG:4326": # If it is already in EPSG:4326, simply use the native resolution myCellSize = theLayer.rasterUnitsPerPixel() else: # Otherwise, work it out based on EPSG:4326 representations of # its extent # Reproject extent to EPSG:4326 myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform(theLayer.crs(), myGeoCrs) myExtent = theLayer.extent() myProjectedExtent = myXForm.transformBoundingBox(myExtent) # Estimate cellsize myColumns = theLayer.width() myGeoWidth = abs(myProjectedExtent.xMaximum() - myProjectedExtent.xMinimum()) myCellSize = myGeoWidth / myColumns return myCellSize
def _clipVectorLayer(theLayer, theExtent, extraKeywords=None): """Clip a Hazard or Exposure layer to the extents of the current view frame. The layer must be a vector layer or an exception will be thrown. The output layer will always be in WGS84/Geographic. Args: * theLayer - a valid QGIS vector layer in EPSG:4326 * theExtent - an array representing the exposure layer extents in the form [xmin, ymin, xmax, ymax]. It is assumed that the coordinates are in EPSG:4326 although currently no checks are made to enforce this. Returns: Path to the output clipped layer (placed in the system temp dir). Raises: None """ if not theLayer or not theExtent: msg = tr('Layer or Extent passed to clip is None.') raise InvalidParameterException(msg) if theLayer.type() != QgsMapLayer.VectorLayer: msg = tr('Expected a vector layer but received a %s.' % str(theLayer.type())) raise InvalidParameterException(msg) myHandle, myFilename = tempfile.mkstemp('.shp', 'clip_', getTempDir()) # Ensure the file is deleted before we try to write to it # fixes windows specific issue where you get a message like this # ERROR 1: c:\temp\inasafe\clip_jpxjnt.shp is not a directory. # This is because mkstemp creates the file handle and leaves # the file open. os.close(myHandle) os.remove(myFilename) # Get the clip extents in the layer's native CRS myGeoCrs = QgsCoordinateReferenceSystem() myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) myXForm = QgsCoordinateTransform(myGeoCrs, theLayer.crs()) myRect = QgsRectangle(theExtent[0], theExtent[1], theExtent[2], theExtent[3]) myProjectedExtent = myXForm.transformBoundingBox(myRect) # Get vector layer myProvider = theLayer.dataProvider() if myProvider is None: msg = tr('Could not obtain data provider from ' 'layer "%s"' % theLayer.source()) raise Exception(msg) # get the layer field list, select by our extent then write to disk # .. todo:: FIXME - for different geometry types we should implement # different clipping behaviour e.g. reject polygons that # intersect the edge of the bbox. Tim myAttributes = myProvider.attributeIndexes() myFetchGeometryFlag = True myUseIntersectFlag = True myProvider.select(myAttributes, myProjectedExtent, myFetchGeometryFlag, myUseIntersectFlag) myFieldList = myProvider.fields() myWriter = QgsVectorFileWriter(myFilename, 'UTF-8', myFieldList, theLayer.wkbType(), myGeoCrs, 'ESRI Shapefile') if myWriter.hasError() != QgsVectorFileWriter.NoError: msg = tr('Error when creating shapefile: <br>Filename:' '%s<br>Error: %s' % (myFilename, myWriter.hasError())) raise Exception(msg) # Reverse the coordinate xform now so that we can convert # geometries from layer crs to geocrs. myXForm = QgsCoordinateTransform(theLayer.crs(), myGeoCrs) # Retrieve every feature with its geometry and attributes myFeature = QgsFeature() myCount = 0 while myProvider.nextFeature(myFeature): myGeometry = myFeature.geometry() myGeometry.transform(myXForm) myFeature.setGeometry(myGeometry) myWriter.addFeature(myFeature) myCount += 1 del myWriter # Flush to disk if myCount < 1: myMessage = tr('No features fall within the clip extents. ' 'Try panning / zooming to an area containing data ' 'and then try to run your analysis again.') raise NoFeaturesInExtentException(myMessage) copyKeywords(theLayer.source(), myFilename, extraKeywords=extraKeywords) return myFilename # Filename of created file
class layerSaveAsDlg(QDialog): ''' classdocs ''' def __init__(self, parent, layer): ''' Constructor ''' QDialog.__init__(self, parent) self.ui = ui_layerSaveAsDlg() self.ui.setupUi(self) # self.layerSet = layerSet self.baseLayer = layer self.shpFormats = ["ESRI Shapefile", "GeoJSON"] self.fileTypes = ["ESRI Shape file(*.shp )", "GeoJSON(*.geojson)"] self.crsList = ["Layer CRS", "Project CRS", "Selected CRS"] self.ui.cmbFormat.addItems(self.shpFormats) self.ui.cmbCrs.addItems(self.crsList) self.ui.btnBrowse.clicked.connect(self.browse) self.ui.txtCrs.setText("WGS 84") self.ui.txtCrs.setEnabled(False) # self.ui.cmbFormat.currentIndexChanged.connect(self.enableTxtAPV) self.ui.cmbCrs.currentIndexChanged.connect(self.crsSelectChange) self.ui.btnChange.clicked.connect(self.crsChange) self.ui.buttonBox.accepted.connect(self.saveLayer) self.crs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId) def browse(self): type1 = self.fileTypes[self.ui.cmbFormat.currentIndex()] filePath = QFileDialog.getSaveFileName(self, "Save layer as...",QCoreApplication.applicationDirPath (),type1) self.ui.txtSavePath.setText(filePath) def crsSelectChange(self): if self.ui.cmbCrs.currentIndex() == 2: self.ui.txtCrs.setEnabled(True) else: self.ui.txtCrs.setEnabled(False) def crsChange(self): projectionDlg = QgsGenericProjectionSelector(self) projectionDlg.exec_() # print projectionDlg.selectedCrsId() srs = QgsCoordinateReferenceSystem(projectionDlg.selectedCrsId(), QgsCoordinateReferenceSystem.InternalCrsId) self.mCRS = srs.srsid() self.crs = QgsCoordinateReferenceSystem() self.crs.createFromId(self.mCRS, QgsCoordinateReferenceSystem.InternalCrsId ) # authId = projectionDlg.selectedAuthId() # crsId = projectionDlg.selectedCrsId() # if authId != "": # if authId[:4] != "EPSG": # self.crs = QgsCoordinateReferenceSystem(crsId, QgsCoordinateReferenceSystem.InternalCrsId) # else: # self.crs = QgsCoordinateReferenceSystem(crsId, QgsCoordinateReferenceSystem.EpsgCrsId) self.ui.cmbCrs.setCurrentIndex(2) self.ui.txtCrs.setText(self.crs.description()) def saveLayer(self): destCrs = None ct = QgsCoordinateTransform() if self.ui.txtSavePath.text() == "": QMessageBox.warning(self, "Error", "Please input save file path") return else: if self.ui.cmbCrs.currentIndex() == 0: if self.baseLayer.crs() is None: destCrs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId) # er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText()) else: destCrs = self.baseLayer.crs() print destCrs.authid() # er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", self.baseLayer.crs(), self.ui.cmbFormat.currentText()) elif self.ui.cmbCrs.currentIndex() == 1: destCrs = define._canvas.mapSettings().destinationCrs() if destCrs is None: destCrs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId) # er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText()) # else: # er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText()) else: destCrs = QgsCoordinateReferenceSystem(self.mCRS, QgsCoordinateReferenceSystem.InternalCrsId) if destCrs != self.baseLayer.crs(): ct = QgsCoordinateTransform( self.baseLayer.crs(), destCrs ) er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText()) # er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", self.crs, self.ui.cmbFormat.currentText()) QMessageBox.information(self, "Successful", "Export to vector file has been completed. ") QDialog.accept(self)
def __init__(self, iface): """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 """ # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join( self.plugin_dir, 'i18n', 'volum_{}.qm'.format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) ## Create the dialog (after translation) and keep reference self.dlg = volumDialog() # Declare instance attributes self.actions = [] self.menu = self.tr(u'&Volumator') # TODO: We are going to let the user set this up in a future iteration self.toolbar = self.iface.addToolBar(u'volum') self.toolbar.setObjectName(u'volum') ##################################################################### INIT self.dlg.hCalc.setMaximum(100000.0) self.dlg.espac.setMinimum(0.1) #botao "BOTH" self.dlg.both.setChecked(True) # self.dlg.lineEdit.clear() # self.dlg.pushButton.clicked.connect(self.select_output_file) ##botao input self.dlg.input2.clear() self.dlg.botaoinput.clicked.connect(self.select_input_file) ##botao output self.dlg.outputTxt.clear() self.dlg.botaoOutput.clicked.connect(self.select_output_file) #botao minmax self.dlg.obMaxMin.clicked.connect(self.obtain_max_min) #botao ids self.dlg.obIDs.clicked.connect(self.obtain_ids) #botao clear self.dlg.clearAll.clicked.connect(self.clearFields) ###botao de seleciona CRS #31982 #32614 temp = QgsCoordinateReferenceSystem() # temp.createFromId(31982) temp.createFromId(32614) self.dlg.crsSel.setCrs(temp) # self.dlg.crsSel.setCrs(crsOrt) #muda seletor de CRS caso seja selecionado o orto self.dlg.defProjButton.clicked.connect(self.set_orto_crs) ## definição do "sobre" self.dlg.aboutDefProj.setOpenExternalLinks(True) #trocando virgula (argh) por ponto self.dlg.hCalc.setLocale(QLocale("UnitedStates")) #LANGUAGE self.dlg.hEquip.setLocale(QLocale("UnitedStates")) #LANGUAGE self.dlg.hBast.setLocale(QLocale("UnitedStates")) #LANGUAGE self.dlg.espac.setLocale(QLocale("UnitedStates")) #LANGUAGE self.dlg.hEquip.setValue(1.5) #hiding everithing that is not useful at the beggining #DO # self.dlg.hEquip.hide() ################################################################## # ####################### LINHAS A VIRAR COMENTARIO self.dlg.input2.setText(homedir+"/Documents/epsg32614.csv") #COMMENT self.dlg.outputTxt.setText(homedir+"/report.txt") #COMMENT
def testWriteShapefileWithZ(self): """Check writing geometries with Z dimension to an ESRI shapefile.""" #start by saving a memory layer and forcing z ml = QgsVectorLayer( ('Point?crs=epsg:4326&field=id:int'), 'test', 'memory') assert ml is not None, 'Provider not initialized' assert ml.isValid(), 'Source layer not valid' provider = ml.dataProvider() assert provider is not None ft = QgsFeature() ft.setGeometry(QgsGeometry.fromWkt('PointZ (1 2 3)')) ft.setAttributes([1]) res, features = provider.addFeatures([ft]) assert res assert len(features) > 0 # check with both a standard PointZ and 25d style Point25D type for t in [QgsWKBTypes.PointZ, QgsWKBTypes.Point25D]: dest_file_name = os.path.join(str(QDir.tempPath()), 'point_{}.shp'.format(QgsWKBTypes.displayString(t))) print(dest_file_name) crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', overrideGeometryType=t) self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr') f = created_layer.getFeatures(QgsFeatureRequest()).next() g = f.geometry() wkt = g.exportToWkt() expWkt = 'PointZ (1 2 3)' assert compareWkt(expWkt, wkt), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt) #also try saving out the shapefile version again, as an extra test #this tests that saving a layer with z WITHOUT explicitly telling the writer to keep z values, #will stay retain the z values dest_file_name = os.path.join(str(QDir.tempPath()), 'point_{}_copy.shp'.format(QgsWKBTypes.displayString(t))) print(dest_file_name) crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result = QgsVectorFileWriter.writeAsVectorFormat( created_layer, dest_file_name, 'utf-8', crs, 'ESRI Shapefile') self.assertEqual(write_result, QgsVectorFileWriter.NoError) # Open result and check created_layer_from_shp = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr') f = created_layer_from_shp.getFeatures(QgsFeatureRequest()).next() g = f.geometry() wkt = g.exportToWkt() assert compareWkt(expWkt, wkt), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt)
def testWriteShapefileWithZ(self): """Check writing geometries with Z dimension to an ESRI shapefile.""" # start by saving a memory layer and forcing z ml = QgsVectorLayer(('Point?crs=epsg:4326&field=id:int'), 'test', 'memory') self.assertIsNotNone(ml, 'Provider not initialized') self.assertTrue(ml.isValid(), 'Source layer not valid') provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromWkt('PointZ (1 2 3)')) ft.setAttributes([1]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) # check with both a standard PointZ and 25d style Point25D type for t in [QgsWkbTypes.PointZ, QgsWkbTypes.Point25D]: dest_file_name = os.path.join( str(QDir.tempPath()), 'point_{}.shp'.format(QgsWkbTypes.displayString(t))) crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', overrideGeometryType=t) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer( '{}|layerid=0'.format(dest_file_name), 'test', 'ogr') f = next(created_layer.getFeatures(QgsFeatureRequest())) g = f.geometry() wkt = g.asWkt() expWkt = 'PointZ (1 2 3)' self.assertTrue( compareWkt(expWkt, wkt), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt)) # also try saving out the shapefile version again, as an extra test # this tests that saving a layer with z WITHOUT explicitly telling the writer to keep z values, # will stay retain the z values dest_file_name = os.path.join( str(QDir.tempPath()), 'point_{}_copy.shp'.format(QgsWkbTypes.displayString(t))) crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( created_layer, dest_file_name, 'utf-8', crs, 'ESRI Shapefile') self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer_from_shp = QgsVectorLayer( '{}|layerid=0'.format(dest_file_name), 'test', 'ogr') f = next(created_layer_from_shp.getFeatures(QgsFeatureRequest())) g = f.geometry() wkt = g.asWkt() self.assertTrue( compareWkt(expWkt, wkt), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt))
def testWriteShapefileWithAttributeSubsets(self): """Tests writing subsets of attributes to files.""" ml = QgsVectorLayer(( 'Point?crs=epsg:4326&field=id:int&field=field1:int&field=field2:int&field=field3:int' ), 'test', 'memory') self.assertIsNotNone(ml, 'Provider not initialized') self.assertTrue(ml.isValid(), 'Source layer not valid') provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromWkt('Point (1 2)')) ft.setAttributes([1, 11, 12, 13]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) # first write out with all attributes dest_file_name = os.path.join(str(QDir.tempPath()), 'all_attributes.shp') crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', attributes=[]) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') self.assertEqual(created_layer.fields().count(), 4) f = next(created_layer.getFeatures(QgsFeatureRequest())) self.assertEqual(f['id'], 1) self.assertEqual(f['field1'], 11) self.assertEqual(f['field2'], 12) self.assertEqual(f['field3'], 13) # now test writing out only a subset of attributes dest_file_name = os.path.join(str(QDir.tempPath()), 'subset_attributes.shp') write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', attributes=[1, 3]) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') self.assertEqual(created_layer.fields().count(), 2) f = next(created_layer.getFeatures(QgsFeatureRequest())) self.assertEqual(f['field1'], 11) self.assertEqual(f['field3'], 13) # finally test writing no attributes dest_file_name = os.path.join(str(QDir.tempPath()), 'no_attributes.shp') write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', skipAttributeCreation=True) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') # expect only a default 'FID' field for shapefiles self.assertEqual(created_layer.fields().count(), 1) self.assertEqual(created_layer.fields()[0].name(), 'FID') # in this case we also check that the geometry exists, to make sure feature has been correctly written # even without attributes f = next(created_layer.getFeatures(QgsFeatureRequest())) g = f.geometry() wkt = g.asWkt() expWkt = 'Point (1 2)' self.assertTrue( compareWkt(expWkt, wkt), "geometry not saved correctly when saving without attributes : mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt)) self.assertEqual(f['FID'], 0)
def testDateTimeWriteShapefile(self): """Check writing date and time fields to an ESRI shapefile.""" ml = QgsVectorLayer( ('Point?crs=epsg:4326&field=id:int&' 'field=date_f:date&field=time_f:time&field=dt_f:datetime'), 'test', 'memory') self.assertTrue(ml.isValid()) provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(10, 10))) ft.setAttributes([ 1, QDate(2014, 3, 5), QTime(13, 45, 22), QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)) ]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp') crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile') self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') fields = created_layer.dataProvider().fields() self.assertEqual( fields.at(fields.indexFromName('date_f')).type(), QVariant.Date) # shapefiles do not support time types, result should be string self.assertEqual( fields.at(fields.indexFromName('time_f')).type(), QVariant.String) # shapefiles do not support datetime types, result should be string self.assertEqual( fields.at(fields.indexFromName('dt_f')).type(), QVariant.String) f = next(created_layer.getFeatures(QgsFeatureRequest())) date_idx = created_layer.fields().lookupField('date_f') self.assertIsInstance(f.attributes()[date_idx], QDate) self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5)) time_idx = created_layer.fields().lookupField('time_f') # shapefiles do not support time types self.assertIsInstance(f.attributes()[time_idx], str) self.assertEqual(f.attributes()[time_idx], '13:45:22') # shapefiles do not support datetime types datetime_idx = created_layer.fields().lookupField('dt_f') self.assertIsInstance(f.attributes()[datetime_idx], str) self.assertEqual( f.attributes()[datetime_idx], QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)).toString("yyyy/MM/dd hh:mm:ss.zzz"))
def testWriteShapefileWithAttributeSubsets(self): """Tests writing subsets of attributes to files.""" ml = QgsVectorLayer( ('Point?crs=epsg:4326&field=id:int&field=field1:int&field=field2:int&field=field3:int'), 'test', 'memory') self.assertIsNotNone(ml, 'Provider not initialized') self.assertTrue(ml.isValid(), 'Source layer not valid') provider = ml.dataProvider() self.assertIsNotNone(provider) ft = QgsFeature() ft.setGeometry(QgsGeometry.fromWkt('Point (1 2)')) ft.setAttributes([1, 11, 12, 13]) res, features = provider.addFeatures([ft]) self.assertTrue(res) self.assertTrue(features) # first write out with all attributes dest_file_name = os.path.join(str(QDir.tempPath()), 'all_attributes.shp') crs = QgsCoordinateReferenceSystem() crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId) write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', attributes=[]) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') self.assertEqual(created_layer.fields().count(), 4) f = next(created_layer.getFeatures(QgsFeatureRequest())) self.assertEqual(f['id'], 1) self.assertEqual(f['field1'], 11) self.assertEqual(f['field2'], 12) self.assertEqual(f['field3'], 13) # now test writing out only a subset of attributes dest_file_name = os.path.join(str(QDir.tempPath()), 'subset_attributes.shp') write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', attributes=[1, 3]) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') self.assertEqual(created_layer.fields().count(), 2) f = next(created_layer.getFeatures(QgsFeatureRequest())) self.assertEqual(f['field1'], 11) self.assertEqual(f['field3'], 13) # finally test writing no attributes dest_file_name = os.path.join(str(QDir.tempPath()), 'no_attributes.shp') write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', skipAttributeCreation=True) self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message) # Open result and check created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr') # expect only a default 'FID' field for shapefiles self.assertEqual(created_layer.fields().count(), 1) self.assertEqual(created_layer.fields()[0].name(), 'FID') # in this case we also check that the geometry exists, to make sure feature has been correctly written # even without attributes f = next(created_layer.getFeatures(QgsFeatureRequest())) g = f.geometry() wkt = g.asWkt() expWkt = 'Point (1 2)' self.assertTrue(compareWkt(expWkt, wkt), "geometry not saved correctly when saving without attributes : mismatch Expected:\n%s\nGot:\n%s\n" % ( expWkt, wkt)) self.assertEqual(f['FID'], 0)