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)
