Python QgsUnitTypes.encodeUnit方法代码示例

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def test_ExpressionFieldEllipsoidLengthCalculation(self):
        #create a temporary layer
        temp_layer = QgsVectorLayer("LineString?crs=epsg:3111&field=pk:int", "vl", "memory")
        self.assertTrue(temp_layer.isValid())
        f1 = QgsFeature(temp_layer.dataProvider().fields(), 1)
        f1.setAttribute("pk", 1)
        f1.setGeometry(QgsGeometry.fromPolyline([QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853)]))
        temp_layer.dataProvider().addFeatures([f1])

        # set project CRS and ellipsoid
        srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId)
        QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4())
        QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid())
        QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid())
        QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84")
        QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Meters))

        idx = temp_layer.addExpressionField('$length', QgsField('length', QVariant.Double))  # NOQA

        # check value
        f = temp_layer.getFeatures().next()
        expected = 26932.156
        self.assertAlmostEqual(f['length'], expected, 3)

        # change project length unit, check calculation respects unit
        QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Feet))
        f = temp_layer.getFeatures().next()
        expected = 88360.0918635
        self.assertAlmostEqual(f['length'], expected, 3)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def test_ExpressionFieldEllipsoidAreaCalculation(self):
        #create a temporary layer
        temp_layer = QgsVectorLayer("Polygon?crs=epsg:3111&field=pk:int", "vl", "memory")
        self.assertTrue(temp_layer.isValid())
        f1 = QgsFeature(temp_layer.dataProvider().fields(), 1)
        f1.setAttribute("pk", 1)
        f1.setGeometry(QgsGeometry.fromPolygon([[QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853), QgsPoint(2520109, 2397715), QgsPoint(2520792, 2425494), QgsPoint(2484588, 2425722)]]))
        temp_layer.dataProvider().addFeatures([f1])

        # set project CRS and ellipsoid
        srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId)
        QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4())
        QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid())
        QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid())
        QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84")
        QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMeters))

        idx = temp_layer.addExpressionField('$area', QgsField('area', QVariant.Double))  # NOQA

        # check value
        f = temp_layer.getFeatures().next()
        expected = 1009089817.0
        self.assertAlmostEqual(f['area'], expected, delta=1.0)

        # change project area unit, check calculation respects unit
        QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMiles))
        f = temp_layer.getFeatures().next()
        expected = 389.6117565069
        self.assertAlmostEqual(f['area'], expected, 3)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def testEncodeDecodeLayoutUnits(self):
        """Test encoding and decoding layout units"""
        units = [QgsUnitTypes.LayoutMillimeters,
                 QgsUnitTypes.LayoutCentimeters,
                 QgsUnitTypes.LayoutMeters,
                 QgsUnitTypes.LayoutInches,
                 QgsUnitTypes.LayoutFeet,
                 QgsUnitTypes.LayoutPoints,
                 QgsUnitTypes.LayoutPicas,
                 QgsUnitTypes.LayoutPixels]

        for u in units:
            res, ok = QgsUnitTypes.decodeLayoutUnit(QgsUnitTypes.encodeUnit(u))
            assert ok
            self.assertEqual(res, u)

        # Test decoding bad units
        res, ok = QgsUnitTypes.decodeLayoutUnit('bad')
        self.assertFalse(ok)
        # default units should be MM
        self.assertEqual(res, QgsUnitTypes.LayoutMillimeters)

        # Test that string is cleaned before decoding
        res, ok = QgsUnitTypes.decodeLayoutUnit(' px  ')
        assert ok
        self.assertEqual(res, QgsUnitTypes.LayoutPixels)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def testEncodeDecodeDistanceUnits(self):
        """Test encoding and decoding distance units"""
        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.decodeDistanceUnit(QgsUnitTypes.encodeUnit(u))
            assert ok
            self.assertEqual(res, u)

        # Test decoding bad units
        res, ok = QgsUnitTypes.decodeDistanceUnit('bad')
        self.assertFalse(ok)
        self.assertEqual(res, QgsUnitTypes.DistanceUnknownUnit)

        # Test that string is cleaned before decoding
        res, ok = QgsUnitTypes.decodeDistanceUnit(' FeEt  ')
        assert ok
        self.assertEqual(res, QgsUnitTypes.DistanceFeet)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def testEncodeDecodeAreaUnits(self):
        """Test encoding and decoding area units"""
        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.decodeAreaUnit(QgsUnitTypes.encodeUnit(u))
            assert ok
            self.assertEqual(res, u)

        # Test decoding bad units
        res, ok = QgsUnitTypes.decodeAreaUnit('bad')
        self.assertFalse(ok)
        self.assertEqual(res, QgsUnitTypes.AreaUnknownUnit)

        # Test that string is cleaned before decoding
        res, ok = QgsUnitTypes.decodeAreaUnit(' Ha  ')
        assert ok
        self.assertEqual(res, QgsUnitTypes.AreaHectares)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
 def createBackgroundSettings(self):
     s = QgsTextBackgroundSettings()
     s.setEnabled(True)
     s.setType(QgsTextBackgroundSettings.ShapeEllipse)
     s.setSvgFile('svg.svg')
     s.setSizeType(QgsTextBackgroundSettings.SizeFixed)
     s.setSize(QSizeF(1, 2))
     s.setSizeUnit(QgsUnitTypes.RenderPixels)
     s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
     s.setRotationType(QgsTextBackgroundSettings.RotationFixed)
     s.setRotation(45)
     s.setOffset(QPointF(3, 4))
     s.setOffsetUnit(QgsUnitTypes.RenderMapUnits)
     s.setOffsetMapUnitScale(QgsMapUnitScale(5, 6))
     s.setRadii(QSizeF(11, 12))
     s.setRadiiUnit(QgsUnitTypes.RenderPixels)
     s.setRadiiMapUnitScale(QgsMapUnitScale(15, 16))
     s.setFillColor(QColor(255, 0, 0))
     s.setStrokeColor(QColor(0, 255, 0))
     s.setOpacity(0.5)
     s.setJoinStyle(Qt.RoundJoin)
     s.setBlendMode(QPainter.CompositionMode_Difference)
     s.setStrokeWidth(7)
     s.setStrokeWidthUnit(QgsUnitTypes.RenderMapUnits)
     s.setStrokeWidthMapUnitScale(QgsMapUnitScale(QgsMapUnitScale(25, 26)))
     s.setPaintEffect(QgsBlurEffect.create({'blur_level': '6.0', 'blur_unit': QgsUnitTypes.encodeUnit(QgsUnitTypes.RenderMillimeters), 'enabled': '1'}))
     return s

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [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 encodeUnit [as 别名]
 def createBufferSettings(self):
     s = QgsTextBufferSettings()
     s.setEnabled(True)
     s.setSize(5)
     s.setSizeUnit(QgsUnitTypes.RenderPixels)
     s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
     s.setColor(QColor(255, 0, 0))
     s.setFillBufferInterior(True)
     s.setOpacity(0.5)
     s.setJoinStyle(Qt.RoundJoin)
     s.setBlendMode(QPainter.CompositionMode_Difference)
     s.setPaintEffect(QgsBlurEffect.create({'blur_level': '2.0', 'blur_unit': QgsUnitTypes.encodeUnit(QgsUnitTypes.RenderMillimeters), 'enabled': '1'}))
     return s

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def testEncodeDecodeDistanceUnits(self):
        """Test encoding and decoding distance units"""
        units = [QGis.Meters, QGis.Feet, QGis.Degrees, QGis.UnknownUnit, QGis.NauticalMiles]

        for u in units:
            res, ok = QgsUnitTypes.decodeDistanceUnit(QgsUnitTypes.encodeUnit(u))
            assert ok
            self.assertEqual(res, u)

        # Test decoding bad units
        res, ok = QgsUnitTypes.decodeDistanceUnit("bad")
        self.assertFalse(ok)
        self.assertEqual(res, QGis.UnknownUnit)

        # Test that string is cleaned before decoding
        res, ok = QgsUnitTypes.decodeDistanceUnit(" FeEt  ")
        assert ok
        self.assertEqual(res, QGis.Feet)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def testEncodeDecodeSymbolUnits(self):
        """Test encoding and decoding symbol units"""
        units = [QgsSymbolV2.MM, QgsSymbolV2.MapUnit, QgsSymbolV2.Pixel, QgsSymbolV2.Percentage]

        for u in units:
            res, ok = QgsUnitTypes.decodeSymbolUnit(QgsUnitTypes.encodeUnit(u))
            assert ok
            self.assertEqual(res, u)

        # Test decoding bad units
        res, ok = QgsUnitTypes.decodeSymbolUnit("bad")
        self.assertFalse(ok)
        # default units should be MM
        self.assertEqual(res, QgsSymbolV2.MM)

        # Test that string is cleaned before decoding
        res, ok = QgsUnitTypes.decodeSymbolUnit(" PiXeL  ")
        assert ok
        self.assertEqual(res, QgsSymbolV2.Pixel)

# 需要导入模块: from qgis.core import QgsUnitTypes [as 别名]
# 或者: from qgis.core.QgsUnitTypes import encodeUnit [as 别名]
    def testEncodeDecodeRenderUnits(self):
        """Test encoding and decoding render units"""
        units = [QgsUnitTypes.RenderMillimeters,
                 QgsUnitTypes.RenderMapUnits,
                 QgsUnitTypes.RenderPixels,
                 QgsUnitTypes.RenderPercentage]

        for u in units:
            res, ok = QgsUnitTypes.decodeRenderUnit(QgsUnitTypes.encodeUnit(u))
            assert ok
            self.assertEqual(res, u)

        # Test decoding bad units
        res, ok = QgsUnitTypes.decodeRenderUnit('bad')
        self.assertFalse(ok)
        # default units should be MM
        self.assertEqual(res, QgsUnitTypes.RenderMillimeters)

        # Test that string is cleaned before decoding
        res, ok = QgsUnitTypes.decodeRenderUnit(' PiXeL  ')
        assert ok
        self.assertEqual(res, QgsUnitTypes.RenderPixels)

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