Python QgsRasterLayer.rasterUnitsPerPixelX方法代码示例

# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import rasterUnitsPerPixelX [as 别名]
    def test_clipRaster(self):
        """Raster layers can be clipped
        """

        # Create a raster layer
        myName = 'shake'
        myRasterLayer = QgsRasterLayer(RASTERPATH, myName)

        myMessage = 'Did not find layer "%s" in path "%s"' % \
                    (myName, RASTERPATH)
        assert myRasterLayer is not None, myMessage

        # Create a bounding box
        myRect = [97, -3, 104, 1]

        # Clip the vector to the bbox
        myResult = clip_layer(myRasterLayer, myRect)

        # Check the output is valid
        assert os.path.exists(myResult.source())

        # Clip and give a desired resolution for the output
        mySize = 0.05
        myResult = clip_layer(myRasterLayer, myRect, mySize)
        myNewRasterLayer = QgsRasterLayer(myResult.source(), myName)
        assert myNewRasterLayer.isValid(), 'Resampled raster is not valid'

        myMessage = ('Resampled raster has incorrect pixel size.'
                     'Expected: %f, Actual: %f' %
                     (mySize, myNewRasterLayer.rasterUnitsPerPixelX()))
        assert myNewRasterLayer.rasterUnitsPerPixelX() == mySize, myMessage

# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import rasterUnitsPerPixelX [as 别名]
    def test_clip_raster(self):
        """Raster layers can be clipped."""

        # Create a raster layer
        layer_name = 'shake'
        raster_layer = QgsRasterLayer(RASTERPATH, layer_name)

        message = (
            'Did not find layer "%s" in path "%s"' % (layer_name, RASTERPATH))
        assert raster_layer is not None, message

        # Create a bounding box
        bounding_box = [97, -3, 104, 1]

        # Clip the vector to the bbox
        result = clip_layer(raster_layer, bounding_box)

        # Check the output is valid
        assert os.path.exists(result.source())

        # Clip and give a desired resolution for the output
        # big pixel size
        size = 0.05
        result = clip_layer(raster_layer, bounding_box, size)
        new_raster_layer = QgsRasterLayer(result.source(), layer_name)
        assert new_raster_layer.isValid(), 'Resampled raster is not valid'
        message = (
            'Resampled raster has incorrect pixel size. Expected: %5f, '
            'Actual: %5f' % (size, new_raster_layer.rasterUnitsPerPixelX()))
        assert new_raster_layer.rasterUnitsPerPixelX() == size, message

# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import rasterUnitsPerPixelX [as 别名]
    def test_clip_raster_small(self):
        """Raster layers can be clipped in small and precise size. For #710."""

        # Create a raster layer
        layer_name = 'shake'
        raster_layer = QgsRasterLayer(RASTERPATH, layer_name)

        message = (
            'Did not find layer "%s" in path "%s"' % (layer_name, RASTERPATH))
        assert raster_layer is not None, message

        # Create a bounding box
        bounding_box = [97, -3, 104, 1]

        # Clip the vector to the bbox
        result = clip_layer(raster_layer, bounding_box)

        # Check the output is valid
        assert os.path.exists(result.source())

        # Clip and give a desired resolution for the output

        # small pixel size and high precision

        # based on pixel size of Flood_Current_Depth_Jakarta_geographic.asc
        size = 0.00045228819716
        result = clip_layer(raster_layer, bounding_box, size)
        new_raster_layer = QgsRasterLayer(result.source(), layer_name)
        assert new_raster_layer.isValid(), 'Resampled raster is not valid'
        message = (
            'Resampled raster has incorrect pixel size. Expected: %.14f, '
            'Actual: %.14f' % (
                size, new_raster_layer.rasterUnitsPerPixelX()))
        result_size = new_raster_layer.rasterUnitsPerPixelX()
        self.assertAlmostEqual(result_size, size, places=13, msg=message)

# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import rasterUnitsPerPixelX [as 别名]
class TestQGISRasterTools(unittest.TestCase):

    def setUp(self):
        self.raster = QgsRasterLayer(RASTER_BASE + '.tif', 'test')
        self.provider = self.raster.dataProvider()
        self.extent = self.raster.extent()
        self.x_res = self.raster.rasterUnitsPerPixelX()
        self.y_res = self.raster.rasterUnitsPerPixelY()

    def test_pixels_to_points(self):
        points = pixels_to_points(
            self.raster, threshold_min=1.0, threshold_max=1.5)

        # There are four such pixels only
        self.assertEquals(points.featureCount(), 4)
        for point in points.dataProvider().getFeatures():
            point = point.geometry().asPoint()

            # Move point in center of the pixels and get the value
            value = self.provider.identify(
                QgsPoint(
                    point.x() + 0.5 * self.x_res,
                    point.y() - 0.5 * self.y_res),
                QgsRaster.IdentifyFormatValue,
                self.extent)
            value = value.results()[1]
            self.assertGreater(value, 1.0)
            self.assertLess(value, 1.5)

        # Infinite threshold test
        points = pixels_to_points(self.raster, threshold_min=1.1)
        self.assertEquals(points.featureCount(), 8)
        for point in points.dataProvider().getFeatures():
            point = point.geometry().asPoint()

            # Move point in center of the pixels and get the value
            value = self.provider.identify(
                QgsPoint(
                    point.x() + 0.5 * self.x_res,
                    point.y() - 0.5 * self.y_res),
                QgsRaster.IdentifyFormatValue,
                self.extent)
            value = value.results()[1]
            self.assertGreater(value, 1.1)
    test_pixels_to_points.slow = True

    def test_polygonize(self):
        """Test if polygonize works"""
        geometry = polygonize(
            self.raster, threshold_min=1.0, threshold_max=1.5)
        # Result is one square
        self.assertTrue(geometry.isGeosValid())
        self.assertFalse(geometry.isMultipart())

        # noinspection PyArgumentEqualDefault
        geometry = polygonize(self.raster, threshold_min=0.0)
        # Result is several polygons
        self.assertTrue(geometry.isGeosValid())
        self.assertTrue(geometry.isMultipart())

        expected = QgsVectorLayer(VECTOR_BASE + '.shp', 'test', 'ogr')
        for feature in expected.getFeatures():
            # the layer has one feature only
            expected_geom = feature.geometry()
            self.assertTrue((geometry.isGeosEqual(expected_geom)))
    test_polygonize.slow = True

    def test_clip_raster(self):
        """Test clip_raster work"""
        new_raster = clip_raster(
            self.raster,
            self.raster.width(),
            self.raster.height(),
            self.extent
        )

        self.assertEqual(self.raster.rasterUnitsPerPixelY(),
                         new_raster.rasterUnitsPerPixelY())
        self.assertEqual(self.raster.rasterUnitsPerPixelX(),
                         new_raster.rasterUnitsPerPixelX())
        self.assertEqual(self.raster.extent(),
                         new_raster.extent())
        self.assertEqual(self.raster.width(),
                         new_raster.width())
        self.assertEqual(self.raster.height(),
                         new_raster.height())

        # Set extent as 1/2 of self.extent
        center = self.extent.center()
        x_max, y_max = center.x(), center.y()
        new_extent = QgsRectangle(
            self.extent.xMinimum(),
            self.extent.yMinimum(),
            x_max,
            y_max
        )
        new_raster = clip_raster(
            self.raster,
            self.raster.width(),
            self.raster.height(),
#.........这里部分代码省略.........

# 需要导入模块: from qgis.core import QgsRasterLayer [as 别名]
# 或者: from qgis.core.QgsRasterLayer import rasterUnitsPerPixelX [as 别名]
    def run(self):
        """Run method that performs all the real work"""
        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()
        # See if OK was pressed
        if result:
            # Do something useful here - delete the line containing pass and
            # substitute with your code.
            """read path from user input"""
            inputPath = self.dlg.Path.text()
            """set path for output file and concat file name to path"""
            outputPath = 'C:\Users\Administrator\Desktop\\'
            outputName = self.dlg.fileName.text()
            outputFile = outputPath + outputName
             
            """read image and calculate electrical conductivity and electrical Resistivity and set RGB for each pixel which R represent adj Pred Moist,
            G represents electrical conductivity and B represents electrical resistivity"""
            """for tiff file output"""
            if(self.dlg.tiff.isChecked()):
                oldImage = Image.open(inputPath)
                rgb_image = oldImage.convert('RGB')
                newImage = Image.new(oldImage.mode,oldImage.size,'white')
                for x in xrange(newImage.size[0]):
                    for y in xrange(newImage.size[1]):
                        R, G, B = rgb_image.getpixel((x, y))
                        sand = (R * 0.4 / 255.0)
                        clay = (G * 0.5 / 255.0)
                        om = (B * 5 / 255.0)
                        predMoist = -0.251 * sand + 0.195 * clay + 0.011 * om + 0.006 * sand * om - 0.027 * clay * om + 0.452 * sand * clay + 0.299
                        adjPredMoist = predMoist + (1.283 * predMoist * predMoist - 0.374 * predMoist - 0.015)
                        electricalConductivity = 0.000471052 * math.pow(100 * adjPredMoist, 3.458)
                        electricalResistivity = 1000.0 / electricalConductivity
                        newImage.putpixel((x,y),(int(adjPredMoist), int(electricalConductivity), int(electricalResistivity)))
                newImage.save(outputFile + '.tif')
            
            """create raster layer and calculate electrical conductivity and write in ASCII XYZ file which X and Y represent centroid coordinate of each pixel
            and Z represents electrical conductivity"""
            """for ASCII XYZ file output"""
            if(self.dlg.asciiXYZ.isChecked()):
                raster = QgsRasterLayer(inputPath)
                w = raster.width()
                h = raster.height()
                p = raster.dataProvider()
                b = p.block(0, p.extent(), w, h)
                f = file(outputFile + '.xyz', 'w')
                f.write('X,Y,Z(Electrical Conductivity)\n')
                pix_x = raster.rasterUnitsPerPixelX()
                pix_y = raster.rasterUnitsPerPixelY()
                half_x = pix_x / 2
                half_y = pix_y / 2
			
                extent = p.extent()
			
                count = 0
                y = extent.yMinimum()
                while y < extent.yMaximum():
                    y += pix_y
                    count += 1
                    x = extent.xMinimum()
                    while x < extent.xMaximum():
                        x += pix_x
                        pos = QgsPoint(x - half_x, y - half_y)
                        R = p.identify(pos, QgsRaster.IdentifyFormatValue).results()[1]
                        G = p.identify(pos, QgsRaster.IdentifyFormatValue).results()[2]
                        B = p.identify(pos, QgsRaster.IdentifyFormatValue).results()[3]
                        sand = (R * 0.4 / 255.0)
                        clay = (G * 0.5 / 255.0)
                        om = (B * 5 / 255.0)
                        predMoist = -0.251 * sand + 0.195 * clay + 0.011 * om + 0.006 * sand * om - 0.027 * clay * om + 0.452 * sand * clay + 0.299
                        adjPredMoist = predMoist + (1.283 * predMoist * predMoist - 0.374 * predMoist - 0.015)
                        electricalConductivity = 0.000471052 * math.pow(100 * adjPredMoist, 3.458)
                        f.write('%s, %s, %s\n' % (pos.x(),pos.y(), electricalConductivity))
                f.close()