Python QgsUnitTypes.toString方法代码示例

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)
                    ),
                )

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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))

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
 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

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
 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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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))

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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))

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import toString [as 别名]
    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)