def testAreaUnitsToFromString(self):
"""Test converting area units to and from translated strings"""
units = [QgsUnitTypes.AreaSquareMeters,
QgsUnitTypes.AreaSquareKilometers,
QgsUnitTypes.AreaSquareFeet,
QgsUnitTypes.AreaSquareYards,
QgsUnitTypes.AreaSquareMiles,
QgsUnitTypes.AreaHectares,
QgsUnitTypes.AreaAcres,
QgsUnitTypes.AreaSquareNauticalMiles,
QgsUnitTypes.AreaSquareDegrees,
QgsUnitTypes.AreaSquareCentimeters,
QgsUnitTypes.AreaSquareMillimeters,
QgsUnitTypes.AreaUnknownUnit]
for u in units:
res, ok = QgsUnitTypes.stringToAreaUnit(QgsUnitTypes.toString(u))
assert ok
self.assertEqual(res, u)
# Test converting bad strings
res, ok = QgsUnitTypes.stringToAreaUnit('bad')
self.assertFalse(ok)
self.assertEqual(res, QgsUnitTypes.AreaUnknownUnit)
# Test that string is cleaned before conversion
res, ok = QgsUnitTypes.stringToAreaUnit(' {} '.format(QgsUnitTypes.toString(QgsUnitTypes.AreaSquareMiles).upper()))
assert ok
self.assertEqual(res, QgsUnitTypes.AreaSquareMiles)
def testDistanceUnitsToFromString(self):
"""Test converting distance units to and from translated strings"""
units = [QgsUnitTypes.DistanceMeters,
QgsUnitTypes.DistanceKilometers,
QgsUnitTypes.DistanceFeet,
QgsUnitTypes.DistanceYards,
QgsUnitTypes.DistanceMiles,
QgsUnitTypes.DistanceDegrees,
QgsUnitTypes.DistanceCentimeters,
QgsUnitTypes.DistanceMillimeters,
QgsUnitTypes.DistanceUnknownUnit,
QgsUnitTypes.DistanceNauticalMiles]
for u in units:
res, ok = QgsUnitTypes.stringToDistanceUnit(QgsUnitTypes.toString(u))
assert ok
self.assertEqual(res, u)
# Test converting bad strings
res, ok = QgsUnitTypes.stringToDistanceUnit('bad')
self.assertFalse(ok)
self.assertEqual(res, QgsUnitTypes.DistanceUnknownUnit)
# Test that string is cleaned before conversion
res, ok = QgsUnitTypes.stringToDistanceUnit(' {} '.format(QgsUnitTypes.toString(QgsUnitTypes.DistanceFeet).upper()))
print((' {} '.format(QgsUnitTypes.toString(QgsUnitTypes.DistanceFeet).upper())))
assert ok
self.assertEqual(res, QgsUnitTypes.DistanceFeet)
def testLengthMeasureAndUnits(self):
"""Test a variety of length measurements in different CRS and ellipsoid modes, to check that the
calculated lengths and units are always consistent
"""
da = QgsDistanceArea()
da.setSourceCrs(QgsCoordinateReferenceSystem.fromSrsId(3452), QgsProject.instance().transformContext())
da.setEllipsoid("NONE")
# We check both the measured length AND the units, in case the logic regarding
# ellipsoids and units changes in future
distance = da.measureLine(QgsPointXY(1, 1), QgsPointXY(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units))))
assert ((abs(distance - 2.23606797) < 0.00000001 and units == QgsUnitTypes.DistanceDegrees) or
(abs(distance - 248.52) < 0.01 and units == QgsUnitTypes.DistanceMeters))
da.setEllipsoid("WGS84")
distance = da.measureLine(QgsPointXY(1, 1), QgsPointXY(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units))))
# should always be in Meters
self.assertAlmostEqual(distance, 247555.57, delta=0.01)
self.assertEqual(units, QgsUnitTypes.DistanceMeters)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance, QgsUnitTypes.DistanceNauticalMiles)
self.assertAlmostEqual(distance, 133.669, delta=0.01)
# now try with a source CRS which is in feet
da.setSourceCrs(QgsCoordinateReferenceSystem.fromSrsId(27469), QgsProject.instance().transformContext())
da.setEllipsoid("NONE")
# measurement should be in feet
distance = da.measureLine(QgsPointXY(1, 1), QgsPointXY(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(distance, 2.23606797, delta=0.000001)
self.assertEqual(units, QgsUnitTypes.DistanceFeet)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance, QgsUnitTypes.DistanceMeters)
self.assertAlmostEqual(distance, 0.6815, delta=0.001)
da.setEllipsoid("WGS84")
# now should be in Meters again
distance = da.measureLine(QgsPointXY(1, 1), QgsPointXY(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(distance, 0.67953772, delta=0.000001)
self.assertEqual(units, QgsUnitTypes.DistanceMeters)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance, QgsUnitTypes.DistanceFeet)
self.assertAlmostEqual(distance, 2.2294, delta=0.001)
def testLengthMeasureAndUnits(self):
"""Test a variety of length measurements in different CRS and ellipsoid modes, to check that the
calculated lengths and units are always consistent
"""
da = QgsDistanceArea()
da.setSourceCrs(3452)
da.setEllipsoidalMode(False)
da.setEllipsoid("NONE")
daCRS = QgsCoordinateReferenceSystem()
daCRS.createFromSrsId(da.sourceCrs())
# We check both the measured length AND the units, in case the logic regarding
# ellipsoids and units changes in future
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print "measured {} in {}".format(distance, QgsUnitTypes.toString(units))
assert ((abs(distance - 2.23606797) < 0.00000001 and units == QGis.Degrees) or
(abs(distance - 248.52) < 0.01 and units == QGis.Meters))
da.setEllipsoid("WGS84")
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print "measured {} in {}".format(distance, QgsUnitTypes.toString(units))
assert ((abs(distance - 2.23606797) < 0.00000001 and units == QGis.Degrees) or
(abs(distance - 248.52) < 0.01 and units == QGis.Meters))
da.setEllipsoidalMode(True)
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print "measured {} in {}".format(distance, QgsUnitTypes.toString(units))
# should always be in Meters
self.assertAlmostEqual(distance, 247555.57, delta=0.01)
self.assertEqual(units, QGis.Meters)
# now try with a source CRS which is in feet
da.setSourceCrs(27469)
da.setEllipsoidalMode(False)
# measurement should be in feet
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print "measured {} in {}".format(distance, QgsUnitTypes.toString(units))
self.assertAlmostEqual(distance, 2.23606797, delta=0.000001)
self.assertEqual(units, QGis.Feet)
da.setEllipsoidalMode(True)
# now should be in Meters again
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print "measured {} in {}".format(distance, QgsUnitTypes.toString(units))
self.assertAlmostEqual(distance, 0.67953772, delta=0.000001)
self.assertEqual(units, QGis.Meters)
def testFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between units"""
expected = {
QGis.Meters: {
QGis.Meters: 1.0,
QGis.Feet: 3.28083989501,
QGis.Degrees: 0.00000898315,
QGis.NauticalMiles: 0.000539957,
},
QGis.Feet: {
QGis.Meters: 0.3048,
QGis.Feet: 1.0,
QGis.Degrees: 2.73806498599629e-06,
QGis.NauticalMiles: 0.000164579,
},
QGis.Degrees: {
QGis.Meters: 111319.49079327358,
QGis.Feet: 365221.4264871,
QGis.Degrees: 1.0,
QGis.NauticalMiles: 60.1077164,
},
QGis.NauticalMiles: {
QGis.Meters: 1852.0,
QGis.Feet: 6076.1154856,
QGis.Degrees: 0.0166367990650,
QGis.NauticalMiles: 1.0,
},
QGis.UnknownUnit: {QGis.Meters: 1.0, QGis.Feet: 1.0, QGis.Degrees: 1.0, QGis.NauticalMiles: 1.0},
}
for from_unit in expected.keys():
for to_unit in expected[from_unit].keys():
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(
res,
expected_factor,
msg="got {:.7f}, expected {:.7f} when converting from {} to {}".format(
res, expected_factor, QgsUnitTypes.toString(from_unit), QgsUnitTypes.toString(to_unit)
),
)
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, QGis.UnknownUnit)
self.assertAlmostEqual(
res,
1.0,
msg="got {:.7f}, expected 1.0 when converting from {} to unknown units".format(
res, expected_factor, QgsUnitTypes.toString(from_unit)
),
)
def testEncodeDecodeAngleUnits(self):
"""Test encoding and decoding angle units"""
units = [
QgsUnitTypes.AngleDegrees,
QgsUnitTypes.Radians,
QgsUnitTypes.Gon,
QgsUnitTypes.MinutesOfArc,
QgsUnitTypes.SecondsOfArc,
QgsUnitTypes.Turn,
QgsUnitTypes.UnknownAngleUnit,
]
for u in units:
res, ok = QgsUnitTypes.decodeAngleUnit(QgsUnitTypes.encodeUnit(u))
assert ok, "could not decode unit {}".format(QgsUnitTypes.toString(u))
self.assertEqual(res, u)
# Test decoding bad units
res, ok = QgsUnitTypes.decodeAngleUnit("bad")
self.assertFalse(ok)
self.assertEqual(res, QgsUnitTypes.UnknownAngleUnit)
# Test that string is cleaned before decoding
res, ok = QgsUnitTypes.decodeAngleUnit(" MoA ")
assert ok
self.assertEqual(res, QgsUnitTypes.MinutesOfArc)
def __init__(self, param):
super().__init__(param)
self.label = QLabel('')
self.units_combo = QComboBox()
self.base_units = QgsUnitTypes.DistanceUnknownUnit
for u in (QgsUnitTypes.DistanceMeters,
QgsUnitTypes.DistanceKilometers,
QgsUnitTypes.DistanceFeet,
QgsUnitTypes.DistanceMiles,
QgsUnitTypes.DistanceYards):
self.units_combo.addItem(QgsUnitTypes.toString(u), u)
label_margin = self.fontMetrics().width('X')
self.layout().insertSpacing(1, label_margin / 2)
self.layout().insertWidget(2, self.label)
self.layout().insertWidget(3, self.units_combo)
self.layout().insertSpacing(4, label_margin / 2)
self.warning_label = QLabel()
icon = QgsApplication.getThemeIcon('mIconWarning.svg')
size = max(24, self.spnValue.height() * 0.5)
self.warning_label.setPixmap(icon.pixmap(icon.actualSize(QSize(size, size))))
self.warning_label.setToolTip(self.tr('Distance is in geographic degrees. Consider reprojecting to a projected local coordinate system for accurate results.'))
self.layout().insertWidget(4, self.warning_label)
self.layout().insertSpacing(5, label_margin)
self.setUnits(QgsUnitTypes.DistanceUnknownUnit)
def testDistanceUnitsToFromString(self):
"""Test converting distance units to and from translated strings"""
units = [QGis.Meters, QGis.Feet, QGis.Degrees, QGis.UnknownUnit, QGis.NauticalMiles]
for u in units:
res, ok = QgsUnitTypes.stringToDistanceUnit(QgsUnitTypes.toString(u))
assert ok
self.assertEqual(res, u)
# Test converting bad strings
res, ok = QgsUnitTypes.stringToDistanceUnit("bad")
self.assertFalse(ok)
self.assertEqual(res, QGis.UnknownUnit)
# Test that string is cleaned before conversion
res, ok = QgsUnitTypes.stringToDistanceUnit(" {} ".format(QgsUnitTypes.toString(QGis.Feet).upper()))
print " {} ".format(QgsUnitTypes.toString(QGis.Feet).upper())
assert ok
self.assertEqual(res, QGis.Feet)
def testRenderUnitsString(self):
"""Test converting render units to strings"""
units = [QgsUnitTypes.RenderMillimeters,
QgsUnitTypes.RenderMapUnits,
QgsUnitTypes.RenderPixels,
QgsUnitTypes.RenderPercentage,
QgsUnitTypes.RenderPoints,
QgsUnitTypes.RenderInches]
for u in units:
self.assertTrue(QgsUnitTypes.toString(u))
def setUnits(self, units):
self.label.setText(QgsUnitTypes.toString(units))
if QgsUnitTypes.unitType(units) != QgsUnitTypes.Standard:
self.units_combo.hide()
self.label.show()
else:
self.units_combo.setCurrentIndex(self.units_combo.findData(units))
self.units_combo.show()
self.label.hide()
self.warning_label.setVisible(units == QgsUnitTypes.DistanceDegrees)
self.base_units = units
def combo_changed(self, idx):
if idx > 0:
crs = self.in_combo.itemData(self.in_combo.currentIndex()).crs()
units = QgsUnitTypes.toString(crs.mapUnits())
self.offset.setToolTip('Offset value ({})'.format(units))
self.interval.setToolTip('Interval value ({})'.format(units))
self.in_name = True
if self.out_name is True:
self.run_button.setEnabled(True)
else:
self.run_button.setEnabled(False)
else:
self.offset.setToolTip('')
self.interval.setToolTip('')
self.in_name = False
self.run_button.setEnabled(False)
def testAbbreviateLayoutUnits(self):
"""Test abbreviating layout units"""
units = [QgsUnitTypes.LayoutMillimeters,
QgsUnitTypes.LayoutCentimeters,
QgsUnitTypes.LayoutMeters,
QgsUnitTypes.LayoutInches,
QgsUnitTypes.LayoutFeet,
QgsUnitTypes.LayoutPoints,
QgsUnitTypes.LayoutPicas,
QgsUnitTypes.LayoutPixels]
used = set()
for u in units:
self.assertTrue(QgsUnitTypes.toString(u))
self.assertTrue(QgsUnitTypes.toAbbreviatedString(u))
self.assertFalse(QgsUnitTypes.toAbbreviatedString(u) in used)
used.add(QgsUnitTypes.toAbbreviatedString(u))
def testAbbreviateRenderUnits(self):
"""Test abbreviating render units"""
units = [QgsUnitTypes.RenderMillimeters,
QgsUnitTypes.RenderMapUnits,
QgsUnitTypes.RenderPixels,
QgsUnitTypes.RenderPercentage,
QgsUnitTypes.RenderPoints,
QgsUnitTypes.RenderInches,
QgsUnitTypes.RenderUnknownUnit,
QgsUnitTypes.RenderMetersInMapUnits]
used = set()
for u in units:
self.assertTrue(QgsUnitTypes.toString(u))
self.assertTrue(QgsUnitTypes.toAbbreviatedString(u))
self.assertFalse(QgsUnitTypes.toAbbreviatedString(u) in used)
used.add(QgsUnitTypes.toAbbreviatedString(u))
def testAngleToString(self):
"""Test converting angle unit to string"""
units = [QgsUnitTypes.AngleDegrees,
QgsUnitTypes.AngleRadians,
QgsUnitTypes.AngleGon,
QgsUnitTypes.AngleMinutesOfArc,
QgsUnitTypes.AngleSecondsOfArc,
QgsUnitTypes.AngleTurn,
QgsUnitTypes.AngleUnknownUnit]
dupes = set()
# can't test result as it may be translated, so make sure it's non-empty and not a duplicate
for u in units:
s = QgsUnitTypes.toString(u)
assert len(s) > 0
self.assertFalse(s in dupes)
dupes.add(s)
def __init__(self, iface):
self.iface = iface
QDialog.__init__(self)
self.setupUi(self)
self.setWindowTitle('QChainage')
self.currentUnits = None
self.qgisSettings = QSettings()
self.okbutton = self.buttonBox.button(QDialogButtonBox.Ok)
self.okbutton.setEnabled(False)
self.da = QgsDistanceArea()
self.UnitsComboBox.clear()
for u in [
QgsUnitTypes.DistanceMeters,
QgsUnitTypes.DistanceKilometers,
QgsUnitTypes.DistanceFeet,
QgsUnitTypes.DistanceNauticalMiles,
QgsUnitTypes.DistanceYards,
QgsUnitTypes.DistanceMiles,
QgsUnitTypes.DistanceDegrees,
QgsUnitTypes.DistanceCentimeters,
QgsUnitTypes.DistanceMillimeters,
QgsUnitTypes.DistanceUnknownUnit,
]:
self.UnitsComboBox.addItem(QgsUnitTypes.toString(u), u)
selected_layer_index = -1
counter = -1
for layer in self.iface.mapCanvas().layers():
if layer.type() == QgsMapLayer.VectorLayer and \
layer.geometryType() == QgsWkbTypes.LineGeometry:
self.loadLayer(layer)
counter += 1
if layer == self.iface.mapCanvas().currentLayer():
selected_layer_index = counter
if selected_layer_index >= 0:
self.selectLayerComboBox.setCurrentIndex(selected_layer_index)
def testEncodeDecodeAngleUnits(self):
"""Test encoding and decoding angle units"""
units = [QgsUnitTypes.AngleDegrees,
QgsUnitTypes.AngleRadians,
QgsUnitTypes.AngleGon,
QgsUnitTypes.AngleMinutesOfArc,
QgsUnitTypes.AngleSecondsOfArc,
QgsUnitTypes.AngleTurn,
QgsUnitTypes.AngleUnknownUnit]
for u in units:
res, ok = QgsUnitTypes.decodeAngleUnit(QgsUnitTypes.encodeUnit(u))
assert ok, 'could not decode unit {}'.format(QgsUnitTypes.toString(u))
self.assertEqual(res, u)
# Test decoding bad units
res, ok = QgsUnitTypes.decodeAngleUnit('bad')
self.assertFalse(ok)
self.assertEqual(res, QgsUnitTypes.AngleUnknownUnit)
# Test that string is cleaned before decoding
res, ok = QgsUnitTypes.decodeAngleUnit(' MoA ')
assert ok
self.assertEqual(res, QgsUnitTypes.AngleMinutesOfArc)
def testAngleFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between angular units"""
expected = {
QgsUnitTypes.AngleDegrees: {
QgsUnitTypes.AngleDegrees: 1.0,
QgsUnitTypes.AngleRadians: 0.0174533,
QgsUnitTypes.AngleGon: 1.1111111,
QgsUnitTypes.AngleMinutesOfArc: 60,
QgsUnitTypes.AngleSecondsOfArc: 3600,
QgsUnitTypes.AngleTurn: 0.00277777777778,
QgsUnitTypes.AngleMilliradiansSI: 17.453292519943297,
QgsUnitTypes.AngleMilNATO: 17.77777777777778
},
QgsUnitTypes.AngleRadians: {
QgsUnitTypes.AngleDegrees: 57.2957795,
QgsUnitTypes.AngleRadians: 1.0,
QgsUnitTypes.AngleGon: 63.6619772,
QgsUnitTypes.AngleMinutesOfArc: 3437.7467708,
QgsUnitTypes.AngleSecondsOfArc: 206264.8062471,
QgsUnitTypes.AngleTurn: 0.159154943092,
QgsUnitTypes.AngleMilliradiansSI: 1000.0,
QgsUnitTypes.AngleMilNATO: 1018.5916357881301
},
QgsUnitTypes.AngleGon: {
QgsUnitTypes.AngleDegrees: 0.9000000,
QgsUnitTypes.AngleRadians: 0.015707968623450838802,
QgsUnitTypes.AngleGon: 1.0,
QgsUnitTypes.AngleMinutesOfArc: 54.0000000,
QgsUnitTypes.AngleSecondsOfArc: 3240.0000000,
QgsUnitTypes.AngleTurn: 0.0025,
QgsUnitTypes.AngleMilliradiansSI: 15.707963267948967,
QgsUnitTypes.AngleMilNATO: 16
},
QgsUnitTypes.AngleMinutesOfArc: {
QgsUnitTypes.AngleDegrees: 0.016666672633390722247,
QgsUnitTypes.AngleRadians: 0.00029088831280398030638,
QgsUnitTypes.AngleGon: 0.018518525464057963154,
QgsUnitTypes.AngleMinutesOfArc: 1.0,
QgsUnitTypes.AngleSecondsOfArc: 60.0,
QgsUnitTypes.AngleTurn: 4.62962962962963e-05,
QgsUnitTypes.AngleMilliradiansSI: 0.29088820866572157,
QgsUnitTypes.AngleMilNATO: 0.29629629629629634
},
QgsUnitTypes.AngleSecondsOfArc: {
QgsUnitTypes.AngleDegrees: 0.00027777787722304257169,
QgsUnitTypes.AngleRadians: 4.848138546730629518e-6,
QgsUnitTypes.AngleGon: 0.0003086420910674814405,
QgsUnitTypes.AngleMinutesOfArc: 0.016666672633325253783,
QgsUnitTypes.AngleSecondsOfArc: 1.0,
QgsUnitTypes.AngleTurn: 7.71604938271605e-07,
QgsUnitTypes.AngleMilliradiansSI: 0.0048481482527009582897,
QgsUnitTypes.AngleMilNATO: 0.0049382716049382715
},
QgsUnitTypes.AngleTurn: {
QgsUnitTypes.AngleDegrees: 360.0,
QgsUnitTypes.AngleRadians: 6.2831853071795,
QgsUnitTypes.AngleGon: 400.0,
QgsUnitTypes.AngleMinutesOfArc: 21600,
QgsUnitTypes.AngleSecondsOfArc: 1296000,
QgsUnitTypes.AngleTurn: 1,
QgsUnitTypes.AngleMilliradiansSI: 6283.185307179586,
QgsUnitTypes.AngleMilNATO: 6400
},
QgsUnitTypes.AngleMilliradiansSI: {
QgsUnitTypes.AngleDegrees: 0.057295779513082325,
QgsUnitTypes.AngleRadians: 0.001,
QgsUnitTypes.AngleGon: 0.06366197723675814,
QgsUnitTypes.AngleMinutesOfArc: 3.4377467707849396,
QgsUnitTypes.AngleSecondsOfArc: 206.26480624709637,
QgsUnitTypes.AngleTurn: 0.0015707963267948967,
QgsUnitTypes.AngleMilliradiansSI: 1.0,
QgsUnitTypes.AngleMilNATO: 1.0185916357881302
},
QgsUnitTypes.AngleMilNATO: {
QgsUnitTypes.AngleDegrees: 0.05625,
QgsUnitTypes.AngleRadians: 0.0009817477042468104,
QgsUnitTypes.AngleGon: 0.0625,
QgsUnitTypes.AngleMinutesOfArc: 3.375,
QgsUnitTypes.AngleSecondsOfArc: 202.5,
QgsUnitTypes.AngleTurn: 0.000015625,
QgsUnitTypes.AngleMilliradiansSI: 0.9817477042468102,
QgsUnitTypes.AngleMilNATO: 1.0
}
}
for from_unit in list(expected.keys()):
for to_unit in list(expected[from_unit].keys()):
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(
res,
expected_factor,
msg=
'got {:.7f}, expected {:.7f} when converting from {} to {}'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(
from_unit, QgsUnitTypes.AngleUnknownUnit)
self.assertAlmostEqual(
res,
1.0,
msg=
'got {:.7f}, expected 1.0 when converting from {} to unknown units'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def spatial_unit(self):
u = self.rgis.crs.mapUnits()
su = QgsUnitTypes.toString(u).upper()
return su
def setUnits(self, units):
self.label.setText(QgsUnitTypes.toString(units))
self.warning_label.setVisible(units == QgsUnitTypes.DistanceDegrees)
def testAreaFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between areal units"""
expected = {
QgsUnitTypes.AreaSquareMeters: {
QgsUnitTypes.AreaSquareMeters: 1.0,
QgsUnitTypes.AreaSquareKilometers: 1e-6,
QgsUnitTypes.AreaSquareFeet: 10.7639104,
QgsUnitTypes.AreaSquareYards: 1.19599,
QgsUnitTypes.AreaSquareMiles: 3.86102e-7,
QgsUnitTypes.AreaHectares: 0.0001,
QgsUnitTypes.AreaAcres: 0.000247105,
QgsUnitTypes.AreaSquareNauticalMiles: 2.91553e-7,
QgsUnitTypes.AreaSquareDegrees: 0.000000000080697,
QgsUnitTypes.AreaSquareMillimeters: 1e6,
QgsUnitTypes.AreaSquareCentimeters: 1e4,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareKilometers: {
QgsUnitTypes.AreaSquareMeters: 1e6,
QgsUnitTypes.AreaSquareKilometers: 1,
QgsUnitTypes.AreaSquareFeet: 10763910.4167097,
QgsUnitTypes.AreaSquareYards: 1195990.04630108,
QgsUnitTypes.AreaSquareMiles: 0.386102158,
QgsUnitTypes.AreaHectares: 100,
QgsUnitTypes.AreaAcres: 247.105381467,
QgsUnitTypes.AreaSquareNauticalMiles: 0.291553349598,
QgsUnitTypes.AreaSquareDegrees: 0.000080697034968,
QgsUnitTypes.AreaSquareMillimeters: 1e12,
QgsUnitTypes.AreaSquareCentimeters: 1e10,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareFeet: {
QgsUnitTypes.AreaSquareMeters: 0.092903,
QgsUnitTypes.AreaSquareKilometers: 9.2903e-8,
QgsUnitTypes.AreaSquareFeet: 1.0,
QgsUnitTypes.AreaSquareYards: 0.11111111111,
QgsUnitTypes.AreaSquareMiles: 3.58701e-8,
QgsUnitTypes.AreaHectares: 9.2903e-6,
QgsUnitTypes.AreaAcres: 2.29568e-5,
QgsUnitTypes.AreaSquareNauticalMiles: 2.70862e-8,
QgsUnitTypes.AreaSquareDegrees: 0.000000000007497,
QgsUnitTypes.AreaSquareMillimeters: 92903.04,
QgsUnitTypes.AreaSquareCentimeters: 929.0304,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareYards: {
QgsUnitTypes.AreaSquareMeters: 0.836127360,
QgsUnitTypes.AreaSquareKilometers: 8.36127e-7,
QgsUnitTypes.AreaSquareFeet: 9.0,
QgsUnitTypes.AreaSquareYards: 1.0,
QgsUnitTypes.AreaSquareMiles: 3.22831e-7,
QgsUnitTypes.AreaHectares: 8.3612736E-5,
QgsUnitTypes.AreaAcres: 0.00020661157,
QgsUnitTypes.AreaSquareNauticalMiles: 2.43776e-7,
QgsUnitTypes.AreaSquareDegrees: 0.000000000067473,
QgsUnitTypes.AreaSquareMillimeters: 836127.360,
QgsUnitTypes.AreaSquareCentimeters: 8361.27360,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareMiles: {
QgsUnitTypes.AreaSquareMeters: 2589988.110336,
QgsUnitTypes.AreaSquareKilometers: 2.589988110,
QgsUnitTypes.AreaSquareFeet: 27878400,
QgsUnitTypes.AreaSquareYards: 3097600,
QgsUnitTypes.AreaSquareMiles: 1.0,
QgsUnitTypes.AreaHectares: 258.998811,
QgsUnitTypes.AreaAcres: 640,
QgsUnitTypes.AreaSquareNauticalMiles: 0.75511970898,
QgsUnitTypes.AreaSquareDegrees: 0.000209004361107,
QgsUnitTypes.AreaSquareMillimeters: 2589988110336.0,
QgsUnitTypes.AreaSquareCentimeters: 25899881103.36,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaHectares: {
QgsUnitTypes.AreaSquareMeters: 10000,
QgsUnitTypes.AreaSquareKilometers: 0.01,
QgsUnitTypes.AreaSquareFeet: 107639.1041670972,
QgsUnitTypes.AreaSquareYards: 11959.9004630,
QgsUnitTypes.AreaSquareMiles: 0.00386102,
QgsUnitTypes.AreaHectares: 1.0,
QgsUnitTypes.AreaAcres: 2.471053814,
QgsUnitTypes.AreaSquareNauticalMiles: 0.00291553,
QgsUnitTypes.AreaSquareDegrees: 0.000000806970350,
QgsUnitTypes.AreaSquareMillimeters: 10000000000.0,
QgsUnitTypes.AreaSquareCentimeters: 100000000.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaAcres: {
QgsUnitTypes.AreaSquareMeters: 4046.8564224,
QgsUnitTypes.AreaSquareKilometers: 0.00404686,
QgsUnitTypes.AreaSquareFeet: 43560,
QgsUnitTypes.AreaSquareYards: 4840,
QgsUnitTypes.AreaSquareMiles: 0.0015625,
QgsUnitTypes.AreaHectares: 0.404685642,
QgsUnitTypes.AreaAcres: 1.0,
QgsUnitTypes.AreaSquareNauticalMiles: 0.00117987,
QgsUnitTypes.AreaSquareDegrees: 0.000000326569314,
QgsUnitTypes.AreaSquareMillimeters: 4046856422.4000005,
QgsUnitTypes.AreaSquareCentimeters: 40468564.224,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareNauticalMiles: {
QgsUnitTypes.AreaSquareMeters: 3429904,
QgsUnitTypes.AreaSquareKilometers: 3.4299040,
QgsUnitTypes.AreaSquareFeet: 36919179.39391434,
QgsUnitTypes.AreaSquareYards: 4102131.04376826,
QgsUnitTypes.AreaSquareMiles: 1.324293337,
QgsUnitTypes.AreaHectares: 342.9904000000,
QgsUnitTypes.AreaAcres: 847.54773631,
QgsUnitTypes.AreaSquareNauticalMiles: 1.0,
QgsUnitTypes.AreaSquareDegrees: 0.000276783083025,
QgsUnitTypes.AreaSquareMillimeters: 3429904000000.0,
QgsUnitTypes.AreaSquareCentimeters: 34299040000.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareDegrees: {
QgsUnitTypes.AreaSquareMeters: 12392029030.5,
QgsUnitTypes.AreaSquareKilometers: 12392.029030499,
QgsUnitTypes.AreaSquareFeet: 133386690365.5682220,
QgsUnitTypes.AreaSquareYards: 14820743373.9520263,
QgsUnitTypes.AreaSquareMiles: 4784.5891573967,
QgsUnitTypes.AreaHectares: 1239202.903050,
QgsUnitTypes.AreaAcres: 3062137.060733889,
QgsUnitTypes.AreaSquareNauticalMiles: 3612.93757215,
QgsUnitTypes.AreaSquareDegrees: 1.0,
QgsUnitTypes.AreaSquareMillimeters: 12392029030500000.0,
QgsUnitTypes.AreaSquareCentimeters: 123920290305000.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareMillimeters: {
QgsUnitTypes.AreaSquareMeters: 1e-6,
QgsUnitTypes.AreaSquareKilometers: 1e-12,
QgsUnitTypes.AreaSquareFeet: 0.000010763910417,
QgsUnitTypes.AreaSquareYards: 0.000001195990046,
QgsUnitTypes.AreaSquareMiles: 3.861021585424458e-13,
QgsUnitTypes.AreaHectares: 1e-10,
QgsUnitTypes.AreaAcres: 2.471053814671653e-10,
QgsUnitTypes.AreaSquareNauticalMiles: 2.9155334959812287e-13,
QgsUnitTypes.AreaSquareDegrees: 8.069703496810251e-17,
QgsUnitTypes.AreaSquareMillimeters: 1.0,
QgsUnitTypes.AreaSquareCentimeters: 0.01,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareCentimeters: {
QgsUnitTypes.AreaSquareMeters: 1e-4,
QgsUnitTypes.AreaSquareKilometers: 1e-10,
QgsUnitTypes.AreaSquareFeet: 0.0010763910417,
QgsUnitTypes.AreaSquareYards: 0.0001195990046,
QgsUnitTypes.AreaSquareMiles: 3.861021585424458e-11,
QgsUnitTypes.AreaHectares: 1e-8,
QgsUnitTypes.AreaAcres: 2.471053814671653e-8,
QgsUnitTypes.AreaSquareNauticalMiles: 2.9155334959812287e-11,
QgsUnitTypes.AreaSquareDegrees: 8.069703496810251e-15,
QgsUnitTypes.AreaSquareMillimeters: 100,
QgsUnitTypes.AreaSquareCentimeters: 1.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
}
}
for from_unit in list(expected.keys()):
for to_unit in list(expected[from_unit].keys()):
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(res,
expected_factor,
msg='got {:.15f}, expected {:.15f} when converting from {} to {}'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, QgsUnitTypes.AreaUnknownUnit)
self.assertAlmostEqual(res,
1.0,
msg='got {:.7f}, expected 1.0 when converting from {} to unknown units'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def testLengthMeasureAndUnits(self):
"""Test a variety of length measurements in different CRS and ellipsoid modes, to check that the
calculated lengths and units are always consistent
"""
da = QgsDistanceArea()
da.setSourceCrs(3452)
da.setEllipsoidalMode(False)
da.setEllipsoid("NONE")
daCRS = QgsCoordinateReferenceSystem()
daCRS = da.sourceCrs()
# We check both the measured length AND the units, in case the logic regarding
# ellipsoids and units changes in future
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance,
QgsUnitTypes.toString(units))))
assert ((abs(distance - 2.23606797) < 0.00000001
and units == QgsUnitTypes.DistanceDegrees)
or (abs(distance - 248.52) < 0.01
and units == QgsUnitTypes.DistanceMeters))
da.setEllipsoid("WGS84")
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance,
QgsUnitTypes.toString(units))))
assert ((abs(distance - 2.23606797) < 0.00000001
and units == QgsUnitTypes.DistanceDegrees)
or (abs(distance - 248.52) < 0.01
and units == QgsUnitTypes.DistanceMeters))
da.setEllipsoidalMode(True)
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance,
QgsUnitTypes.toString(units))))
# should always be in Meters
self.assertAlmostEqual(distance, 247555.57, delta=0.01)
self.assertEqual(units, QgsUnitTypes.DistanceMeters)
# test converting the resultant length
distance = da.convertLengthMeasurement(
distance, QgsUnitTypes.DistanceNauticalMiles)
self.assertAlmostEqual(distance, 133.669, delta=0.01)
# now try with a source CRS which is in feet
da.setSourceCrs(27469)
da.setEllipsoidalMode(False)
# measurement should be in feet
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance,
QgsUnitTypes.toString(units))))
self.assertAlmostEqual(distance, 2.23606797, delta=0.000001)
self.assertEqual(units, QgsUnitTypes.DistanceFeet)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance,
QgsUnitTypes.DistanceMeters)
self.assertAlmostEqual(distance, 0.6815, delta=0.001)
da.setEllipsoidalMode(True)
# now should be in Meters again
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print(("measured {} in {}".format(distance,
QgsUnitTypes.toString(units))))
self.assertAlmostEqual(distance, 0.67953772, delta=0.000001)
self.assertEqual(units, QgsUnitTypes.DistanceMeters)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance,
QgsUnitTypes.DistanceFeet)
self.assertAlmostEqual(distance, 2.2294, delta=0.001)
def testAreaMeasureAndUnits(self):
"""Test a variety of area measurements in different CRS and ellipsoid modes, to check that the
calculated areas and units are always consistent
"""
da = QgsDistanceArea()
da.setSourceCrs(3452)
da.setEllipsoidalMode(False)
da.setEllipsoid("NONE")
daCRS = QgsCoordinateReferenceSystem()
daCRS = da.sourceCrs()
polygon = QgsGeometry.fromPolygon(
[[
QgsPoint(0, 0), QgsPoint(1, 0), QgsPoint(1, 1), QgsPoint(2, 1), QgsPoint(2, 2), QgsPoint(0, 2), QgsPoint(0, 0),
]]
)
# We check both the measured area AND the units, in case the logic regarding
# ellipsoids and units changes in future
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
assert ((abs(area - 3.0) < 0.00000001 and units == QgsUnitTypes.AreaSquareDegrees) or
(abs(area - 37176087091.5) < 0.1 and units == QgsUnitTypes.AreaSquareMeters))
da.setEllipsoid("WGS84")
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
assert ((abs(area - 3.0) < 0.00000001 and units == QgsUnitTypes.AreaSquareDegrees) or
(abs(area - 37176087091.5) < 0.1 and units == QgsUnitTypes.AreaSquareMeters))
da.setEllipsoidalMode(True)
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
# should always be in Meters Squared
self.assertAlmostEqual(area, 37416879192.9, delta=0.1)
self.assertEqual(units, QgsUnitTypes.AreaSquareMeters)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareMiles)
self.assertAlmostEqual(area, 14446.7378, delta=0.001)
# now try with a source CRS which is in feet
polygon = QgsGeometry.fromPolygon(
[[
QgsPoint(1850000, 4423000), QgsPoint(1851000, 4423000), QgsPoint(1851000, 4424000), QgsPoint(1852000, 4424000), QgsPoint(1852000, 4425000), QgsPoint(1851000, 4425000), QgsPoint(1850000, 4423000)
]]
)
da.setSourceCrs(27469)
da.setEllipsoidalMode(False)
# measurement should be in square feet
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(area, 2000000, delta=0.001)
self.assertEqual(units, QgsUnitTypes.AreaSquareFeet)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards)
self.assertAlmostEqual(area, 222222.2222, delta=0.001)
da.setEllipsoidalMode(True)
# now should be in Square Meters again
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(area, 184149.37, delta=1.0)
self.assertEqual(units, QgsUnitTypes.AreaSquareMeters)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards)
self.assertAlmostEqual(area, 220240.8172549, delta=1.0)
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = flowTraceDialog()
# get current selected layer
clayer = self.iface.mapCanvas().currentLayer()
# set layer name in dialog
self.dlg.labelLayer.setText(clayer.name())
# set number of selected features in dialog
self.dlg.labelNumFeatures.setText(str(len(clayer.selectedFeatures())))
# print(self.iface.mapCanvas().mapUnits())
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# get direct from dialog
direction = self.dlg.downstream_radio_button.isChecked()
final_list = []
#add tolerance value
# setup total length
totallength = 0.0
# distance = 0
#setup distance
distance = QgsDistanceArea()
# the unit of measure will be set to the same as the layer
# maybe it would be better to set it to the map CRS
distance.setSourceCrs(clayer.sourceCrs(),
QgsProject.instance().transformContext())
if result:
#setup final selection list
#setup temporary selection list
selection_list = []
#add tolerance value
tolerance = 1
#get current layer
clayer = self.iface.mapCanvas().currentLayer()
# print (clayer.name())
if clayer is None:
return
#get provider
provider = clayer.dataProvider()
#get selected features
features = clayer.selectedFeatures()
# get crs for tolerance setting
crs = self.iface.activeLayer().crs().authid()
# print (crs)
if crs == 'EPSG:4269':
rec = .0001
tolerance = .0001
else:
#rec = .1
rec = self.dlg.SpinBoxTolerance.value()
#iterate thru features to add to lists
for feature in features:
# add selected features to final list
final_list.append(feature.id())
# add selected features to selection list for while loop
selection_list.append(feature.id())
#get feature geometry
geom = feature.geometry()
totallength = totallength + distance.measureLength(geom)
# print (QgsDistanceArea.lengthUnits)
# https://qgis.org/api/classQgsWkbTypes.html
if geom.type() != 1:
print("Geometry not allowed")
QMessageBox.information(
None, "Flow Trace",
"Geometry not allowed, \nPlease select line geometry only."
)
return
#loop thru selection list
while selection_list:
#get selected features
request = QgsFeatureRequest().setFilterFid(selection_list[0])
# request = QgsFeatureRequest()
feature = next(clayer.getFeatures(request))
geom = feature.geometry()
# get nodes
nodes = self.get_geometry(feature.geometry())
# get upstream node
if direction:
upstream_coord = nodes[-1]
# print (upstream_coord)
else:
upstream_coord = nodes[0]
# print (upstream_coord)
# select all features around upstream coordinate
# using a bounding box
rectangle = QgsRectangle(upstream_coord.x() - rec,
upstream_coord.y() - rec,
upstream_coord.x() + rec,
upstream_coord.y() + rec)
# rectangle = QgsRectangle (minx, miny, maxx, maxy)
request = QgsFeatureRequest().setFilterRect(rectangle)
features = clayer.getFeatures(request)
#iterate thru requested features
for feature in features:
# get nodes
nodes = self.get_geometry(feature.geometry())
#downstream_coord = nodes[-1]
# get upstream node
if direction:
downstream_coord = nodes[0]
# print (upstream_coord)
else:
downstream_coord = nodes[-1]
# print (upstream_coord)
#get distance from downstream node to upstream node
dist = distance.measureLine(downstream_coord,
upstream_coord)
if dist < tolerance:
#add feature to final list
final_list.append(feature.id())
if feature.id() not in selection_list:
#add feature to selection list
selection_list.append(feature.id())
# Length from Line
totallength = totallength + distance.measureLength(
feature.geometry())
#remove feature from selection list
selection_list.pop(0)
#select features using final_list
for fid in final_list:
clayer.select(fid)
#refresh the canvas
self.iface.mapCanvas().refresh()
#add message box about length and number of features
QMessageBox.information(
None, "Flow Trace Complete",
"Total Features Selected: " + str(len(final_list)) + "\r\n" +
" Length: " + str(round(totallength, 2)) + ' ' +
QgsUnitTypes.toString(distance.lengthUnits()))
def do_stratified_random_sampling(dockwidget):
# first check input files requirements
if not valid_file_selected_in(dockwidget.QCBox_ThematicRaster, "thematic raster"):
return
if not valid_file_selected_in(dockwidget.QCBox_CategRaster_StraRS, "categorical raster"):
return
# get and define some variables
min_distance = float(dockwidget.minDistance_StraRS.value())
ThematicR = Raster(file_selected_combo_box=dockwidget.QCBox_ThematicRaster,
band=int(dockwidget.QCBox_band_ThematicRaster.currentText()),
nodata=int(dockwidget.nodata_ThematicRaster.value()))
CategoricalR = Raster(file_selected_combo_box=dockwidget.QCBox_CategRaster_StraRS,
band=int(dockwidget.QCBox_band_CategRaster_StraRS.currentText()),
nodata=int(dockwidget.nodata_CategRaster_StraRS.value()))
# get values from category table #########
pixel_values = []
number_of_samples = []
for row in range(dockwidget.QTableW_StraRS.rowCount()):
pixel_values.append(int(dockwidget.QTableW_StraRS.item(row, 0).text()))
number_of_samples.append(dockwidget.QTableW_StraRS.item(row, 2).text())
# convert and check if number of samples only positive integers
try:
number_of_samples = [int(ns) for ns in number_of_samples]
if True in [ns < 0 for ns in number_of_samples]:
raise Exception
except:
iface.messageBar().pushMessage("AcATaMa", "Error, the number of samples should be only positive integers",
level=Qgis.Warning)
return
total_of_samples = sum(number_of_samples)
if total_of_samples == 0:
iface.messageBar().pushMessage("AcATaMa", "Error, no number of samples configured!",
level=Qgis.Warning)
return
# check neighbors aggregation
if dockwidget.widget_generate_StraRS.QGBox_neighbour_aggregation.isChecked():
number_of_neighbors = int(dockwidget.widget_generate_StraRS.QCBox_NumberOfNeighbors.currentText())
same_class_of_neighbors = int(dockwidget.widget_generate_StraRS.QCBox_SameClassOfNeighbors.currentText())
neighbor_aggregation = (number_of_neighbors, same_class_of_neighbors)
else:
neighbor_aggregation = None
# set the attempts_by_sampling
if dockwidget.widget_generate_StraRS.button_attempts_by_sampling.isChecked():
attempts_by_sampling = int(dockwidget.widget_generate_StraRS.attempts_by_sampling.value())
else:
attempts_by_sampling = None
# set the method of stratified sampling and save StraRS config
if dockwidget.QCBox_StraRS_Method.currentText().startswith("Fixed values"):
sampling_method = "fixed values"
srs_config = None
if dockwidget.QCBox_StraRS_Method.currentText().startswith("Area based proportion"):
sampling_method = "area based proportion"
srs_config = {}
# save total expected std error
srs_config["total_std_error"] = dockwidget.TotalExpectedSE.value()
# get std_dev from table
srs_config["std_dev"] = []
for row in range(dockwidget.QTableW_StraRS.rowCount()):
srs_config["std_dev"].append(float(dockwidget.QTableW_StraRS.item(row, 3).text()))
# first select the target dir for save the sampling file
suggested_filename = os.path.join(os.path.dirname(ThematicR.file_path), "stratified_random_sampling.gpkg")
output_file, _ = QFileDialog.getSaveFileName(dockwidget,
dockwidget.tr("Select the output file to save the sampling"),
suggested_filename,
dockwidget.tr("GeoPackage files (*.gpkg);;Shape files (*.shp);;All files (*.*)"))
if output_file == '':
return
# define the random seed
if dockwidget.widget_generate_StraRS.button_random_seed_by_user.isChecked():
random_seed = dockwidget.widget_generate_StraRS.random_seed_by_user.text()
try:
random_seed = int(random_seed)
except:
pass
else:
random_seed = None
# process
sampling = Sampling("stratified", ThematicR, CategoricalR, sampling_method,
srs_config=srs_config, output_file=output_file)
sampling.generate_sampling_points(pixel_values, number_of_samples, min_distance,
neighbor_aggregation, attempts_by_sampling,
dockwidget.widget_generate_StraRS.QPBar_GenerateSampling,
random_seed)
# zero points
if sampling.total_of_samples < total_of_samples and sampling.total_of_samples == 0:
# delete instance where storage all sampling generated
Sampling.samplings.pop(sampling.filename, None)
iface.messageBar().pushMessage("AcATaMa", "Error, could not generate any stratified random points with this settings, "
"attempts exceeded", level=Qgis.Warning, duration=-1)
return
# success
if sampling.total_of_samples == total_of_samples:
qgslayer = load_layer(sampling.output_file)
iface.messageBar().pushMessage("AcATaMa", "Generate the stratified random sampling, completed",
level=Qgis.Success)
# success but not completed
if sampling.total_of_samples < total_of_samples and sampling.total_of_samples > 0:
qgslayer = load_layer(sampling.output_file)
iface.messageBar().pushMessage("AcATaMa", "Generated the stratified random sampling, but can not generate requested number of "
"random points {}/{}, attempts exceeded".format(sampling.total_of_samples, total_of_samples),
level=Qgis.Warning, duration=-1)
# check the thematic raster map unit to calculate the minimum distances
if min_distance > 0:
if ThematicR.qgs_layer.crs().mapUnits() == QgsUnitTypes.DistanceUnknownUnit:
iface.messageBar().pushMessage("AcATaMa",
"The thematic raster \"{}\" does not have a valid map unit, AcATaMa used \"{}\" as the base unit to "
"calculate the minimum distances.".format(
ThematicR.qgs_layer.name(), QgsUnitTypes.toString(qgslayer.crs().mapUnits())),
level=Qgis.Warning, duration=-1)
def testAreaFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between areal units"""
expected = {
QgsUnitTypes.AreaSquareMeters: {
QgsUnitTypes.AreaSquareMeters: 1.0,
QgsUnitTypes.AreaSquareKilometers: 1e-6,
QgsUnitTypes.AreaSquareFeet: 10.7639104,
QgsUnitTypes.AreaSquareYards: 1.19599,
QgsUnitTypes.AreaSquareMiles: 3.86102e-7,
QgsUnitTypes.AreaHectares: 0.0001,
QgsUnitTypes.AreaAcres: 0.000247105,
QgsUnitTypes.AreaSquareNauticalMiles: 2.91553e-7,
QgsUnitTypes.AreaSquareDegrees: 0.000000000080697,
QgsUnitTypes.AreaSquareMillimeters: 1e6,
QgsUnitTypes.AreaSquareCentimeters: 1e4,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareKilometers: {
QgsUnitTypes.AreaSquareMeters: 1e6,
QgsUnitTypes.AreaSquareKilometers: 1,
QgsUnitTypes.AreaSquareFeet: 10763910.4167097,
QgsUnitTypes.AreaSquareYards: 1195990.04630108,
QgsUnitTypes.AreaSquareMiles: 0.386102158,
QgsUnitTypes.AreaHectares: 100,
QgsUnitTypes.AreaAcres: 247.105381467,
QgsUnitTypes.AreaSquareNauticalMiles: 0.291553349598,
QgsUnitTypes.AreaSquareDegrees: 0.000080697034968,
QgsUnitTypes.AreaSquareMillimeters: 1e12,
QgsUnitTypes.AreaSquareCentimeters: 1e10,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareFeet: {
QgsUnitTypes.AreaSquareMeters: 0.092903,
QgsUnitTypes.AreaSquareKilometers: 9.2903e-8,
QgsUnitTypes.AreaSquareFeet: 1.0,
QgsUnitTypes.AreaSquareYards: 0.11111111111,
QgsUnitTypes.AreaSquareMiles: 3.58701e-8,
QgsUnitTypes.AreaHectares: 9.2903e-6,
QgsUnitTypes.AreaAcres: 2.29568e-5,
QgsUnitTypes.AreaSquareNauticalMiles: 2.70862e-8,
QgsUnitTypes.AreaSquareDegrees: 0.000000000007497,
QgsUnitTypes.AreaSquareMillimeters: 92903.04,
QgsUnitTypes.AreaSquareCentimeters: 929.0304,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareYards: {
QgsUnitTypes.AreaSquareMeters: 0.836127360,
QgsUnitTypes.AreaSquareKilometers: 8.36127e-7,
QgsUnitTypes.AreaSquareFeet: 9.0,
QgsUnitTypes.AreaSquareYards: 1.0,
QgsUnitTypes.AreaSquareMiles: 3.22831e-7,
QgsUnitTypes.AreaHectares: 8.3612736E-5,
QgsUnitTypes.AreaAcres: 0.00020661157,
QgsUnitTypes.AreaSquareNauticalMiles: 2.43776e-7,
QgsUnitTypes.AreaSquareDegrees: 0.000000000067473,
QgsUnitTypes.AreaSquareMillimeters: 836127.360,
QgsUnitTypes.AreaSquareCentimeters: 8361.27360,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareMiles: {
QgsUnitTypes.AreaSquareMeters: 2589988.110336,
QgsUnitTypes.AreaSquareKilometers: 2.589988110,
QgsUnitTypes.AreaSquareFeet: 27878400,
QgsUnitTypes.AreaSquareYards: 3097600,
QgsUnitTypes.AreaSquareMiles: 1.0,
QgsUnitTypes.AreaHectares: 258.998811,
QgsUnitTypes.AreaAcres: 640,
QgsUnitTypes.AreaSquareNauticalMiles: 0.75511970898,
QgsUnitTypes.AreaSquareDegrees: 0.000209004361107,
QgsUnitTypes.AreaSquareMillimeters: 2589988110336.0,
QgsUnitTypes.AreaSquareCentimeters: 25899881103.36,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaHectares: {
QgsUnitTypes.AreaSquareMeters: 10000,
QgsUnitTypes.AreaSquareKilometers: 0.01,
QgsUnitTypes.AreaSquareFeet: 107639.1041670972,
QgsUnitTypes.AreaSquareYards: 11959.9004630,
QgsUnitTypes.AreaSquareMiles: 0.00386102,
QgsUnitTypes.AreaHectares: 1.0,
QgsUnitTypes.AreaAcres: 2.471053814,
QgsUnitTypes.AreaSquareNauticalMiles: 0.00291553,
QgsUnitTypes.AreaSquareDegrees: 0.000000806970350,
QgsUnitTypes.AreaSquareMillimeters: 10000000000.0,
QgsUnitTypes.AreaSquareCentimeters: 100000000.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaAcres: {
QgsUnitTypes.AreaSquareMeters: 4046.8564224,
QgsUnitTypes.AreaSquareKilometers: 0.00404686,
QgsUnitTypes.AreaSquareFeet: 43560,
QgsUnitTypes.AreaSquareYards: 4840,
QgsUnitTypes.AreaSquareMiles: 0.0015625,
QgsUnitTypes.AreaHectares: 0.404685642,
QgsUnitTypes.AreaAcres: 1.0,
QgsUnitTypes.AreaSquareNauticalMiles: 0.00117987,
QgsUnitTypes.AreaSquareDegrees: 0.000000326569314,
QgsUnitTypes.AreaSquareMillimeters: 4046856422.4000005,
QgsUnitTypes.AreaSquareCentimeters: 40468564.224,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareNauticalMiles: {
QgsUnitTypes.AreaSquareMeters: 3429904,
QgsUnitTypes.AreaSquareKilometers: 3.4299040,
QgsUnitTypes.AreaSquareFeet: 36919179.39391434,
QgsUnitTypes.AreaSquareYards: 4102131.04376826,
QgsUnitTypes.AreaSquareMiles: 1.324293337,
QgsUnitTypes.AreaHectares: 342.9904000000,
QgsUnitTypes.AreaAcres: 847.54773631,
QgsUnitTypes.AreaSquareNauticalMiles: 1.0,
QgsUnitTypes.AreaSquareDegrees: 0.000276783083025,
QgsUnitTypes.AreaSquareMillimeters: 3429904000000.0,
QgsUnitTypes.AreaSquareCentimeters: 34299040000.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareDegrees: {
QgsUnitTypes.AreaSquareMeters: 12392029030.5,
QgsUnitTypes.AreaSquareKilometers: 12392.029030499,
QgsUnitTypes.AreaSquareFeet: 133386690365.5682220,
QgsUnitTypes.AreaSquareYards: 14820743373.9520263,
QgsUnitTypes.AreaSquareMiles: 4784.5891573967,
QgsUnitTypes.AreaHectares: 1239202.903050,
QgsUnitTypes.AreaAcres: 3062137.060733889,
QgsUnitTypes.AreaSquareNauticalMiles: 3612.93757215,
QgsUnitTypes.AreaSquareDegrees: 1.0,
QgsUnitTypes.AreaSquareMillimeters: 12392029030500000.0,
QgsUnitTypes.AreaSquareCentimeters: 123920290305000.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareMillimeters: {
QgsUnitTypes.AreaSquareMeters: 1e-6,
QgsUnitTypes.AreaSquareKilometers: 1e-12,
QgsUnitTypes.AreaSquareFeet: 0.000010763910417,
QgsUnitTypes.AreaSquareYards: 0.000001195990046,
QgsUnitTypes.AreaSquareMiles: 3.861021585424458e-13,
QgsUnitTypes.AreaHectares: 1e-10,
QgsUnitTypes.AreaAcres: 2.471053814671653e-10,
QgsUnitTypes.AreaSquareNauticalMiles: 2.9155334959812287e-13,
QgsUnitTypes.AreaSquareDegrees: 8.069703496810251e-17,
QgsUnitTypes.AreaSquareMillimeters: 1.0,
QgsUnitTypes.AreaSquareCentimeters: 0.01,
QgsUnitTypes.AreaUnknownUnit: 1.0
},
QgsUnitTypes.AreaSquareCentimeters: {
QgsUnitTypes.AreaSquareMeters: 1e-4,
QgsUnitTypes.AreaSquareKilometers: 1e-10,
QgsUnitTypes.AreaSquareFeet: 0.0010763910417,
QgsUnitTypes.AreaSquareYards: 0.0001195990046,
QgsUnitTypes.AreaSquareMiles: 3.861021585424458e-11,
QgsUnitTypes.AreaHectares: 1e-8,
QgsUnitTypes.AreaAcres: 2.471053814671653e-8,
QgsUnitTypes.AreaSquareNauticalMiles: 2.9155334959812287e-11,
QgsUnitTypes.AreaSquareDegrees: 8.069703496810251e-15,
QgsUnitTypes.AreaSquareMillimeters: 100,
QgsUnitTypes.AreaSquareCentimeters: 1.0,
QgsUnitTypes.AreaUnknownUnit: 1.0
}
}
for from_unit in list(expected.keys()):
for to_unit in list(expected[from_unit].keys()):
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(
res,
expected_factor,
msg=
'got {:.15f}, expected {:.15f} when converting from {} to {}'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(
from_unit, QgsUnitTypes.AreaUnknownUnit)
self.assertAlmostEqual(
res,
1.0,
msg=
'got {:.7f}, expected 1.0 when converting from {} to unknown units'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def testAngleFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between angular units"""
expected = {
QgsUnitTypes.AngleDegrees: {
QgsUnitTypes.AngleDegrees: 1.0,
QgsUnitTypes.AngleRadians: 0.0174533,
QgsUnitTypes.AngleGon: 1.1111111,
QgsUnitTypes.AngleMinutesOfArc: 60,
QgsUnitTypes.AngleSecondsOfArc: 3600,
QgsUnitTypes.AngleTurn: 0.00277777777778
},
QgsUnitTypes.AngleRadians: {
QgsUnitTypes.AngleDegrees: 57.2957795,
QgsUnitTypes.AngleRadians: 1.0,
QgsUnitTypes.AngleGon: 63.6619772,
QgsUnitTypes.AngleMinutesOfArc: 3437.7467708,
QgsUnitTypes.AngleSecondsOfArc: 206264.8062471,
QgsUnitTypes.AngleTurn: 0.159154943092
},
QgsUnitTypes.AngleGon: {
QgsUnitTypes.AngleDegrees: 0.9000000,
QgsUnitTypes.AngleRadians: 0.015707968623450838802,
QgsUnitTypes.AngleGon: 1.0,
QgsUnitTypes.AngleMinutesOfArc: 54.0000000,
QgsUnitTypes.AngleSecondsOfArc: 3240.0000000,
QgsUnitTypes.AngleTurn: 0.0025
},
QgsUnitTypes.AngleMinutesOfArc: {
QgsUnitTypes.AngleDegrees: 0.016666672633390722247,
QgsUnitTypes.AngleRadians: 0.00029088831280398030638,
QgsUnitTypes.AngleGon: 0.018518525464057963154,
QgsUnitTypes.AngleMinutesOfArc: 1.0,
QgsUnitTypes.AngleSecondsOfArc: 60.0,
QgsUnitTypes.AngleTurn: 4.62962962962963e-05
},
QgsUnitTypes.AngleSecondsOfArc: {
QgsUnitTypes.AngleDegrees: 0.00027777787722304257169,
QgsUnitTypes.AngleRadians: 4.848138546730629518e-6,
QgsUnitTypes.AngleGon: 0.0003086420910674814405,
QgsUnitTypes.AngleMinutesOfArc: 0.016666672633325253783,
QgsUnitTypes.AngleSecondsOfArc: 1.0,
QgsUnitTypes.AngleTurn: 7.71604938271605e-07
},
QgsUnitTypes.AngleTurn: {
QgsUnitTypes.AngleDegrees: 360.0,
QgsUnitTypes.AngleRadians: 6.2831853071795,
QgsUnitTypes.AngleGon: 400.0,
QgsUnitTypes.AngleMinutesOfArc: 21600,
QgsUnitTypes.AngleSecondsOfArc: 1296000,
QgsUnitTypes.AngleTurn: 1
}
}
for from_unit in list(expected.keys()):
for to_unit in list(expected[from_unit].keys()):
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(
res,
expected_factor,
msg=
'got {:.7f}, expected {:.7f} when converting from {} to {}'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(
from_unit, QgsUnitTypes.AngleUnknownUnit)
self.assertAlmostEqual(
res,
1.0,
msg=
'got {:.7f}, expected 1.0 when converting from {} to unknown units'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def setUnits(self, units):
self.label.setText(QgsUnitTypes.toString(units))
self.warning_label.setVisible(units == QgsUnitTypes.DistanceDegrees)
def save_config(self, file_out):
import yaml
from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa
def setup_yaml():
"""
Keep dump ordered with orderedDict
"""
represent_dict_order = lambda self, data: self.represent_mapping(
'tag:yaml.org,2002:map', list(data.items()))
yaml.add_representer(OrderedDict, represent_dict_order)
setup_yaml()
data = OrderedDict()
data["thematic_raster"] = \
{"path": get_current_file_path_in(AcATaMa.dockwidget.QCBox_ThematicRaster, show_message=False),
"band": int(AcATaMa.dockwidget.QCBox_band_ThematicRaster.currentText())
if AcATaMa.dockwidget.QCBox_band_ThematicRaster.currentText() else None,
"nodata": AcATaMa.dockwidget.nodata_ThematicRaster.value()}
data["sampling_layer"] = get_file_path_of_layer(self.sampling_layer)
data["dialog_size"] = self.dialog_size
data["grid_view_widgets"] = {
"columns": self.grid_columns,
"rows": self.grid_rows
}
data["current_sample_idx"] = self.current_sample_idx
data["fit_to_sample"] = self.fit_to_sample
data["is_completed"] = self.is_completed
data["view_widgets_config"] = self.view_widgets_config
data["classification_buttons"] = self.buttons_config
# save samples status
points_config = {}
for pnt_idx, point in enumerate(self.points):
if point.is_classified:
points_config[pnt_idx] = {
"classif_id": point.classif_id,
"shape_id": point.shape_id
}
data["points"] = points_config
# save the samples order
data["points_order"] = [p.shape_id for p in self.points]
# save sampling selected in accuracy assessment
data["accuracy_assessment_sampling_file"] = get_current_file_path_in(
AcATaMa.dockwidget.QCBox_SamplingFile_AA, show_message=False)
# save config of the accuracy assessment dialog if exists
if self.accuracy_assessment:
data["accuracy_assessment_dialog"] = {
"area_unit":
QgsUnitTypes.toString(self.accuracy_assessment.area_unit),
"z_score":
self.accuracy_assessment.z_score,
"csv_separator":
self.accuracy_assessment.csv_separator,
"csv_decimal":
self.accuracy_assessment.csv_decimal,
}
with open(file_out, 'w') as yaml_file:
yaml.dump(data, yaml_file)
def testAreaMeasureAndUnits(self):
"""Test a variety of area measurements in different CRS and ellipsoid modes, to check that the
calculated areas and units are always consistent
"""
da = QgsDistanceArea()
da.setSourceCrs(QgsCoordinateReferenceSystem.fromSrsId(3452))
da.setEllipsoid("NONE")
polygon = QgsGeometry.fromPolygon(
[[
QgsPointXY(0, 0), QgsPointXY(1, 0), QgsPointXY(1, 1), QgsPointXY(2, 1), QgsPointXY(2, 2), QgsPointXY(0, 2), QgsPointXY(0, 0),
]]
)
# We check both the measured area AND the units, in case the logic regarding
# ellipsoids and units changes in future
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
assert ((abs(area - 3.0) < 0.00000001 and units == QgsUnitTypes.AreaSquareDegrees) or
(abs(area - 37176087091.5) < 0.1 and units == QgsUnitTypes.AreaSquareMeters))
da.setEllipsoid("WGS84")
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
# should always be in Meters Squared
self.assertAlmostEqual(area, 37416879192.9, delta=0.1)
self.assertEqual(units, QgsUnitTypes.AreaSquareMeters)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareMiles)
self.assertAlmostEqual(area, 14446.7378, delta=0.001)
# now try with a source CRS which is in feet
polygon = QgsGeometry.fromPolygon(
[[
QgsPointXY(1850000, 4423000), QgsPointXY(1851000, 4423000), QgsPointXY(1851000, 4424000), QgsPointXY(1852000, 4424000), QgsPointXY(1852000, 4425000), QgsPointXY(1851000, 4425000), QgsPointXY(1850000, 4423000)
]]
)
da.setSourceCrs(QgsCoordinateReferenceSystem.fromSrsId(27469))
da.setEllipsoid("NONE")
# measurement should be in square feet
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(area, 2000000, delta=0.001)
self.assertEqual(units, QgsUnitTypes.AreaSquareFeet)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards)
self.assertAlmostEqual(area, 222222.2222, delta=0.001)
da.setEllipsoid("WGS84")
# now should be in Square Meters again
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(area, 184149.37, delta=1.0)
self.assertEqual(units, QgsUnitTypes.AreaSquareMeters)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards)
self.assertAlmostEqual(area, 220240.8172549, delta=1.0)
def testMeasureLineProjectedWorldPoints(self):
# +-+
# | |
# +-+ +
# checking returned length_mapunits/projected_points of diffferent world points with results from SpatiaLite ST_Project
da_3068 = QgsDistanceArea()
da_3068.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:3068'))
if (da_3068.sourceCrs().isGeographic()):
da_3068.setEllipsoid(da_3068.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_3068.sourceCrs().authid(), 'EPSG:3068')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:3068', da_3068.sourceCrs().authid(), da_3068.sourceCrs().description(), da_3068.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_3068.lengthUnits()), da_3068.sourceCrs().projectionAcronym(), da_3068.sourceCrs().ellipsoidAcronym())))
da_wsg84 = QgsDistanceArea()
da_wsg84.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4326'))
if (da_wsg84.sourceCrs().isGeographic()):
da_wsg84.setEllipsoid(da_wsg84.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_wsg84.sourceCrs().authid(), 'EPSG:4326')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}] ellipsoid[{}]".format(u'EPSG:4326', da_wsg84.sourceCrs().authid(), da_wsg84.sourceCrs().description(), da_wsg84.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_wsg84.lengthUnits()), da_wsg84.sourceCrs().projectionAcronym(), da_wsg84.sourceCrs().ellipsoidAcronym(), da_wsg84.ellipsoid())))
da_4314 = QgsDistanceArea()
da_4314.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4314'))
if (da_4314.sourceCrs().isGeographic()):
da_4314.setEllipsoid(da_4314.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_4314.sourceCrs().authid(), 'EPSG:4314')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:4314', da_4314.sourceCrs().authid(), da_4314.sourceCrs().description(), da_4314.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_4314.lengthUnits()), da_4314.sourceCrs().projectionAcronym(), da_4314.sourceCrs().ellipsoidAcronym())))
da_4805 = QgsDistanceArea()
da_4805.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4805'))
if (da_4805.sourceCrs().isGeographic()):
da_4805.setEllipsoid(da_4805.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_4805.sourceCrs().authid(), 'EPSG:4805')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:4805', da_4805.sourceCrs().authid(), da_4805.sourceCrs().description(), da_4805.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_4805.lengthUnits()), da_4805.sourceCrs().projectionAcronym(), da_4805.sourceCrs().ellipsoidAcronym())))
# EPSG:5665 unknown, why?
da_5665 = QgsDistanceArea()
da_5665.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:5665'))
if (da_5665.sourceCrs().isGeographic()):
da_5665.setEllipsoid(da_5665.sourceCrs().ellipsoidAcronym())
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:5665', da_5665.sourceCrs().authid(), da_5665.sourceCrs().description(), da_5665.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_5665.lengthUnits()), da_5665.sourceCrs().projectionAcronym(), da_5665.sourceCrs().ellipsoidAcronym())))
#self.assertEqual(da_5665.sourceCrs().authid(), 'EPSG:5665')
da_25833 = QgsDistanceArea()
da_25833.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:25833'))
if (da_25833.sourceCrs().isGeographic()):
da_25833.setEllipsoid(da_25833.sourceCrs().ellipsoidAcronym())
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:25833', da_25833.sourceCrs().authid(), da_25833.sourceCrs().description(), da_25833.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_25833.lengthUnits()), da_25833.sourceCrs().projectionAcronym(), da_25833.sourceCrs().ellipsoidAcronym())))
self.assertEqual(da_25833.sourceCrs().authid(), 'EPSG:25833')
# Berlin - Brandenburg Gate - Quadriga
point_berlin_3068 = QgsPointXY(23183.38449999984, 21047.3225000017)
point_berlin_3068_project = point_berlin_3068.project(1, (math.pi / 2))
point_meter_result = QgsPointXY(0, 0)
length_meter_mapunits, point_meter_result = da_3068.measureLineProjected(point_berlin_3068, 1.0, (math.pi / 2))
pprint(point_meter_result)
print('-I-> Berlin 3068 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_3068.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 1, da_3068.lengthUnits(), True), '1.0 m')
self.assertEqual(point_meter_result.toString(7), point_berlin_3068_project.toString(7))
point_berlin_wsg84 = QgsPointXY(13.37770458660236, 52.51627178856762)
point_berlin_wsg84_project = QgsPointXY(13.37771931736259, 52.51627178856669)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_berlin_wsg84, 1.0, (math.pi / 2))
print('-I-> Berlin Wsg84 length_meter_mapunits[{}] point_meter_result[{}] ellipsoid[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 20, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText(), da_wsg84.ellipsoid()))
# for unknown reasons, this is returning '0.00001473026 m' instead of '0.00001473026 deg' when using da_wsg84.lengthUnits()
# self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits,11,da_wsg84.lengthUnits(),True), '0.00001473026 deg')
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 11, QgsUnitTypes.DistanceDegrees, True), '0.00001473026 deg')
self.assertEqual(point_meter_result.toString(7), point_berlin_wsg84_project.toString(7))
point_berlin_4314 = QgsPointXY(13.37944343021465, 52.51767872437083)
point_berlin_4314_project = QgsPointXY(13.37945816324759, 52.5176787243699)
length_meter_mapunits, point_meter_result = da_4314.measureLineProjected(point_berlin_4314, 1.0, (math.pi / 2))
print('-I-> Berlin 4314 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_4314.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 9, QgsUnitTypes.DistanceDegrees, True), '0.000014733 deg')
self.assertEqual(point_meter_result.toString(7), point_berlin_4314_project.toString(7))
point_berlin_4805 = QgsPointXY(31.04960570069176, 52.5174657497405)
point_berlin_4805_project = QgsPointXY(31.04962043365347, 52.51746574973957)
length_meter_mapunits, point_meter_result = da_4805.measureLineProjected(point_berlin_4805, 1.0, (math.pi / 2))
print('-I-> Berlin 4805 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_4805.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 9, QgsUnitTypes.DistanceDegrees, True), '0.000014733 deg')
self.assertEqual(point_meter_result.toString(7), point_berlin_4805_project.toString(7))
point_berlin_25833 = QgsPointXY(389918.0748318382, 5819698.772194743)
point_berlin_25833_project = point_berlin_25833.project(1, (math.pi / 2))
length_meter_mapunits, point_meter_result = da_25833.measureLineProjected(point_berlin_25833, 1.0, (math.pi / 2))
print('-I-> Berlin 25833 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_25833.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_25833.lengthUnits(), True), '1.0000000 m')
self.assertEqual(point_meter_result.toString(7), point_berlin_25833_project.toString(7))
if da_5665.sourceCrs().authid() != "":
point_berlin_5665 = QgsPointXY(3389996.871728864, 5822169.719727578)
point_berlin_5665_project = point_berlin_5665.project(1, (math.pi / 2))
length_meter_mapunits, point_meter_result = da_5665.measureLineProjected(point_berlin_5665, 1.0, (math.pi / 2))
print('-I-> Berlin 5665 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_5665.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 1.0, da_5665.lengthUnits(), True), '1.0 m')
self.assertEqual(point_meter_result.toString(7), point_berlin_5665_project.toString(7))
print('\n12 points ''above over'' and on the Equator')
point_wsg84 = QgsPointXY(25.7844, 71.1725)
point_wsg84_project = QgsPointXY(25.78442775215388, 71.17249999999795)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Nordkap, Norway - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, QgsUnitTypes.DistanceDegrees, True), '0.0000278 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(24.95995, 60.16841)
point_wsg84_project = QgsPointXY(24.95996801277454, 60.16840999999877)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Helsinki, Finnland - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001801 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(12.599278, 55.692861)
point_wsg84_project = QgsPointXY(12.59929390161872, 55.69286099999897)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Copenhagen, Denmark - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001590 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-0.001389, 51.477778)
point_wsg84_project = QgsPointXY(-0.001374606184398, 51.4777779999991)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Royal Greenwich Observatory, United Kingdom - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001439 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(7.58769, 47.55814)
point_wsg84_project = QgsPointXY(7.587703287209086, 47.55813999999922)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Basel, Switzerland - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001329 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(11.255278, 43.775278)
point_wsg84_project = QgsPointXY(11.25529042107924, 43.77527799999933)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Florenz, Italy - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001242 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(14.514722, 35.899722)
point_wsg84_project = QgsPointXY(14.51473307693308, 35.89972199999949)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Valletta, Malta - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001108 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-79.933333, 32.783333)
point_wsg84_project = QgsPointXY(-79.93332232547254, 32.78333299999955)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Charlston, South Carolina - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001067 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-17.6666666, 27.733333)
point_wsg84_project = QgsPointXY(-17.66665645831515, 27.73333299999962)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Ferro, Spain - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001014 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-99.133333, 19.433333)
point_wsg84_project = QgsPointXY(-99.1333234776827, 19.43333299999975)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Mexico City, Mexico - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000952 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-79.894444, 9.341667)
point_wsg84_project = QgsPointXY(-79.89443489691369, 9.341666999999882)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Colón, Panama - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000910 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-74.075833, 4.598056)
point_wsg84_project = QgsPointXY(-74.07582398803629, 4.598055999999943)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Bogotá, Colombia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000901 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(0, 0)
point_wsg84_project = QgsPointXY(0.000008983152841, 0)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Equator, Atlantic Ocean - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000898 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
print('\n12 points ''down under'' and 1 point that should be considered invalid')
point_wsg84 = QgsPointXY(-78.509722, -0.218611)
point_wsg84_project = QgsPointXY(-78.50971301678221, -0.218610999999997)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Quito, Ecuador - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000898 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(106.816667, -6.2)
point_wsg84_project = QgsPointXY(106.8166760356519, -6.199999999999922)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Jakarta, Indonesia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000904 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-77.018611, -12.035)
point_wsg84_project = QgsPointXY(-77.01860181630058, -12.03499999999985)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Lima, Peru - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000918 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(25.466667, -10.716667)
point_wsg84_project = QgsPointXY(25.46667614155322, -10.71666699999986)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Kolwezi, Congo - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000914 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-70.333333, -18.483333)
point_wsg84_project = QgsPointXY(-70.3333235314429, -18.48333299999976)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Arica, Chile - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000947 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-70.666667, -33.45)
point_wsg84_project = QgsPointXY(-70.66665624452817, -33.44999999999953)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Santiago, Chile - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001076 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(144.9604, -37.8191)
point_wsg84_project = QgsPointXY(144.96041135746983741, -37.81909999999945171)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Melbourne, Australia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001136 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(147.29, -42.88)
point_wsg84_project = QgsPointXY(147.2900122399815, -42.87999999999934)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Hobart City,Tasmania, Australia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001224 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(168.101667, -46.899722)
point_wsg84_project = QgsPointXY(168.101680123673, -46.89972199999923)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Ryan''s Creek Aerodrome, New Zealand - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001312 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-69.216667, -51.633333)
point_wsg84_project = QgsPointXY(-69.21665255700216, -51.6333329999991)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Río Gallegos, Argentina - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001444 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-68.3, -54.8)
point_wsg84_project = QgsPointXY(-68.29998445081456, -54.79999999999899)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Ushuaia, Tierra del Fuego, Argentina - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001555 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-63.494444, -64.825278)
point_wsg84_project = QgsPointXY(-63.49442294002932, -64.82527799999851)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Port Lockroy, Antarctica - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00002106 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-180, -84.863272250)
point_wsg84_project = QgsPointXY(-179.9999000000025, -84.8632722499922)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Someware, Antarctica - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00010000 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-180, -85.0511300)
point_wsg84_project = QgsPointXY(-179.9998962142197, -85.05112999999191)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-W-> Mercator''s Last Stop, Antarctica - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.wellKnownText()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00010379 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
def testMeasureLineProjectedWorldPoints(self):
# +-+
# | |
# +-+ +
# checking returned length_mapunits/projected_points of diffferent world points with results from SpatiaLite ST_Project
da_3068 = QgsDistanceArea()
da_3068.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:3068'), QgsProject.instance().transformContext())
if (da_3068.sourceCrs().isGeographic()):
da_3068.setEllipsoid(da_3068.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_3068.sourceCrs().authid(), 'EPSG:3068')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:3068', da_3068.sourceCrs().authid(), da_3068.sourceCrs().description(), da_3068.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_3068.lengthUnits()), da_3068.sourceCrs().projectionAcronym(), da_3068.sourceCrs().ellipsoidAcronym())))
da_wsg84 = QgsDistanceArea()
da_wsg84.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4326'), QgsProject.instance().transformContext())
if (da_wsg84.sourceCrs().isGeographic()):
da_wsg84.setEllipsoid(da_wsg84.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_wsg84.sourceCrs().authid(), 'EPSG:4326')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}] ellipsoid[{}]".format(u'EPSG:4326', da_wsg84.sourceCrs().authid(), da_wsg84.sourceCrs().description(), da_wsg84.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_wsg84.lengthUnits()), da_wsg84.sourceCrs().projectionAcronym(), da_wsg84.sourceCrs().ellipsoidAcronym(), da_wsg84.ellipsoid())))
da_4314 = QgsDistanceArea()
da_4314.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4314'), QgsProject.instance().transformContext())
if (da_4314.sourceCrs().isGeographic()):
da_4314.setEllipsoid(da_4314.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_4314.sourceCrs().authid(), 'EPSG:4314')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:4314', da_4314.sourceCrs().authid(), da_4314.sourceCrs().description(), da_4314.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_4314.lengthUnits()), da_4314.sourceCrs().projectionAcronym(), da_4314.sourceCrs().ellipsoidAcronym())))
da_4805 = QgsDistanceArea()
da_4805.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4805'), QgsProject.instance().transformContext())
if (da_4805.sourceCrs().isGeographic()):
da_4805.setEllipsoid(da_4805.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_4805.sourceCrs().authid(), 'EPSG:4805')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:4805', da_4805.sourceCrs().authid(), da_4805.sourceCrs().description(), da_4805.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_4805.lengthUnits()), da_4805.sourceCrs().projectionAcronym(), da_4805.sourceCrs().ellipsoidAcronym())))
# EPSG:5665 unknown, why?
da_5665 = QgsDistanceArea()
da_5665.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:5665'), QgsProject.instance().transformContext())
if (da_5665.sourceCrs().isGeographic()):
da_5665.setEllipsoid(da_5665.sourceCrs().ellipsoidAcronym())
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:5665', da_5665.sourceCrs().authid(), da_5665.sourceCrs().description(), da_5665.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_5665.lengthUnits()), da_5665.sourceCrs().projectionAcronym(), da_5665.sourceCrs().ellipsoidAcronym())))
#self.assertEqual(da_5665.sourceCrs().authid(), 'EPSG:5665')
da_25833 = QgsDistanceArea()
da_25833.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:25833'), QgsProject.instance().transformContext())
if (da_25833.sourceCrs().isGeographic()):
da_25833.setEllipsoid(da_25833.sourceCrs().ellipsoidAcronym())
print(("setting [{}] srid [{}] description [{}] isGeographic[{}] lengthUnits[{}] projectionAcronym[{}] ellipsoidAcronym[{}]".format(u'EPSG:25833', da_25833.sourceCrs().authid(), da_25833.sourceCrs().description(), da_25833.sourceCrs().isGeographic(), QgsUnitTypes.toString(da_25833.lengthUnits()), da_25833.sourceCrs().projectionAcronym(), da_25833.sourceCrs().ellipsoidAcronym())))
self.assertEqual(da_25833.sourceCrs().authid(), 'EPSG:25833')
# Berlin - Brandenburg Gate - Quadriga
point_berlin_3068 = QgsPointXY(23183.38449999984, 21047.3225000017)
point_berlin_3068_project = point_berlin_3068.project(1, (math.pi / 2))
point_meter_result = QgsPointXY(0, 0)
length_meter_mapunits, point_meter_result = da_3068.measureLineProjected(point_berlin_3068, 1.0, (math.pi / 2))
pprint(point_meter_result)
print('-I-> Berlin 3068 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_3068.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 1, da_3068.lengthUnits(), True), '1.0 m')
self.assertEqual(point_meter_result.toString(7), point_berlin_3068_project.toString(7))
point_berlin_wsg84 = QgsPointXY(13.37770458660236, 52.51627178856762)
point_berlin_wsg84_project = QgsPointXY(13.37771931736259, 52.51627178856669)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_berlin_wsg84, 1.0, (math.pi / 2))
print('-I-> Berlin Wsg84 length_meter_mapunits[{}] point_meter_result[{}] ellipsoid[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 20, da_wsg84.lengthUnits(), True), point_meter_result.asWkt(), da_wsg84.ellipsoid()))
# for unknown reasons, this is returning '0.00001473026 m' instead of '0.00001473026 deg' when using da_wsg84.lengthUnits()
# self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits,11,da_wsg84.lengthUnits(),True), '0.00001473026 deg')
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 11, QgsUnitTypes.DistanceDegrees, True), '0.00001473026 deg')
self.assertEqual(point_meter_result.toString(7), point_berlin_wsg84_project.toString(7))
point_berlin_4314 = QgsPointXY(13.37944343021465, 52.51767872437083)
point_berlin_4314_project = QgsPointXY(13.37945816324759, 52.5176787243699)
length_meter_mapunits, point_meter_result = da_4314.measureLineProjected(point_berlin_4314, 1.0, (math.pi / 2))
print('-I-> Berlin 4314 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_4314.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 9, QgsUnitTypes.DistanceDegrees, True), '0.000014733 deg')
self.assertEqual(point_meter_result.toString(7), point_berlin_4314_project.toString(7))
point_berlin_4805 = QgsPointXY(31.04960570069176, 52.5174657497405)
point_berlin_4805_project = QgsPointXY(31.04962043365347, 52.51746574973957)
length_meter_mapunits, point_meter_result = da_4805.measureLineProjected(point_berlin_4805, 1.0, (math.pi / 2))
print('-I-> Berlin 4805 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_4805.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 9, QgsUnitTypes.DistanceDegrees, True), '0.000014733 deg')
self.assertEqual(point_meter_result.toString(7), point_berlin_4805_project.toString(7))
point_berlin_25833 = QgsPointXY(389918.0748318382, 5819698.772194743)
point_berlin_25833_project = point_berlin_25833.project(1, (math.pi / 2))
length_meter_mapunits, point_meter_result = da_25833.measureLineProjected(point_berlin_25833, 1.0, (math.pi / 2))
print('-I-> Berlin 25833 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_25833.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_25833.lengthUnits(), True), '1.0000000 m')
self.assertEqual(point_meter_result.toString(7), point_berlin_25833_project.toString(7))
if da_5665.sourceCrs().authid() != "":
point_berlin_5665 = QgsPointXY(3389996.871728864, 5822169.719727578)
point_berlin_5665_project = point_berlin_5665.project(1, (math.pi / 2))
length_meter_mapunits, point_meter_result = da_5665.measureLineProjected(point_berlin_5665, 1.0, (math.pi / 2))
print('-I-> Berlin 5665 length_meter_mapunits[{}] point_meter_result[{}]'.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_5665.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 1.0, da_5665.lengthUnits(), True), '1.0 m')
self.assertEqual(point_meter_result.toString(7), point_berlin_5665_project.toString(7))
print('\n12 points ''above over'' and on the Equator')
point_wsg84 = QgsPointXY(25.7844, 71.1725)
point_wsg84_project = QgsPointXY(25.78442775215388, 71.17249999999795)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Nordkap, Norway - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, QgsUnitTypes.DistanceDegrees, True), '0.0000278 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(24.95995, 60.16841)
point_wsg84_project = QgsPointXY(24.95996801277454, 60.16840999999877)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Helsinki, Finnland - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001801 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(12.599278, 55.692861)
point_wsg84_project = QgsPointXY(12.59929390161872, 55.69286099999897)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Copenhagen, Denmark - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001590 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-0.001389, 51.477778)
point_wsg84_project = QgsPointXY(-0.001374606184398, 51.4777779999991)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Royal Greenwich Observatory, United Kingdom - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001439 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(7.58769, 47.55814)
point_wsg84_project = QgsPointXY(7.587703287209086, 47.55813999999922)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Basel, Switzerland - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001329 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(11.255278, 43.775278)
point_wsg84_project = QgsPointXY(11.25529042107924, 43.77527799999933)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Florenz, Italy - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001242 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(14.514722, 35.899722)
point_wsg84_project = QgsPointXY(14.51473307693308, 35.89972199999949)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Valletta, Malta - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001108 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-79.933333, 32.783333)
point_wsg84_project = QgsPointXY(-79.93332232547254, 32.78333299999955)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Charlston, South Carolina - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001067 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-17.6666666, 27.733333)
point_wsg84_project = QgsPointXY(-17.66665645831515, 27.73333299999962)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Ferro, Spain - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001014 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-99.133333, 19.433333)
point_wsg84_project = QgsPointXY(-99.1333234776827, 19.43333299999975)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Mexico City, Mexico - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000952 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-79.894444, 9.341667)
point_wsg84_project = QgsPointXY(-79.89443489691369, 9.341666999999882)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Colón, Panama - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000910 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-74.075833, 4.598056)
point_wsg84_project = QgsPointXY(-74.07582398803629, 4.598055999999943)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Bogotá, Colombia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000901 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(0, 0)
point_wsg84_project = QgsPointXY(0.000008983152841, 0)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Equator, Atlantic Ocean - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000898 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
print('\n12 points ''down under'' and 1 point that should be considered invalid')
point_wsg84 = QgsPointXY(-78.509722, -0.218611)
point_wsg84_project = QgsPointXY(-78.50971301678221, -0.218610999999997)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Quito, Ecuador - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000898 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(106.816667, -6.2)
point_wsg84_project = QgsPointXY(106.8166760356519, -6.199999999999922)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Jakarta, Indonesia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000904 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-77.018611, -12.035)
point_wsg84_project = QgsPointXY(-77.01860181630058, -12.03499999999985)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Lima, Peru - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000918 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(25.466667, -10.716667)
point_wsg84_project = QgsPointXY(25.46667614155322, -10.71666699999986)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Kolwezi, Congo - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000914 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-70.333333, -18.483333)
point_wsg84_project = QgsPointXY(-70.3333235314429, -18.48333299999976)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Arica, Chile - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00000947 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-70.666667, -33.45)
point_wsg84_project = QgsPointXY(-70.66665624452817, -33.44999999999953)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Santiago, Chile - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001076 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(144.9604, -37.8191)
point_wsg84_project = QgsPointXY(144.96041135746983741, -37.81909999999945171)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Melbourne, Australia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001136 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(147.29, -42.88)
point_wsg84_project = QgsPointXY(147.2900122399815, -42.87999999999934)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Hobart City,Tasmania, Australia - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001224 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(168.101667, -46.899722)
point_wsg84_project = QgsPointXY(168.101680123673, -46.89972199999923)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Ryan''s Creek Aerodrome, New Zealand - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001312 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-69.216667, -51.633333)
point_wsg84_project = QgsPointXY(-69.21665255700216, -51.6333329999991)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Río Gallegos, Argentina - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001444 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-68.3, -54.8)
point_wsg84_project = QgsPointXY(-68.29998445081456, -54.79999999999899)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Ushuaia, Tierra del Fuego, Argentina - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00001555 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-63.494444, -64.825278)
point_wsg84_project = QgsPointXY(-63.49442294002932, -64.82527799999851)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Port Lockroy, Antarctica - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00002106 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-180, -84.863272250)
point_wsg84_project = QgsPointXY(-179.9999000000025, -84.8632722499922)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-I-> Someware, Antarctica - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00010000 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
point_wsg84 = QgsPointXY(-180, -85.0511300)
point_wsg84_project = QgsPointXY(-179.9998962142197, -85.05112999999191)
length_meter_mapunits, point_meter_result = da_wsg84.measureLineProjected(point_wsg84, 1.0, (math.pi / 2))
print('-W-> Mercator''s Last Stop, Antarctica - Wsg84 - length_meter_mapunits[{}] point_meter_result[{}] '.format(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, da_wsg84.lengthUnits(), True), point_meter_result.asWkt()))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 8, QgsUnitTypes.DistanceDegrees, True), '0.00010379 deg')
self.assertEqual(point_meter_result.toString(7), point_wsg84_project.toString(7))
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = flowTraceDialog()
# get current selected layer
clayer = self.iface.mapCanvas().currentLayer()
# make sure that the selected layer is a QgsVectorLayer of
# QgsWkbTypes.GeometryType.LineGeometry type before opening the dialog
if clayer is None or clayer.type() != 0 or clayer.geometryType() != 1:
return
# set layer name in dialog
self.dlg.labelLayer.setText(clayer.name())
# set number of selected features in dialog
self.dlg.labelNumFeatures.setText(str(len(clayer.selectedFeatures())))
# print(self.iface.mapCanvas().mapUnits())
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# get direct from dialog
direction = self.dlg.downstream_radio_button.isChecked()
#setup distance
distance = QgsDistanceArea()
# the unit of measure will be set to the same as the layer
# maybe it would be better to set it to the map CRS
distance.setSourceCrs(clayer.sourceCrs(),
QgsProject.instance().transformContext())
if result:
# get crs for tolerance setting
crs = self.iface.activeLayer().crs().authid()
# print (crs)
if crs == 'EPSG:4269':
tolerance = .0001
else:
tolerance = self.dlg.SpinBoxTolerance.value()
#index and create sets from layer
index = QgsSpatialIndex(clayer)
selection_set = set(clayer.selectedFeatureIds())
final_set = selection_set.copy()
dict_features = {
feature.id(): feature
for feature in clayer.getFeatures()
}
#loop thru selection set
while selection_set:
# get upstream/downstream node of next feature
feature = dict_features[selection_set.pop()]
nodes = self.get_geometry(feature.geometry())
upstream_coord = nodes[0 - direction]
# select all features around selected node
# using a bounding box
upstream_coord_x = upstream_coord.x()
upstream_coord_y = upstream_coord.y()
rectangle = QgsRectangle(upstream_coord_x - tolerance,
upstream_coord_y - tolerance,
upstream_coord_x + tolerance,
upstream_coord_y + tolerance)
ls_fids = index.intersects(rectangle)
#iterate thru intersected features
for fid in ls_fids:
if fid not in final_set:
# get downstream/upstream coordinates
feature = dict_features[fid]
nodes = self.get_geometry(feature.geometry())
downstream_coord = nodes[direction - 1]
#get distance between downstream and upstream nodes
dist = math.sqrt(
(downstream_coord.x() - upstream_coord_x)**2 +
(downstream_coord.y() - upstream_coord_y)**2)
if dist <= tolerance:
# if within tolerance, adds feature to selection and final set
# set values being unique, a duplicate won't be created if
# already present in the selection set
final_set.add(fid)
selection_set.add(fid)
#calculate total length
list_length = [
distance.measureLength(dict_features[fid].geometry())
for fid in final_set
]
total_length = sum(list_length)
#select features using final_set
clayer.selectByIds(list(final_set))
self.iface.mapCanvas().refresh()
#add message bar about number of features selected and length
message = self.tr(
"{} features selected totalling {} {} in length.".format(
len(final_set), round(total_length, 2),
QgsUnitTypes.toString(distance.lengthUnits())))
self.iface.messageBar().pushMessage("Flow Trace Completed",
message, 0, 10)
def points_along_line(layerout,
startpoint,
endpoint,
distance,
label,
layer,
selected_only=True,
force=False,
fo_fila=False,
divide=0,
decimal=2):
"""Adding Points along the line
"""
crs = layer.crs().authid()
# TODO check for virtual or shapelayer and set virt_layer according to it
shape = False
if shape:
# define fields for feature attributes. A list of QgsField objects is needed
fields = [
QgsField("first", QVariant.Int),
QgsField("second", QVariant.String)
]
# create an instance of vector file writer, which will create the vector file.
# Arguments:
# 1. path to new file (will fail if exists already)
# 2. encoding of the attributes
# 3. field map
# 4. geometry type - from WKBTYPE enum
# 5. layer's spatial reference (instance of
# QgsCoordinateReferenceSystem) - optional
# 6. driver name for the output file
writer = QgsVectorFileWriter("my_shapes.shp", "CP1250", fields,
Qgis.WKBPoint, crs, "ESRI Shapefile")
if writer.hasError() != QgsVectorFileWriter.NoError:
# fix_print_with_import
print("Error when creating shapefile: ", writer.hasError())
# add a feature
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
fet.setAttributes([1, "text"])
writer.addFeature(fet)
# delete the writer to flush features to disk (optional)
del writer
layer_type = "Shapefile" # TODO Add Shapefile functionality here
else:
layer_type = "memory"
virt_layer = QgsVectorLayer("Point?crs=%s" % crs, layerout, layer_type)
provider = virt_layer.dataProvider()
virt_layer.startEditing() # actually writes attributes
units = layer.crs().mapUnits()
unitname = QgsUnitTypes.toString(units)
provider.addAttributes([
QgsField("fid", QVariant.Int),
QgsField("cng" + unitname, QVariant.Double)
])
def get_features():
"""Getting the features
"""
if selected_only:
return layer.selectedFeatures()
else:
return layer.getFeatures()
# Loop through all (selected) features
for feature in get_features():
geom = feature.geometry()
# Add feature ID of selected feature
fid = feature.id()
if not geom:
QgsMessageLog.logMessage("No geometry", "QChainage")
continue
features = create_points_at(startpoint, endpoint, distance, geom, fid,
force, fo_fila, divide)
provider.addFeatures(features)
virt_layer.updateExtents()
proj = QgsProject.instance()
proj.addMapLayers([virt_layer])
virt_layer.commitChanges()
virt_layer.reload()
# generic labeling properties
if label:
virt_layer.setCustomProperty("labeling", "pal")
virt_layer.setCustomProperty("labeling/enabled", "true")
virt_layer.setCustomProperty("labeling/fieldName", "cng")
virt_layer.setCustomProperty("labeling/fontSize", "10")
virt_layer.setCustomProperty("labeling/multiLineLabels", "true")
virt_layer.setCustomProperty("labeling/formatNumbers", "true")
virt_layer.setCustomProperty("labeling/decimals", decimal)
virt_layer.setCustomProperty("labeling/Size", "5")
# symbol = QgsMarkerSymbol.createSimple({"name": "capital"})
# virt_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
virt_layer.triggerRepaint()
return
def parse_literal_input(param: QgsProcessingParameterDefinition,
kwargs) -> LiteralInput:
""" Convert processing input to Literal Input
"""
typ = param.type()
if typ == 'string':
kwargs['data_type'] = 'string'
elif typ == 'boolean':
kwargs['data_type'] = 'boolean'
elif typ == 'enum':
options = param.options()
kwargs['data_type'] = 'string'
kwargs['allowed_values'] = options
kwargs['max_occurs'] = len(options) if param.allowMultiple() else 1
default_value = param.defaultValue()
if default_value is not None:
# XXX Values for processing enum are indices
if isinstance(default_value, list):
default_value = default_value[0]
if not isinstance(default_value, int):
raise InvalidParameterValue(
'Unsupported default value for parameter %s: %s' %
(param.name(), default_value))
if default_value < 0 or default_value >= len(options):
LOGGER.error(
"Out of range default value for enum parameter %s: %s",
param.name(), default_value)
default_value = 0
kwargs['default'] = options[default_value]
elif typ == 'number':
kwargs['data_type'] = _number_data_type(param)
kwargs['allowed_values'] = [(param.minimum(), param.maximum())]
elif typ == 'distance':
kwargs['data_type'] = 'length'
kwargs['allowed_values'] = [(param.minimum(), param.maximum())]
kwargs['metadata'].extend((
Metadata('processing:parentParameterName',
param.parentParameterName()),
Metadata('processing:defaultUnit',
QgsUnitTypes.toString(param.defaultUnit())),
))
elif typ == 'scale':
kwargs['data_type'] = 'scale'
kwargs['allowed_values'] = [(param.minimum(), param.maximum())]
elif typ == 'duration':
# XXX OGC duration is defined as time dataType
kwargs['data_type'] = 'time'
kwargs['allowed_values'] = [(param.minimum(), param.maximum())]
kwargs['metadata'].append(
Metadata('processing:defaultUnit',
QgsUnitTypes.toString(param.defaultUnit())), )
elif typ == 'field':
kwargs['data_type'] = 'string'
kwargs['metadata'].append(
Metadata('processing:parentLayerParameterName',
param.parentLayerParameterName()))
kwargs['metadata'].append(
Metadata(
'processing:dataType', {
QgsProcessingParameterField.Any: 'Any',
QgsProcessingParameterField.Numeric: 'Numeric',
QgsProcessingParameterField.String: 'String',
QgsProcessingParameterField.DateTime: 'DateTime',
}[param.dataType()]))
elif typ == 'band':
kwargs['data_type'] = 'nonNegativeInteger'
else:
return None
return LiteralInput(**kwargs)
def __init__(self, sampling_layer, columns, rows):
QDialog.__init__(self)
self.sampling_layer = sampling_layer
self.setupUi(self)
ClassificationDialog.instance = self
# flags
self.setWindowFlags(self.windowFlags() | Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint)
# get classification or init new instance
if sampling_layer in Classification.instances:
self.classification = Classification.instances[sampling_layer]
else:
self.classification = Classification(sampling_layer)
self.classification.grid_columns = columns
self.classification.grid_rows = rows
#### settings the classification dialog
# set dialog title
self.setWindowTitle("Classification of samples for " +
sampling_layer.name())
# resize the classification dialog
if self.classification.dialog_size:
self.resize(*self.classification.dialog_size)
# disable enter action
self.QPBtn_SetClassification.setAutoDefault(False)
self.QPBtn_unclassifySampleButton.setAutoDefault(False)
# go to sample ID action
self.GoTo_ID_Button.clicked.connect(self.go_to_sample_id)
self.GoTo_ID.returnPressed.connect(self.go_to_sample_id)
self.GoTo_ID.textChanged.connect(
lambda: self.GoTo_ID.setStyleSheet(""))
# open in Google Earth
self.QPBtn_OpenInGE.clicked.connect(
self.open_current_point_in_google_engine)
# set properties and default value for the fit to sample spinBox based on sampling file
layer_dist_unit = self.sampling_layer.crs().mapUnits()
str_unit = QgsUnitTypes.toString(layer_dist_unit)
abbr_unit = QgsUnitTypes.toAbbreviatedString(layer_dist_unit)
self.radiusFitToSample.setSuffix(" {}".format(abbr_unit))
self.radiusFitToSample.setToolTip(
"Units in {} for set the zoom radius to the current sample\n"
"(units based on sampling file selected)".format(str_unit))
self.radiusFitToSample.setRange(
0,
360 if layer_dist_unit == QgsUnitTypes.DistanceDegrees else 10e6)
self.radiusFitToSample.setDecimals(4 if layer_dist_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
self.radiusFitToSample.setSingleStep(0.0001 if layer_dist_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
self.radiusFitToSample.setValue(self.classification.fit_to_sample)
# set total samples
self.QPBar_SamplesNavigation.setMaximum(len(
self.classification.points))
# actions for fit and go to current sample
self.radiusFitToSample.valueChanged.connect(
lambda: self.show_and_go_to_current_sample(highlight=False))
self.currentSample.clicked.connect(
lambda: self.show_and_go_to_current_sample(highlight=True))
# move through samples
self.nextSample.clicked.connect(self.next_sample)
self.nextSampleNotClassified.clicked.connect(
self.next_sample_not_classified)
self.previousSample.clicked.connect(self.previous_sample)
self.previousSampleNotClassified.clicked.connect(
self.previous_sample_not_classified)
# dialog buttons box
self.closeButton.rejected.connect(self.closing)
# disable enter action
self.closeButton.button(QDialogButtonBox.Close).setAutoDefault(False)
# init current point
self.current_sample_idx = self.classification.current_sample_idx
self.current_sample = None
self.set_current_sample()
# set classification buttons
self.classification_btns_config = ClassificationButtonsConfig(
self.classification.buttons_config)
self.create_classification_buttons(
buttons_config=self.classification.buttons_config)
self.QPBtn_SetClassification.clicked.connect(
self.open_set_classification_dialog)
self.QPBtn_unclassifySampleButton.clicked.connect(
self.unclassify_sample)
# create dynamic size of the view render widgets windows
# inside the grid with columns x rows divide by splitters
h_splitters = []
view_widgets = []
for row in range(self.classification.grid_rows):
splitter = QSplitter(Qt.Horizontal)
for column in range(self.classification.grid_columns):
new_view_widget = ClassificationViewWidget()
splitter.addWidget(new_view_widget)
h_splitters.append(splitter)
view_widgets.append(new_view_widget)
v_splitter = QSplitter(Qt.Vertical)
for splitter in h_splitters:
v_splitter.addWidget(splitter)
# add to classification dialog
self.widget_view_windows.layout().addWidget(v_splitter)
# save instances
ClassificationDialog.view_widgets = view_widgets
# setup view widget
[
view_widget.setup_view_widget(sampling_layer)
for view_widget in ClassificationDialog.view_widgets
]
for idx, view_widget in enumerate(ClassificationDialog.view_widgets):
view_widget.id = idx
# set the label names for each view
for num_view, view_widget in enumerate(
ClassificationDialog.view_widgets):
view_widget.QLabel_ViewID.setText("View {}:".format(num_view + 1))
# restore view widgets status
for config_id, view_config in self.classification.view_widgets_config.items(
):
for view_widget in ClassificationDialog.view_widgets:
if config_id == view_widget.id:
view_widget = ClassificationDialog.view_widgets[config_id]
# select the file for this view widget if exists and is loaded in Qgis
layer_name = view_config["layer_name"]
if not layer_name and view_config["render_file_path"]:
layer_name = os.path.splitext(
os.path.basename(
view_config["render_file_path"]))[0]
file_index = view_widget.QCBox_RenderFile.findText(
layer_name, Qt.MatchFixedString)
if file_index != -1:
# select layer if exists in Qgis
with block_signals_to(view_widget.QCBox_RenderFile):
view_widget.QCBox_RenderFile.setCurrentIndex(
file_index)
elif view_config["render_file_path"] and os.path.isfile(
view_config["render_file_path"]):
# load file and select in view if this exists and not load in Qgis
load_and_select_filepath_in(
view_widget.QCBox_RenderFile,
view_config["render_file_path"],
layer_name=layer_name)
elif view_config["render_file_path"] and not os.path.isfile(
view_config["render_file_path"]):
self.MsgBar.pushMessage(
"Could not to load the layer '{}' in the view {}: no such file {}"
.format(
layer_name,
"'{}'".format(view_config["view_name"]) if
view_config["view_name"] else view_widget.id +
1, view_config["render_file_path"]),
level=Qgis.Warning,
duration=-1)
else:
self.MsgBar.pushMessage(
"Could not to load the layer '{}' in the view {} (for network layers use save/load a Qgis project)"
.format(
layer_name,
"'{}'".format(view_config["view_name"]) if
view_config["view_name"] else view_widget.id +
1),
level=Qgis.Warning,
duration=-1)
# TODO: restore size by view widget
# view_widget.resize(*view_config["view_size"])
view_widget.QLabel_ViewName.setText(
view_config["view_name"])
view_widget.scaleFactor.setValue(
view_config["scale_factor"])
# active render layer in canvas
view_widget.set_render_layer(
view_widget.QCBox_RenderFile.currentLayer())
def do_simple_random_sampling(dockwidget):
# first check input files requirements
if not valid_file_selected_in(dockwidget.QCBox_ThematicRaster, "thematic raster"):
return
if dockwidget.QGBox_SimpRSwithCR.isChecked():
if not valid_file_selected_in(dockwidget.QCBox_CategRaster_SimpRS, "categorical raster"):
return
ThematicR = Raster(file_selected_combo_box=dockwidget.QCBox_ThematicRaster,
band=int(dockwidget.QCBox_band_ThematicRaster.currentText()),
nodata=int(dockwidget.nodata_ThematicRaster.value()))
# get and define some variables
number_of_samples = int(dockwidget.numberOfSamples_SimpRS.value())
min_distance = float(dockwidget.minDistance_SimpRS.value())
# simple random sampling in categorical raster
if dockwidget.QGBox_SimpRSwithCR.isChecked():
CategoricalR = Raster(file_selected_combo_box=dockwidget.QCBox_CategRaster_SimpRS,
band=int(dockwidget.QCBox_band_CategRaster_SimpRS.currentText()))
try:
pixel_values = [int(p) for p in dockwidget.pixelsValuesCategRaster.text().split(",")]
except:
iface.messageBar().pushMessage("AcATaMa", "Error, wrong pixel values, set only integers and separated by commas",
level=Qgis.Warning)
return
else:
CategoricalR = None
pixel_values = None
# check neighbors aggregation
if dockwidget.widget_generate_SimpRS.QGBox_neighbour_aggregation.isChecked():
number_of_neighbors = int(dockwidget.widget_generate_SimpRS.QCBox_NumberOfNeighbors.currentText())
same_class_of_neighbors = int(dockwidget.widget_generate_SimpRS.QCBox_SameClassOfNeighbors.currentText())
neighbor_aggregation = (number_of_neighbors, same_class_of_neighbors)
else:
neighbor_aggregation = None
# set the attempts_by_sampling
if dockwidget.widget_generate_SimpRS.button_attempts_by_sampling.isChecked():
attempts_by_sampling = int(dockwidget.widget_generate_SimpRS.attempts_by_sampling.value())
else:
attempts_by_sampling = None
# first select the target dir for save the sampling file
suggested_filename = os.path.join(os.path.dirname(ThematicR.file_path), "random_sampling.gpkg")
output_file, _ = QFileDialog.getSaveFileName(dockwidget,
dockwidget.tr("Select the output file to save the sampling"),
suggested_filename,
dockwidget.tr("GeoPackage files (*.gpkg);;Shape files (*.shp);;All files (*.*)"))
if output_file == '':
return
# define the random seed
if dockwidget.widget_generate_SimpRS.button_random_seed_by_user.isChecked():
random_seed = dockwidget.widget_generate_SimpRS.random_seed_by_user.text()
try:
random_seed = int(random_seed)
except:
pass
else:
random_seed = None
# process
sampling = Sampling("simple", ThematicR, CategoricalR, output_file=output_file)
sampling.generate_sampling_points(pixel_values, number_of_samples, min_distance,
neighbor_aggregation, attempts_by_sampling,
dockwidget.widget_generate_SimpRS.QPBar_GenerateSampling,
random_seed)
# zero points
if sampling.total_of_samples < number_of_samples and sampling.total_of_samples == 0:
# delete instance where storage all sampling generated
Sampling.samplings.pop(sampling.filename, None)
iface.messageBar().pushMessage("AcATaMa", "Error, could not generate any random points with this settings, "
"attempts exceeded", level=Qgis.Warning, duration=-1)
return
# success
if sampling.total_of_samples == number_of_samples:
qgslayer = load_layer(sampling.output_file)
iface.messageBar().pushMessage("AcATaMa", "Generate the simple random sampling, completed",
level=Qgis.Success)
# success but not completed
if number_of_samples > sampling.total_of_samples > 0:
qgslayer = load_layer(sampling.output_file)
iface.messageBar().pushMessage("AcATaMa", "Generated the simple random sampling, but can not generate requested number of "
"random points {}/{}, attempts exceeded".format(sampling.total_of_samples, number_of_samples),
level=Qgis.Warning, duration=-1)
# check the thematic raster map unit to calculate the minimum distances
if min_distance > 0:
if ThematicR.qgs_layer.crs().mapUnits() == QgsUnitTypes.DistanceUnknownUnit:
iface.messageBar().pushMessage("AcATaMa",
"The thematic raster \"{}\" does not have a valid map unit, AcATaMa used \"{}\" as the base unit to "
"calculate the minimum distances.".format(
ThematicR.qgs_layer.name(), QgsUnitTypes.toString(qgslayer.crs().mapUnits())),
level=Qgis.Warning, duration=-1)
def testFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between units"""
expected = {
QgsUnitTypes.DistanceMeters: {
QgsUnitTypes.DistanceMeters: 1.0,
QgsUnitTypes.DistanceKilometers: 0.001,
QgsUnitTypes.DistanceFeet: 3.28083989501,
QgsUnitTypes.DistanceYards: 1.0936133,
QgsUnitTypes.DistanceMiles: 0.00062136931818182,
QgsUnitTypes.DistanceDegrees: 0.00000898315,
QgsUnitTypes.DistanceNauticalMiles: 0.000539957,
QgsUnitTypes.DistanceMillimeters: 1000.0,
QgsUnitTypes.DistanceCentimeters: 100.0
},
QgsUnitTypes.DistanceKilometers: {
QgsUnitTypes.DistanceMeters: 1000.0,
QgsUnitTypes.DistanceKilometers: 1.0,
QgsUnitTypes.DistanceFeet: 3280.8398950,
QgsUnitTypes.DistanceYards: 1093.6132983,
QgsUnitTypes.DistanceMiles: 0.62137121212119317271,
QgsUnitTypes.DistanceDegrees: 0.0089832,
QgsUnitTypes.DistanceNauticalMiles: 0.53995682073432482717,
QgsUnitTypes.DistanceMillimeters: 1000000.0,
QgsUnitTypes.DistanceCentimeters: 100000.0
},
QgsUnitTypes.DistanceFeet: {
QgsUnitTypes.DistanceMeters: 0.3048,
QgsUnitTypes.DistanceKilometers: 0.0003048,
QgsUnitTypes.DistanceFeet: 1.0,
QgsUnitTypes.DistanceYards: 0.3333333,
QgsUnitTypes.DistanceMiles: 0.00018939375,
QgsUnitTypes.DistanceDegrees: 2.73806498599629E-06,
QgsUnitTypes.DistanceNauticalMiles: 0.000164579,
QgsUnitTypes.DistanceMillimeters: 304.8,
QgsUnitTypes.DistanceCentimeters: 30.48
},
QgsUnitTypes.DistanceYards: {
QgsUnitTypes.DistanceMeters: 0.9144,
QgsUnitTypes.DistanceKilometers: 0.0009144,
QgsUnitTypes.DistanceFeet: 3.0,
QgsUnitTypes.DistanceYards: 1.0,
QgsUnitTypes.DistanceMiles: 0.000568182,
QgsUnitTypes.DistanceDegrees: 0.0000082,
QgsUnitTypes.DistanceNauticalMiles: 0.0004937366590756,
QgsUnitTypes.DistanceMillimeters: 914.4,
QgsUnitTypes.DistanceCentimeters: 91.44
},
QgsUnitTypes.DistanceDegrees: {
QgsUnitTypes.DistanceMeters: 111319.49079327358,
QgsUnitTypes.DistanceKilometers: 111.3194908,
QgsUnitTypes.DistanceFeet: 365221.4264871,
QgsUnitTypes.DistanceYards: 121740.4754957,
QgsUnitTypes.DistanceMiles: 69.1707247,
QgsUnitTypes.DistanceDegrees: 1.0,
QgsUnitTypes.DistanceNauticalMiles: 60.1077164,
QgsUnitTypes.DistanceMillimeters: 111319490.79327358,
QgsUnitTypes.DistanceCentimeters: 11131949.079327358
},
QgsUnitTypes.DistanceMiles: {
QgsUnitTypes.DistanceMeters: 1609.3440000,
QgsUnitTypes.DistanceKilometers: 1.6093440,
QgsUnitTypes.DistanceFeet: 5280.0000000,
QgsUnitTypes.DistanceYards: 1760.0000000,
QgsUnitTypes.DistanceMiles: 1.0,
QgsUnitTypes.DistanceDegrees: 0.0144570,
QgsUnitTypes.DistanceNauticalMiles: 0.8689762,
QgsUnitTypes.DistanceMillimeters: 1609344.0,
QgsUnitTypes.DistanceCentimeters: 160934.4
},
QgsUnitTypes.DistanceNauticalMiles: {
QgsUnitTypes.DistanceMeters: 1852.0,
QgsUnitTypes.DistanceKilometers: 1.8520000,
QgsUnitTypes.DistanceFeet: 6076.1154856,
QgsUnitTypes.DistanceYards: 2025.3718285,
QgsUnitTypes.DistanceMiles: 1.1507794,
QgsUnitTypes.DistanceDegrees: 0.0166367990650,
QgsUnitTypes.DistanceNauticalMiles: 1.0,
QgsUnitTypes.DistanceMillimeters: 1852000.0,
QgsUnitTypes.DistanceCentimeters: 185200.0
},
QgsUnitTypes.DistanceMillimeters: {
QgsUnitTypes.DistanceMeters: 0.001,
QgsUnitTypes.DistanceKilometers: 0.000001,
QgsUnitTypes.DistanceFeet: 0.00328083989501,
QgsUnitTypes.DistanceYards: 0.0010936133,
QgsUnitTypes.DistanceMiles: 0.00000062136931818182,
QgsUnitTypes.DistanceDegrees: 0.00000000898315,
QgsUnitTypes.DistanceNauticalMiles: 0.000000539957,
QgsUnitTypes.DistanceMillimeters: 1.0,
QgsUnitTypes.DistanceCentimeters: 0.1
},
QgsUnitTypes.DistanceCentimeters: {
QgsUnitTypes.DistanceMeters: 0.01,
QgsUnitTypes.DistanceKilometers: 0.00001,
QgsUnitTypes.DistanceFeet: 0.0328083989501,
QgsUnitTypes.DistanceYards: 0.010936133,
QgsUnitTypes.DistanceMiles: 0.0000062136931818182,
QgsUnitTypes.DistanceDegrees: 0.0000000898315,
QgsUnitTypes.DistanceNauticalMiles: 0.00000539957,
QgsUnitTypes.DistanceMillimeters: 10.0,
QgsUnitTypes.DistanceCentimeters: 1.0
},
QgsUnitTypes.DistanceUnknownUnit: {
QgsUnitTypes.DistanceMeters: 1.0,
QgsUnitTypes.DistanceKilometers: 1.0,
QgsUnitTypes.DistanceFeet: 1.0,
QgsUnitTypes.DistanceYards: 1.0,
QgsUnitTypes.DistanceMiles: 1.0,
QgsUnitTypes.DistanceDegrees: 1.0,
QgsUnitTypes.DistanceNauticalMiles: 1.0,
QgsUnitTypes.DistanceMillimeters: 1.0,
QgsUnitTypes.DistanceCentimeters: 1.0
},
}
for from_unit in list(expected.keys()):
for to_unit in list(expected[from_unit].keys()):
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(res,
expected_factor,
msg='got {:.7f}, expected {:.7f} when converting from {} to {}'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, QgsUnitTypes.DistanceUnknownUnit)
self.assertAlmostEqual(res,
1.0,
msg='got {:.7f}, expected 1.0 when converting from {} to unknown units'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def testFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between units"""
expected = {QGis.Meters: {QGis.Meters: 1.0, QGis.Feet: 3.28083989501, QGis.Degrees: 0.00000898315, QGis.NauticalMiles: 0.000539957},
QGis.Feet: {QGis.Meters: 0.3048, QGis.Feet: 1.0, QGis.Degrees: 2.73806498599629E-06, QGis.NauticalMiles: 0.000164579},
QGis.Degrees: {QGis.Meters: 111319.49079327358, QGis.Feet: 365221.4264871, QGis.Degrees: 1.0, QGis.NauticalMiles: 60.1077164},
QGis.NauticalMiles: {QGis.Meters: 1852.0, QGis.Feet: 6076.1154856, QGis.Degrees: 0.0166367990650, QGis.NauticalMiles: 1.0},
QGis.UnknownUnit: {QGis.Meters: 1.0, QGis.Feet: 1.0, QGis.Degrees: 1.0, QGis.NauticalMiles: 1.0}
}
for from_unit in expected.keys():
for to_unit in expected[from_unit].keys():
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(res,
expected_factor,
msg='got {:.7f}, expected {:.7f} when converting from {} to {}'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
#test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, QGis.UnknownUnit)
self.assertAlmostEqual(res,
1.0,
msg='got {:.7f}, expected 1.0 when converting from {} to unknown units'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def testAreaMeasureAndUnits(self):
"""Test a variety of area measurements in different CRS and ellipsoid modes, to check that the
calculated areas and units are always consistent
"""
da = QgsDistanceArea()
da.setSourceCrs(QgsCoordinateReferenceSystem.fromSrsId(3452), QgsProject.instance().transformContext())
da.setEllipsoid("NONE")
polygon = QgsGeometry.fromPolygonXY(
[[
QgsPointXY(0, 0), QgsPointXY(1, 0), QgsPointXY(1, 1), QgsPointXY(2, 1), QgsPointXY(2, 2), QgsPointXY(0, 2), QgsPointXY(0, 0),
]]
)
# We check both the measured area AND the units, in case the logic regarding
# ellipsoids and units changes in future
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
assert ((abs(area - 3.0) < 0.00000001 and units == QgsUnitTypes.AreaSquareDegrees) or
(abs(area - 37176087091.5) < 0.1 and units == QgsUnitTypes.AreaSquareMeters))
da.setEllipsoid("WGS84")
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
# should always be in Meters Squared
self.assertAlmostEqual(area, 36918093794.121284, delta=0.1)
self.assertEqual(units, QgsUnitTypes.AreaSquareMeters)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareMiles)
self.assertAlmostEqual(area, 14254.155703182701, delta=0.001)
# now try with a source CRS which is in feet
polygon = QgsGeometry.fromPolygonXY(
[[
QgsPointXY(1850000, 4423000), QgsPointXY(1851000, 4423000), QgsPointXY(1851000, 4424000), QgsPointXY(1852000, 4424000), QgsPointXY(1852000, 4425000), QgsPointXY(1851000, 4425000), QgsPointXY(1850000, 4423000)
]]
)
da.setSourceCrs(QgsCoordinateReferenceSystem.fromSrsId(27469), QgsProject.instance().transformContext())
da.setEllipsoid("NONE")
# measurement should be in square feet
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(area, 2000000, delta=0.001)
self.assertEqual(units, QgsUnitTypes.AreaSquareFeet)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards)
self.assertAlmostEqual(area, 222222.2222, delta=0.001)
da.setEllipsoid("WGS84")
# now should be in Square Meters again
area = da.measureArea(polygon)
units = da.areaUnits()
print(("measured {} in {}".format(area, QgsUnitTypes.toString(units))))
self.assertAlmostEqual(area, 185818.59096575077, delta=1.0)
self.assertEqual(units, QgsUnitTypes.AreaSquareMeters)
# test converting the resultant area
area = da.convertAreaMeasurement(area, QgsUnitTypes.AreaSquareYards)
self.assertAlmostEqual(area, 222237.18521272976, delta=1.0)
def select_thematic_raster(self, layer):
def clear_and_unset_the_thematic_raster():
with block_signals_to(self.QCBox_ThematicRaster):
self.QCBox_ThematicRaster.setCurrentIndex(-1)
self.QCBox_band_ThematicRaster.clear()
self.nodata_ThematicRaster.setValue(-1)
# SimpRS
self.minDistance_SimpRS.setSuffix("")
self.minDistance_SimpRS.setToolTip("")
self.minDistance_SimpRS.setValue(0)
# StraRS
self.minDistance_StraRS.setSuffix("")
self.minDistance_StraRS.setToolTip("")
self.minDistance_StraRS.setValue(0)
# disable sampling tab
self.scrollAreaWidgetContents_S.setDisabled(True)
# unset the thematic classes in classification instance
sampling_layer = self.QCBox_SamplingFile.currentLayer()
if sampling_layer and sampling_layer in Classification.instances:
Classification.instances[
sampling_layer].with_thematic_classes = False
# updated state of sampling file selected for accuracy assessment tab
self.set_sampling_file_accuracy_assessment()
# first check
if not layer or not valid_file_selected_in(self.QCBox_ThematicRaster,
"thematic raster"):
clear_and_unset_the_thematic_raster()
return
# check if thematic raster data type is integer or byte
if layer.dataProvider().dataType(1) not in [1, 2, 3, 4, 5]:
clear_and_unset_the_thematic_raster()
iface.messageBar().pushMessage(
"AcATaMa",
"Error, thematic raster must be byte or integer as data type.",
level=Qgis.Warning)
return
# set band count
self.QCBox_band_ThematicRaster.clear()
self.QCBox_band_ThematicRaster.addItems(
[str(x) for x in range(1,
layer.bandCount() + 1)])
# set nodata value of thematic raster in nodata field
self.nodata_ThematicRaster.setValue(get_nodata_value(layer))
# set/update the units in minimum distance items in sampling tab
layer_dist_unit = layer.crs().mapUnits()
str_unit = QgsUnitTypes.toString(layer_dist_unit)
abbr_unit = QgsUnitTypes.toAbbreviatedString(layer_dist_unit)
# Set the properties of the QdoubleSpinBox based on the QgsUnitTypes of the thematic raster
# https://qgis.org/api/classQgsUnitTypes.html
# SimpRS
self.minDistance_SimpRS.setSuffix(" {}".format(abbr_unit))
self.minDistance_SimpRS.setToolTip(
"Minimum distance in {} (units based on thematic raster selected)".
format(str_unit))
self.minDistance_SimpRS.setRange(
0,
360 if layer_dist_unit == QgsUnitTypes.DistanceDegrees else 10e6)
self.minDistance_SimpRS.setDecimals(4 if layer_dist_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
self.minDistance_SimpRS.setSingleStep(0.0001 if layer_dist_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
self.minDistance_SimpRS.setValue(0)
# StraRS
self.minDistance_StraRS.setSuffix(" {}".format(abbr_unit))
self.minDistance_StraRS.setToolTip(
"Minimum distance in {} (units based on thematic raster selected)".
format(str_unit))
self.minDistance_StraRS.setRange(
0,
360 if layer_dist_unit == QgsUnitTypes.DistanceDegrees else 10e6)
self.minDistance_StraRS.setDecimals(4 if layer_dist_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
self.minDistance_StraRS.setSingleStep(0.0001 if layer_dist_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
self.minDistance_StraRS.setValue(0)
# enable sampling tab
self.scrollAreaWidgetContents_S.setEnabled(True)
def testAngleFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between angular units"""
expected = {QgsUnitTypes.AngleDegrees: {QgsUnitTypes.AngleDegrees: 1.0, QgsUnitTypes.AngleRadians: 0.0174533, QgsUnitTypes.AngleGon: 1.1111111, QgsUnitTypes.AngleMinutesOfArc: 60, QgsUnitTypes.AngleSecondsOfArc: 3600, QgsUnitTypes.AngleTurn: 0.00277777777778},
QgsUnitTypes.AngleRadians: {QgsUnitTypes.AngleDegrees: 57.2957795, QgsUnitTypes.AngleRadians: 1.0, QgsUnitTypes.AngleGon: 63.6619772, QgsUnitTypes.AngleMinutesOfArc: 3437.7467708, QgsUnitTypes.AngleSecondsOfArc: 206264.8062471, QgsUnitTypes.AngleTurn: 0.159154943092},
QgsUnitTypes.AngleGon: {QgsUnitTypes.AngleDegrees: 0.9000000, QgsUnitTypes.AngleRadians: 0.015707968623450838802, QgsUnitTypes.AngleGon: 1.0, QgsUnitTypes.AngleMinutesOfArc: 54.0000000, QgsUnitTypes.AngleSecondsOfArc: 3240.0000000, QgsUnitTypes.AngleTurn: 0.0025},
QgsUnitTypes.AngleMinutesOfArc: {QgsUnitTypes.AngleDegrees: 0.016666672633390722247, QgsUnitTypes.AngleRadians: 0.00029088831280398030638, QgsUnitTypes.AngleGon: 0.018518525464057963154, QgsUnitTypes.AngleMinutesOfArc: 1.0, QgsUnitTypes.AngleSecondsOfArc: 60.0, QgsUnitTypes.AngleTurn: 4.62962962962963e-05},
QgsUnitTypes.AngleSecondsOfArc: {QgsUnitTypes.AngleDegrees: 0.00027777787722304257169, QgsUnitTypes.AngleRadians: 4.848138546730629518e-6, QgsUnitTypes.AngleGon: 0.0003086420910674814405, QgsUnitTypes.AngleMinutesOfArc: 0.016666672633325253783, QgsUnitTypes.AngleSecondsOfArc: 1.0, QgsUnitTypes.AngleTurn: 7.71604938271605e-07},
QgsUnitTypes.AngleTurn: {QgsUnitTypes.AngleDegrees: 360.0, QgsUnitTypes.AngleRadians: 6.2831853071795, QgsUnitTypes.AngleGon: 400.0, QgsUnitTypes.AngleMinutesOfArc: 21600, QgsUnitTypes.AngleSecondsOfArc: 1296000, QgsUnitTypes.AngleTurn: 1}
}
for from_unit in list(expected.keys()):
for to_unit in list(expected[from_unit].keys()):
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(res,
expected_factor,
msg='got {:.7f}, expected {:.7f} when converting from {} to {}'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, QgsUnitTypes.AngleUnknownUnit)
self.assertAlmostEqual(res,
1.0,
msg='got {:.7f}, expected 1.0 when converting from {} to unknown units'.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def __init__(self, parent=None):
super().__init__(parent=parent)
scale_factor = QApplication.instance().primaryScreen() \
.logicalDotsPerInch() / 96
def create_editable_combobox(text):
combo = QComboBox()
combo.setEditable(True)
combo.setEditText(text)
return combo
cols = lambda cx, lx: \
(QCheckBox(cx), create_editable_combobox(lx),
FramedLabel(), PrecisionEdit())
self.rowXcoord = cols(self.tr('X Coordinate'), 'xcoord')
self.rowYcoord = cols(self.tr('Y Coordinate'), 'ycoord')
self.rowZcoord = cols(self.tr('Z Coordinate'), 'zcoord')
self.rowMvalue = cols(self.tr('M Value'), 'mvalue')
unit = QgsUnitTypes.DistanceDegrees
self.rowXcoord[2].setText(QgsUnitTypes.toString(unit).title())
self.rowYcoord[2].setText(QgsUnitTypes.toString(unit).title())
unit = QgsUnitTypes.DistanceMeters
self.rowZcoord[2].setText(QgsUnitTypes.toString(unit).title())
self.rowMvalue[2].setText(QgsUnitTypes.toString(unit).title())
cols = lambda cx, lx: \
(QCheckBox(cx), create_editable_combobox(lx),
QComboBox(), PrecisionEdit())
self.rowLength = cols(self.tr('Length'), 'length')
for unit in distance_units:
self.rowLength[2].addItem(QgsUnitTypes.toString(unit).title(), unit)
self.rowLength[2].setItemText(self.rowLength[2].count() - 1,
self.tr('Map Units'))
self.rowArea = cols(self.tr('Area'), 'area')
for unit in area_units:
self.rowArea[2].addItem(QgsUnitTypes.toString(unit).title(), unit)
self.rowArea[2].setItemText(self.rowArea[2].count() - 1,
self.tr('Map Units'))
self.rowPerimeter = cols(self.tr('Perimeter'), 'perimeter')
for i in range(self.rowLength[2].count()):
self.rowPerimeter[2].addItem(self.rowLength[2].itemText(i),
self.rowLength[2].itemData(i))
grid = QGridLayout()
grid.addWidget(QLabel(self.tr('Field')), 0, 1)
grid.addWidget(QLabel(self.tr('Units')), 0, 2)
label_prec = QLabel(self.tr('Precision'))
grid.addWidget(label_prec, 0, 3)
grid.itemAtPosition(0, 3).widget().show()
width = int(QFontMetrics(QFont()).height() * scale_factor * 3)
self.rows = (self.rowXcoord,
self.rowYcoord,
self.rowZcoord,
self.rowMvalue,
self.rowLength,
self.rowArea,
self.rowPerimeter,)
for row, w in enumerate(self.rows):
w[0].setChecked(True)
w[1].setMinimumWidth(width * 2)
w[3].setMaximumWidth(max(width, label_prec.width()))
for col in range(len(w)):
grid.addWidget(w[col], row + 1, col)
for col in (1, 2):
grid.setColumnStretch(col, 1)
groupProp = QGroupBox(self.tr('Properties'))
groupProp.setLayout(grid)
self.radio1 = QRadioButton(
self.tr('Cartesian calculation with following CRS'))
self.radio1.setChecked(True)
self.radio2 = QRadioButton(
self.tr('Ellipsoidal calculation with following ellipsoid'))
self.radios = QButtonGroup()
self.radios.addButton(self.radio1)
self.radios.addButton(self.radio2)
self.selectorCrs = QgsProjectionSelectionWidget()
self.selectorCrs.setMinimumWidth(width * 8)
self.selectorCrs.setOptionVisible(
QgsProjectionSelectionWidget.CurrentCrs, False)
self.selectorCrs.setLayerCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.comboCrs = self.selectorCrs.layout().itemAt(0).widget()
self.comboCrs.setCurrentIndex(
self.comboCrs.findData(QgsProjectionSelectionWidget.LayerCrs))
self.labelEllips = FramedLabel()
grid = QGridLayout()
grid.addWidget(self.radio1, 0, 0, 1, 0)
grid.addWidget(self.selectorCrs, 1, 1)
grid.addWidget(self.radio2, 2, 0, 1, 0)
grid.addWidget(self.labelEllips, 3, 1)
grid.setColumnMinimumWidth(0, QRadioButton().sizeHint().width())
grid.setRowMinimumHeight(3, QLineEdit().sizeHint().height())
groupSystem = QGroupBox(self.tr('Calculation System'))
groupSystem.setLayout(grid)
self.checkSelected = QCheckBox(self.tr('Selected features only'))
self.checkDefault = QCheckBox(self.tr('Set expression to default value'))
self.checkVirtual = QCheckBox(self.tr('Use virtual field for new field'))
self.checks = QButtonGroup()
self.checks.setExclusive(False)
self.checks.addButton(self.checkSelected)
self.checks.addButton(self.checkDefault)
self.checks.addButton(self.checkVirtual)
form = QFormLayout()
form.addRow(groupProp)
form.addRow(groupSystem)
form.addRow(self.checkSelected)
form.addRow(self.checkDefault)
form.addRow(self.checkVirtual)
self.buttonBox = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
accepted=self.accept, rejected=self.reject)
vbox = QVBoxLayout()
vbox.addLayout(form)
vbox.addWidget(self.buttonBox)
self.setLayout(vbox)
self.setMaximumSize(QWIDGETSIZE_MAX, 0)
def points_along_line(layerout,
startpoint,
endpoint,
distance,
label,
layer,
selected_only=True,
force=False,
fo_fila=False,
divide=0,
decimal=2):
"""Adding Points along the line
"""
crs = layer.crs().authid()
# TODO check for virtual or shapelayer and set virt_layer according to it
shape = False
if shape:
# define fields for feature attributes. A list of QgsField objects is needed
fields = [QgsField("first", QVariant.Int),
QgsField("second", QVariant.String)]
# create an instance of vector file writer, which will create the vector file.
# Arguments:
# 1. path to new file (will fail if exists already)
# 2. encoding of the attributes
# 3. field map
# 4. geometry type - from WKBTYPE enum
# 5. layer's spatial reference (instance of
# QgsCoordinateReferenceSystem) - optional
# 6. driver name for the output file
writer = QgsVectorFileWriter("my_shapes.shp",
"CP1250",
fields,
Qgis.WKBPoint,
crs,
"ESRI Shapefile")
if writer.hasError() != QgsVectorFileWriter.NoError:
# fix_print_with_import
print("Error when creating shapefile: ", writer.hasError())
# add a feature
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
fet.setAttributes([1, "text"])
writer.addFeature(fet)
# delete the writer to flush features to disk (optional)
del writer
layer_type = "Shapefile" # TODO Add Shapefile functionality here
else:
layer_type = "memory"
virt_layer = QgsVectorLayer("Point?crs=%s" % crs,
layerout,
layer_type)
provider = virt_layer.dataProvider()
virt_layer.startEditing() # actually writes attributes
units = layer.crs().mapUnits()
unitname = QgsUnitTypes.toString(units)
provider.addAttributes([QgsField("fid", QVariant.Int),
QgsField("cng"+unitname, QVariant.Double)])
def get_features():
"""Getting the features
"""
if selected_only:
return layer.selectedFeatures()
else:
return layer.getFeatures()
# Loop through all (selected) features
for feature in get_features():
geom = feature.geometry()
# Add feature ID of selected feature
fid = feature.id()
if not geom:
QgsMessageLog.logMessage("No geometry", "QChainage")
continue
features = create_points_at(startpoint,
endpoint,
distance,
geom,
fid,
force,
fo_fila,
divide)
provider.addFeatures(features)
virt_layer.updateExtents()
proj = QgsProject.instance()
proj.addMapLayers([virt_layer])
virt_layer.commitChanges()
virt_layer.reload()
# generic labeling properties
if label:
virt_layer.setCustomProperty("labeling", "pal")
virt_layer.setCustomProperty("labeling/enabled", "true")
virt_layer.setCustomProperty("labeling/fieldName", "cng")
virt_layer.setCustomProperty("labeling/fontSize", "10")
virt_layer.setCustomProperty("labeling/multiLineLabels", "true")
virt_layer.setCustomProperty("labeling/formatNumbers", "true")
virt_layer.setCustomProperty("labeling/decimals", decimal)
virt_layer.setCustomProperty("labeling/Size", "5")
# symbol = QgsMarkerSymbol.createSimple({"name": "capital"})
# virt_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
virt_layer.triggerRepaint()
return
def setup_gui(self):
self.NavTiles_widgetFile.setHidden(True)
self.NavTiles_widgetAOI.setHidden(True)
self.SliderNavigationBlock.setEnabled(False)
self.QCBox_BuildNavType.currentIndexChanged[str].connect(
self.set_navigation_type_tool)
# set properties to QgsMapLayerComboBox
self.QCBox_VectorFile.setCurrentIndex(-1)
self.QCBox_VectorFile.setFilters(QgsMapLayerProxyModel.VectorLayer)
# handle connect layer selection with render canvas
self.QCBox_VectorFile.currentIndexChanged.connect(
lambda: self.render_over_thematic(self.QCBox_VectorFile.
currentLayer()))
# call to browse the render file
self.QPBtn_BrowseVectorFile.clicked.connect(
lambda: self.browser_dialog_to_load_file(
self.QCBox_VectorFile,
dialog_title=self.tr("Select the vector file"),
file_filters=self.tr(
"Vector files (*.gpkg *.shp);;All files (*.*)")))
# buttons connections
self.QPBtn_BuildNavigationTools.clicked.connect(self.build_tools)
self.QPBtn_BuildNavigation.clicked.connect(
self.call_to_build_navigation)
self.TilesColor.clicked.connect(self.change_tiles_color)
self.CleanNavigation.clicked.connect(self.clean_navigation)
self.AOI_Picker.clicked.connect(self.activate_deactivate_AOI_picker)
self.DeleteAllAOI.clicked.connect(self.clean_all_aoi_drawn)
self.ZoomToTiles.clicked.connect(self.zoom_to_tiles)
# slider and spinbox connection
self.SliderNavigation.valueChanged.connect(self.highlight)
self.SliderNavigation.sliderReleased.connect(
lambda: self.change_tile_from_slider(self.SliderNavigation.value()
))
self.currentTile.valueChanged.connect(self.change_tile_from_spinbox)
# #### setup units in tile size
# set/update the units in tileSize item
layer_unit = self.layer_to_edit.qgs_layer.crs().mapUnits()
if layer_unit == QgsUnitTypes.DistanceUnknownUnit:
layer_unit = QgsUnitTypes.DistanceMeters
str_unit = QgsUnitTypes.toString(layer_unit) + \
"\nWARNING: the layer does not have a valid map unit considering meters as the base unit!"
else:
str_unit = QgsUnitTypes.toString(layer_unit)
abbr_unit = QgsUnitTypes.toAbbreviatedString(layer_unit)
# Set the properties of the QdoubleSpinBox based on the QgsUnitTypes of the thematic layer
# https://qgis.org/api/classQgsUnitTypes.html
self.tileSize.setSuffix(" {}".format(abbr_unit))
self.tileSize.setToolTip(
"The height/width of the tile to build the navigation, in {}\n"
"(units based on the current thematic layer to edit)\n"
"(rebuild the navigation to make the changes)".format(str_unit))
self.tileSize.setRange(
0, 360 if layer_unit == QgsUnitTypes.DistanceDegrees else 10e10)
self.tileSize.setDecimals(4 if layer_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
self.tileSize.setSingleStep(0.0001 if layer_unit in [
QgsUnitTypes.DistanceKilometers, QgsUnitTypes.
DistanceNauticalMiles, QgsUnitTypes.DistanceMiles, QgsUnitTypes.
DistanceDegrees
] else 1)
default_tile_size = {
QgsUnitTypes.DistanceMeters: 15000,
QgsUnitTypes.DistanceKilometers: 15,
QgsUnitTypes.DistanceFeet: 49125,
QgsUnitTypes.DistanceNauticalMiles: 8.125,
QgsUnitTypes.DistanceYards: 16500,
QgsUnitTypes.DistanceMiles: 9.375,
QgsUnitTypes.DistanceDegrees: 0.1375,
QgsUnitTypes.DistanceCentimeters: 1500000,
QgsUnitTypes.DistanceMillimeters: 15000000
}
self.tileSize.setValue(default_tile_size[layer_unit])
def testFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between units"""
expected = {
QgsUnitTypes.DistanceMeters: {
QgsUnitTypes.DistanceMeters: 1.0,
QgsUnitTypes.DistanceKilometers: 0.001,
QgsUnitTypes.DistanceFeet: 3.28083989501,
QgsUnitTypes.DistanceYards: 1.0936133,
QgsUnitTypes.DistanceMiles: 0.00062136931818182,
QgsUnitTypes.DistanceDegrees: 0.00000898315,
QgsUnitTypes.DistanceNauticalMiles: 0.000539957,
QgsUnitTypes.DistanceMillimeters: 1000.0,
QgsUnitTypes.DistanceCentimeters: 100.0
},
QgsUnitTypes.DistanceKilometers: {
QgsUnitTypes.DistanceMeters: 1000.0,
QgsUnitTypes.DistanceKilometers: 1.0,
QgsUnitTypes.DistanceFeet: 3280.8398950,
QgsUnitTypes.DistanceYards: 1093.6132983,
QgsUnitTypes.DistanceMiles: 0.62137121212119317271,
QgsUnitTypes.DistanceDegrees: 0.0089832,
QgsUnitTypes.DistanceNauticalMiles: 0.53995682073432482717,
QgsUnitTypes.DistanceMillimeters: 1000000.0,
QgsUnitTypes.DistanceCentimeters: 100000.0
},
QgsUnitTypes.DistanceFeet: {
QgsUnitTypes.DistanceMeters: 0.3048,
QgsUnitTypes.DistanceKilometers: 0.0003048,
QgsUnitTypes.DistanceFeet: 1.0,
QgsUnitTypes.DistanceYards: 0.3333333,
QgsUnitTypes.DistanceMiles: 0.00018939375,
QgsUnitTypes.DistanceDegrees: 2.73806498599629E-06,
QgsUnitTypes.DistanceNauticalMiles: 0.000164579,
QgsUnitTypes.DistanceMillimeters: 304.8,
QgsUnitTypes.DistanceCentimeters: 30.48
},
QgsUnitTypes.DistanceYards: {
QgsUnitTypes.DistanceMeters: 0.9144,
QgsUnitTypes.DistanceKilometers: 0.0009144,
QgsUnitTypes.DistanceFeet: 3.0,
QgsUnitTypes.DistanceYards: 1.0,
QgsUnitTypes.DistanceMiles: 0.000568182,
QgsUnitTypes.DistanceDegrees: 0.0000082,
QgsUnitTypes.DistanceNauticalMiles: 0.0004937366590756,
QgsUnitTypes.DistanceMillimeters: 914.4,
QgsUnitTypes.DistanceCentimeters: 91.44
},
QgsUnitTypes.DistanceDegrees: {
QgsUnitTypes.DistanceMeters: 111319.49079327358,
QgsUnitTypes.DistanceKilometers: 111.3194908,
QgsUnitTypes.DistanceFeet: 365221.4264871,
QgsUnitTypes.DistanceYards: 121740.4754957,
QgsUnitTypes.DistanceMiles: 69.1707247,
QgsUnitTypes.DistanceDegrees: 1.0,
QgsUnitTypes.DistanceNauticalMiles: 60.1077164,
QgsUnitTypes.DistanceMillimeters: 111319490.79327358,
QgsUnitTypes.DistanceCentimeters: 11131949.079327358
},
QgsUnitTypes.DistanceMiles: {
QgsUnitTypes.DistanceMeters: 1609.3440000,
QgsUnitTypes.DistanceKilometers: 1.6093440,
QgsUnitTypes.DistanceFeet: 5280.0000000,
QgsUnitTypes.DistanceYards: 1760.0000000,
QgsUnitTypes.DistanceMiles: 1.0,
QgsUnitTypes.DistanceDegrees: 0.0144570,
QgsUnitTypes.DistanceNauticalMiles: 0.8689762,
QgsUnitTypes.DistanceMillimeters: 1609344.0,
QgsUnitTypes.DistanceCentimeters: 160934.4
},
QgsUnitTypes.DistanceNauticalMiles: {
QgsUnitTypes.DistanceMeters: 1852.0,
QgsUnitTypes.DistanceKilometers: 1.8520000,
QgsUnitTypes.DistanceFeet: 6076.1154856,
QgsUnitTypes.DistanceYards: 2025.3718285,
QgsUnitTypes.DistanceMiles: 1.1507794,
QgsUnitTypes.DistanceDegrees: 0.0166367990650,
QgsUnitTypes.DistanceNauticalMiles: 1.0,
QgsUnitTypes.DistanceMillimeters: 1852000.0,
QgsUnitTypes.DistanceCentimeters: 185200.0
},
QgsUnitTypes.DistanceMillimeters: {
QgsUnitTypes.DistanceMeters: 0.001,
QgsUnitTypes.DistanceKilometers: 0.000001,
QgsUnitTypes.DistanceFeet: 0.00328083989501,
QgsUnitTypes.DistanceYards: 0.0010936133,
QgsUnitTypes.DistanceMiles: 0.00000062136931818182,
QgsUnitTypes.DistanceDegrees: 0.00000000898315,
QgsUnitTypes.DistanceNauticalMiles: 0.000000539957,
QgsUnitTypes.DistanceMillimeters: 1.0,
QgsUnitTypes.DistanceCentimeters: 0.1
},
QgsUnitTypes.DistanceCentimeters: {
QgsUnitTypes.DistanceMeters: 0.01,
QgsUnitTypes.DistanceKilometers: 0.00001,
QgsUnitTypes.DistanceFeet: 0.0328083989501,
QgsUnitTypes.DistanceYards: 0.010936133,
QgsUnitTypes.DistanceMiles: 0.0000062136931818182,
QgsUnitTypes.DistanceDegrees: 0.0000000898315,
QgsUnitTypes.DistanceNauticalMiles: 0.00000539957,
QgsUnitTypes.DistanceMillimeters: 10.0,
QgsUnitTypes.DistanceCentimeters: 1.0
},
QgsUnitTypes.DistanceUnknownUnit: {
QgsUnitTypes.DistanceMeters: 1.0,
QgsUnitTypes.DistanceKilometers: 1.0,
QgsUnitTypes.DistanceFeet: 1.0,
QgsUnitTypes.DistanceYards: 1.0,
QgsUnitTypes.DistanceMiles: 1.0,
QgsUnitTypes.DistanceDegrees: 1.0,
QgsUnitTypes.DistanceNauticalMiles: 1.0,
QgsUnitTypes.DistanceMillimeters: 1.0,
QgsUnitTypes.DistanceCentimeters: 1.0
},
}
for from_unit in list(expected.keys()):
for to_unit in list(expected[from_unit].keys()):
expected_factor = expected[from_unit][to_unit]
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
self.assertAlmostEqual(
res,
expected_factor,
msg=
'got {:.7f}, expected {:.7f} when converting from {} to {}'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
# test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(
from_unit, QgsUnitTypes.DistanceUnknownUnit)
self.assertAlmostEqual(
res,
1.0,
msg=
'got {:.7f}, expected 1.0 when converting from {} to unknown units'
.format(res, expected_factor,
QgsUnitTypes.toString(from_unit)))
def accept(self, *args, **kwargs):
if not self.validate():
return False
try:
# disable form via a frame, this will still allow interaction with the message bar
self.stackedWidget.setDisabled(True)
# clean gui and Qgis messagebars
self.cleanMessageBars(True)
# self.iface.messageBar().clearWidgets()
# Change cursor to Wait cursor
QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
self.iface.mainWindow().statusBar().showMessage('Processing {}'.format(self.windowTitle()))
self.send_to_messagebar("Please wait.. QGIS will be locked... See log panel for progress.",
level=Qgis.Warning,
duration=0, addToLog=False, core_QGIS=False, showLogPanel=True)
gp_layer_name = ''
LOGGER.info('{st}\nProcessing {}'.format(self.windowTitle(), st='*' * 50))
# Add settings to log
settingsStr = 'Parameters:---------------------------------------'
if self.optFile.isChecked():
settingsStr += '\n {:30}\t{}'.format('File:', self.lneInCSVFile.text())
settingsStr += '\n {:30}\t{}, {}'.format('Geometry Fields:', self.cboXField.currentText(),
self.cboYField.currentText())
settingsStr += '\n {:30}\t{} - {}'.format('CSV Coordinate System:', self.qgsCRScsv.crs().authid(),
self.qgsCRScsv.crs().description())
else:
if self.chkUseSelected.isChecked():
settingsStr += '\n {:30}\t{} with {} selected features'.format('Layer:',
self.mcboTargetLayer.currentLayer().name(),
self.mcboTargetLayer.currentLayer().selectedFeatureCount())
else:
settingsStr += '\n {:30}\t{}'.format('Layer:', self.mcboTargetLayer.currentLayer().name())
crs_units = QgsUnitTypes.toString(self.mCRSoutput.crs().mapUnits())
settingsStr += '\n {:30}\t{} {}'.format('Thinning Distance:', self.dsbThinDist.value(),crs_units)
settingsStr += '\n {:30}\t{} {}'.format("Aggregate Distance:", self.dsbAggregateDist.value(),crs_units)
settingsStr += '\n {:30}\t{} {}'.format("Buffer Distance:", self.dsbBufferDist.value(),crs_units)
settingsStr += '\n {:30}\t{} {}'.format("Shrink Distance:", self.dsbShrinkDist.value(),crs_units)
settingsStr += '\n {:30}\t{}'.format('Output Polygon Shapefile:', self.lneSavePolyFile.text())
if self.lneSavePointsFile.text() == '':
settingsStr += '\n {:30}\t{}'.format('Saved Points Shapefile:', self.lneSavePointsFile.text())
settingsStr += '\n {:30}\t{} - {}\n\n'.format('Output Projected Coordinate System:',
self.mCRSoutput.crs().authid(),
self.mCRSoutput.crs().description())
LOGGER.info(settingsStr)
stepTime = time.time()
if self.optFile.isChecked():
in_epsg = int(self.qgsCRScsv.crs().authid().replace('EPSG:',''))
in_crs = self.qgsCRScsv.crs()
else:
in_epsg =self.mcboTargetLayer.currentLayer().crs().authid().replace('EPSG:','')
in_crs = self.mcboTargetLayer.currentLayer().crs()
out_epsg = int(self.mCRSoutput.crs().authid().replace('EPSG:',''))
filePoly = None
gdfPoints = None
filePoints = None
if self.optFile.isChecked():
if self.DEBUG:
filePoints = os.path.join(TEMPDIR, os.path.splitext(os.path.basename(self.lneSavePolyFile.text()))[0] + '_table2pts.shp')
if os.path.splitext(self.lneInCSVFile.text())[-1] == '.csv':
gdfPoints, gdfPtsCrs = convert.convert_csv_to_points(self.lneInCSVFile.text() , out_shapefilename=filePoints,
coord_columns=[self.cboXField.currentText(),
self.cboYField.currentText()],
coord_columns_epsg=in_epsg)
elif os.path.splitext(self.lneInCSVFile.text())[-1] in ['.xls', '.xlsx', '.ods']:
xls_file = pd.ExcelFile(self.lneInCSVFile.text())
pdfxls = xls_file.parse(self.sheet(), skiprows=self.linesToIgnore() - 1)
del xls_file
gdfPoints, gdfPtsCrs = convert.add_point_geometry_to_dataframe(pdfxls,
coord_columns=[
self.cboXField.currentText(),
self.cboYField.currentText()],
coord_columns_epsg=in_epsg)
del pdfxls
LOGGER.info('{:<30} {d:<15} {}'.format('Add Geometry to Table','',
d=str(timedelta(seconds=time.time() - stepTime))))
stepTime = time.time()
if filePoints is not None:
describe.save_geopandas_tofile(gdfPoints, filePoints) #, file_encoding=self.file_encoding)
if self.DISP_TEMP_LAYERS and filePoints is not None:
addVectorFileToQGIS(filePoints, layer_name=os.path.splitext(os.path.basename(filePoints))[0],
group_layer_name='DEBUG', atTop=True)
else:
layerPts = self.mcboTargetLayer.currentLayer()
if layerPts.providerType() == 'delimitedtext' or \
os.path.splitext(get_layer_source(layerPts))[-1] == '.vrt' or \
self.chkUseSelected.isChecked() or self.optFile.isChecked():
filePoints = os.path.join(TEMPDIR, "{}_points.shp".format(layerPts.name()))
if self.chkUseSelected.isChecked():
filePoints = os.path.join(TEMPDIR, "{}_selected_points.shp".format(layerPts.name()))
if os.path.exists(filePoints):
removeFileFromQGIS(filePoints)
ptsLayer = copyLayerToMemory(layerPts, layerPts.name() + "_memory", bAddUFI=True,
bOnlySelectedFeat=self.chkUseSelected.isChecked())
_writer = QgsVectorFileWriter.writeAsVectorFormat(ptsLayer, filePoints, "utf-8",
self.mCRSoutput.crs(), driverName="ESRI Shapefile")
LOGGER.info('{:<30} {d:<15} {}'.format('Save layer/selection to file',filePoints,
d=str(timedelta(seconds=time.time() - stepTime) )))
stepTime = time.time()
del ptsLayer
if self.DISP_TEMP_LAYERS:
addVectorFileToQGIS(filePoints, layer_name=os.path.splitext(os.path.basename(filePoints))[0],
group_layer_name='DEBUG', atTop=True)
else:
filePoints = get_layer_source(layerPts)
if gdfPoints is None:
ptsDesc = describe.VectorDescribe(filePoints)
gdfPtsCrs = ptsDesc.crs
gdfPoints = ptsDesc.open_geo_dataframe()
if in_crs.authid() != self.mCRSoutput.crs().authid():
gdfPoints = gdfPoints.to_crs(epsg=out_epsg)
gdfPtsCrs = pyprecag_crs.crs()
gdfPtsCrs.getFromEPSG(out_epsg)
LOGGER.info('{:<30} {d:<15} {} to {}'.format('Reproject points', in_crs.authid(),
self.mCRSoutput.crs().authid(),
d=str(timedelta(seconds=time.time() - stepTime))))
if self.DEBUG:
filePoints = os.path.join(TEMPDIR, os.path.basename(self.lneSavePolyFile.text().replace('.csv', '_ptsprj.shp')))
removeFileFromQGIS(filePoints)
describe.save_geopandas_tofile(gdfPoints, filePoints)
if self.DISP_TEMP_LAYERS:
if self.DEBUG:
addVectorFileToQGIS(filePoints,
layer_name=os.path.splitext(os.path.basename(filePoints))[0],
group_layer_name='DEBUG', atTop=True)
else:
addVectorFileToQGIS(filePoints,
layer_name=os.path.splitext(os.path.basename(filePoints))[0],
atTop=True)
stepTime = time.time()
result = processing.create_polygon_from_point_trail(gdfPoints, gdfPtsCrs,
out_filename=self.lneSavePolyFile.text(),
thin_dist_m=self.dsbThinDist.value(),
aggregate_dist_m=self.dsbAggregateDist.value(),
buffer_dist_m=self.dsbBufferDist.value(),
shrink_dist_m=self.dsbShrinkDist.value())
addVectorFileToQGIS(self.lneSavePolyFile.text(), atTop=True)
self.cleanMessageBars(True)
self.stackedWidget.setDisabled(False)
QApplication.restoreOverrideCursor()
self.iface.messageBar().popWidget()
self.iface.mainWindow().statusBar().clearMessage()
if result is not None:
self.fraMain.setDisabled(False)
self.send_to_messagebar(result, level=Qgis.Warning, duration=0, addToLog=False)
return False # leave dialog open
return super(PointTrailToPolygonDialog, self).accept(*args, **kwargs)
except Exception as err:
QApplication.restoreOverrideCursor()
self.iface.mainWindow().statusBar().clearMessage()
self.cleanMessageBars(True)
self.stackedWidget.setDisabled(False)
self.send_to_messagebar(str(err), level=Qgis.Critical,
duration=0, addToLog=True, core_QGIS=False, showLogPanel=True,
exc_info=sys.exc_info())
return False # leave dialog open
