Python QgsCoordinateReferenceSystem.createFromWkt方法代码示例

# 需要导入模块: from qgis.core import QgsCoordinateReferenceSystem [as 别名]
# 或者: from qgis.core.QgsCoordinateReferenceSystem import createFromWkt [as 别名]
 def test_projection(self):
     """Test that QGIS properly parses a wkt string.
     """
     crs = QgsCoordinateReferenceSystem()
     wkt = (
         'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
         'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
         'PRIMEM["Greenwich",0.0],UNIT["Degree",'
         '0.0174532925199433]]')
     crs.createFromWkt(wkt)
     auth_id = crs.authid()
     expected_auth_id = 'EPSG:4326'
     self.assertEqual(auth_id, expected_auth_id)

# 需要导入模块: from qgis.core import QgsCoordinateReferenceSystem [as 别名]
# 或者: from qgis.core.QgsCoordinateReferenceSystem import createFromWkt [as 别名]
 def coordinatetransform(self, layer=None):
     """
     Return the transform for WGS84 -> QGIS projection.
     """
     source = QgsCoordinateReferenceSystem()
     source.createFromWkt(
         'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]]'
     )
     if not layer:
         dest = self.canvas.mapRenderer().destinationCrs()
     else:
         dest = layer.crs()
     transform = QgsCoordinateTransform(source, dest)
     return transform

# 需要导入模块: from qgis.core import QgsCoordinateReferenceSystem [as 别名]
# 或者: from qgis.core.QgsCoordinateReferenceSystem import createFromWkt [as 别名]
 def _extractCrsFromPrj(self):
     crs = None
     if self._fileContainer.hasPrj():
         with open(self._fileContainer.pathToPrj) as prjfile:
             crsWkt = prjfile.readline()
             _crs = QgsCoordinateReferenceSystem()
             if _crs.createFromWkt(crsWkt):
                 crs = _crs
     return crs

# 需要导入模块: from qgis.core import QgsCoordinateReferenceSystem [as 别名]
# 或者: from qgis.core.QgsCoordinateReferenceSystem import createFromWkt [as 别名]
    def test_projection(self):
        """QGIS properly parses a wkt string"""
        crs = QgsCoordinateReferenceSystem()
        wkt = (
            'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
            'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
            'PRIMEM["Greenwich",0.0],UNIT["Degree",'
            '0.0174532925199433]]')
        crs.createFromWkt(wkt)
        auth_id = crs.authid()
        expected_auth_id = 'EPSG:4326'
        self.assertEqual(auth_id, expected_auth_id)

        # now test for a loaded layer
        path = os.path.join(os.path.dirname(__file__), 'tenbytenraster.asc')
        title = 'TestRaster'
        layer = QgsRasterLayer(path, title)
        auth_id = layer.crs().authid()
        self.assertEqual(auth_id, expected_auth_id)

# 需要导入模块: from qgis.core import QgsCoordinateReferenceSystem [as 别名]
# 或者: from qgis.core.QgsCoordinateReferenceSystem import createFromWkt [as 别名]
    def testProjInterpretation(self):
        """Test that QGIS properly parses a proj4 string.
        see https://github.com/AIFDR/inasafe/issues/349
        """
        myCrs = QgsCoordinateReferenceSystem()
        myProj4 = ('GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
                   'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
                   'PRIMEM["Greenwich",0.0],UNIT["Degree",'
                   '0.0174532925199433]]')
        myCrs.createFromWkt(myProj4)
        myAuthId = myCrs.authid()
        myExpectedAuthId = 'EPSG:4326'
        self.assertEqual(myAuthId, myExpectedAuthId)

        # now test for a loaded layer
        myPath = os.path.join(EXPDATA, 'glp10ag.asc')
        myTitle = 'people'
        myLayer = QgsRasterLayer(myPath, myTitle)
        myAuthId = myLayer.crs().authid()
        self.assertEqual(myAuthId, myExpectedAuthId)

# 需要导入模块: from qgis.core import QgsCoordinateReferenceSystem [as 别名]
# 或者: from qgis.core.QgsCoordinateReferenceSystem import createFromWkt [as 别名]
    def test_proj_interpretation(self):
        """Test that QGIS properly parses a proj4 string.
        see https://github.com/AIFDR/inasafe/issues/349
        """
        # noinspection PyCallingNonCallable
        crs = QgsCoordinateReferenceSystem()
        proj4 = (
            'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
            'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
            'PRIMEM["Greenwich",0.0],UNIT["Degree",'
            '0.0174532925199433]]')
        crs.createFromWkt(proj4)
        auth_id = crs.authid()
        expected_auth_id = 'EPSG:4326'
        self.assertEqual(auth_id, expected_auth_id)

        # now test for a loaded layer
        path = standard_data_path('hazard', 'jakarta_flood_design.tif')
        title = 'Jakarta Flood'
        # noinspection PyCallingNonCallable
        layer = QgsRasterLayer(path, title)
        auth_id = layer.crs().authid()
        self.assertEqual(auth_id, expected_auth_id)

# 需要导入模块: from qgis.core import QgsCoordinateReferenceSystem [as 别名]
# 或者: from qgis.core.QgsCoordinateReferenceSystem import createFromWkt [as 别名]
class GSIElevTileProvider:

  def __init__(self, dest_wkt):
    self.dest_wkt = dest_wkt

    # crs transformer, which aims to calculate bbox in EPSG:3857
    self.crs3857 = QgsCoordinateReferenceSystem(3857)
    self.dest_crs = QgsCoordinateReferenceSystem()
    if not self.dest_crs.createFromWkt(dest_wkt):
      logMessage("Failed to create CRS from WKT: {0}".format(dest_wkt))
    self.transform = QgsCoordinateTransform(self.dest_crs, self.crs3857)

    # approximate bbox of this data
    self.boundingbox = QgsRectangle(13667807, 2320477, 17230031, 5713298)

    self.downloader = Downloader()
    self.downloader.userAgent = "QGIS/{0} Qgis2threejs GSIElevTileProvider".format(QGis.QGIS_VERSION)  # not written since QGIS 2.2
    self.downloader.DEFAULT_CACHE_EXPIRATION = QSettings().value("/qgis/defaultTileExpiry", 24, type=int)

    self.driver = gdal.GetDriverByName("MEM")
    self.last_dataset = None

  def name(self):
    return "GSI Elevation Tile"

  def read(self, width, height, extent):
    # calculate bounding box in EPSG:3857
    geometry = extent.geometry()
    geometry.transform(self.transform)
    merc_rect = geometry.boundingBox()

    # if the bounding box doesn't intersect with the bounding box of this data, return a list filled with nodata value
    if not self.boundingbox.intersects(merc_rect):
      return [NODATA_VALUE] * width * height

    # get tiles
    over_smpl = 1
    segments_x = 1 if width == 1 else width - 1
    res = extent.width() / segments_x / over_smpl
    ds = self.getDataset(merc_rect.xMinimum(), merc_rect.yMinimum(), merc_rect.xMaximum(), merc_rect.yMaximum(), res)

    geotransform = extent.geotransform(width, height)
    return self._read(ds, width, height, geotransform)

  def readValue(self, x, y):
    """Get value at the position using 1px * 1px memory raster. The value is calculated using a tile of max zoom level"""
    # coordinate transformation into EPSG:3857
    pt = self.transform.transform(QgsPoint(x, y))

    # if the point is not within the bounding box of this data, return nodata value
    if not self.boundingbox.contains(pt):
      return NODATA_VALUE

    res = 0.1
    hres = res / 2
    ds = self.getDataset(pt.x() - hres, pt.y() - hres, pt.x() + hres, pt.y() + hres, res)

    geotransform = [x - hres, res, 0, y + hres, 0, -res]
    return self._read(ds, 1, 1, geotransform)[0]

  def _read(self, ds, width, height, geotransform):
    # create a memory dataset
    warped_ds = self.driver.Create("", width, height, 1, gdal.GDT_Float32)
    warped_ds.SetProjection(self.dest_wkt)
    warped_ds.SetGeoTransform(geotransform)

    # reproject image
    gdal.ReprojectImage(ds, warped_ds, None, None, gdal.GRA_Bilinear)

    # load values into an array
    band = warped_ds.GetRasterBand(1)
    fs = "f" * width * height
    return struct.unpack(fs, band.ReadRaster(0, 0, width, height, buf_type=gdal.GDT_Float32))

  def getDataset(self, xmin, ymin, xmax, ymax, mapUnitsPerPixel):
    # calculate zoom level
    mpp1 = TSIZE1 / TILE_SIZE
    zoom = int(math.ceil(math.log(mpp1 / mapUnitsPerPixel, 2) + 1))
    zoom = max(0, min(zoom, ZMAX))

    # calculate tile range (yOrigin is top)
    size = TSIZE1 / 2 ** (zoom - 1)
    matrixSize = 2 ** zoom
    ulx = max(0, int((xmin + TSIZE1) / size))
    uly = max(0, int((TSIZE1 - ymax) / size))
    lrx = min(int((xmax + TSIZE1) / size), matrixSize - 1)
    lry = min(int((TSIZE1 - ymin) / size), matrixSize - 1)

    cols = lrx - ulx + 1
    rows = lry - uly + 1

    # download count limit
    if cols * rows > 128:
      logMessage("Number of tiles to fetch is too large!")
      width = height = 1
      return self.driver.Create("", width, height, 1, gdal.GDT_Float32, [])

    if self.last_dataset and self.last_dataset[0] == [zoom, ulx, uly, lrx, lry]:    # if same as last tile set, return cached dataset
      return self.last_dataset[1]

#.........这里部分代码省略.........