def osr_ct_6(): if gdaltest.have_proj4 == 0: return 'skip' ct = osr.CreateCoordinateTransformation(None, None) if ct is not None: return 'fail' utm_srs = osr.SpatialReference() utm_srs.SetUTM(11) utm_srs.SetWellKnownGeogCS('WGS84') ll_srs = osr.SpatialReference() ll_srs.SetWellKnownGeogCS('WGS84') ct = osr.CreateCoordinateTransformation(ll_srs, utm_srs) if ct is None: return 'fail' result = ct.TransformPoints(((-117.5, 32.0, 0.0), (-117.5, 32.0))) for i in range(2): if abs(result[i][0] - 452772.06) > 0.01 \ or abs(result[i][1] - 3540544.89) > 0.01 \ or abs(result[i][2] - 0.0) > 0.01: gdaltest.post_reason('Wrong LL to UTM result') return 'fail' return 'success'
def setParams(layer): srs = layer.GetSpatialRef() wkt7390 = 'PROJCS["Brazil / Albers Equal Area Conic (WGS84)",GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]],PROJECTION["Albers_Conic_Equal_Area"],PARAMETER["longitude_of_center",-50.0],PARAMETER["standard_parallel_1",10.0],PARAMETER["standard_parallel_2",-40.0],PARAMETER["latitude_of_center",-25.0],UNIT["Meter",1.0]]' sr7390 = osr.SpatialReference() sr7390.ImportFromWkt(wkt7390) AggregatorParams.srs = srs AggregatorParams.ctArea = osr.CreateCoordinateTransformation( srs, sr7390) AggregatorParams.ctOrigin = osr.CreateCoordinateTransformation( sr7390, srs)
def _get_transforms(self, sr_origin, rect, rect_from='origin'): """Retrieve the `to_work` and `to_origin` conversion functions. Parameters ---------- sr_origin: osr.SpatialReference rect: Footprint or extent or None rect_from: one of ('origin', 'work') """ assert rect_from in ['origin', 'work'] if not self._sr_work: return None, None if self._sr_origin: sr_origin = self._sr_origin elif not sr_origin: if self._sr_implicit: sr_origin = self._sr_implicit else: raise ValueError("Missing origin's spatial reference") to_work = osr.CreateCoordinateTransformation( sr_origin, self._sr_work).TransformPoints to_origin = osr.CreateCoordinateTransformation( self._sr_work, sr_origin).TransformPoints to_work = self._make_transfo(to_work) to_origin = self._make_transfo(to_origin) if self._analyse_transformations: if rect_from == 'origin': an = srs.Analysis(to_work, to_origin, rect) else: an = srs.Analysis(to_origin, to_work, rect) if rect is None: pass elif isinstance(rect, Footprint): if not an.ratio_valid: raise ValueError( 'Bad coord transformation for raster proxy: {}'.format( an.messages)) else: minx, maxx, miny, maxy = rect if minx != maxx and miny != maxy: if not an.inverse_valid: raise ValueError( 'Bad coord transformation for vector proxy: {}'. format(an.messages)) return to_work, to_origin
def pcs_2000_to_sz_local(self, points): helmert_para = helmert_para_dict(4547, 2435, "EAST") opt = osr.CoordinateTransformationOptions() opt.SetOperation(helmert_para) tr = osr.CreateCoordinateTransformation(None, None, opt) points = osr.CoordinateTransformation.TransformPoints(tr, points) return points
def get_map_size(): if param_reference in maps: refmap = maps[param_reference] else: print("Map", param_reference, "does not exist.") return if param_crop: if param_reproject: north, east, south, west = param_region minp = merc_transform.TransformPoint(west, south) maxp = merc_transform.TransformPoint(east, north) pxsize = param_hscale / np.cos(np.radians((north+south)/2)) npx = (maxp[0]-minp[0]) // pxsize npy = (maxp[1]-minp[1]) // pxsize return int(npx), int(npy), 0, 0, pxsize else: gt = refmap.GetGeoTransform() proj = osr.SpatialReference() proj.ImportFromWkt(refmap.GetProjection()) transform = osr.CreateCoordinateTransformation(wgs, proj) north, east, south, west = param_region xNW, yNW = gm.inverse(gt, transform.TransformPoint(west, north)) xSE, ySE = gm.inverse(gt, transform.TransformPoint(east, south)) xmin = np.floor(min(xNW, xSE)+.5) xmax = np.floor(max(xNW, xSE)+.5) ymin = np.floor(min(yNW, ySE)+.5) ymax = np.floor(max(yNW, ySE)+.5) return int(xmax-xmin+1), int(ymax-ymin+1), int(xmin), int(ymin), 0 else: return refmap.RasterXSize, refmap.RasterYSize, 0, 0, 0
def read_map(mapname, interp=gdal.GRA_NearestNeighbour): npx, npy, xmin, ymin, pxsize = get_map_size() if mapname in maps: map1 = maps[mapname] else: print("Map", mapname, "does not exist.") return print("Reading", mapname) if param_reproject: proj = mercator transform = merc_transform north, east, south, west = param_region origin = merc_transform.TransformPoint(west, north) geotransform = (origin[0], pxsize, 0., origin[1], 0., -pxsize) elif mapname == param_reference: return map1.ReadAsArray(xmin, ymin, npx, npy) else: refmap = maps[param_reference] proj = osr.SpatialReference() proj.ImportFromWkt(refmap.GetProjection()) transform = osr.CreateCoordinateTransformation(wgs, proj) ref_gt = refmap.GetGeoTransform() origin = gm.transform(ref_gt, (xmin, ymin)) geotransform = (origin[0], ref_gt[1], ref_gt[2], origin[1], ref_gt[4], ref_gt[5]) map2 = drv.Create("", npx, npy, 1, map1.GetRasterBand(1).DataType) map2.SetGeoTransform(geotransform) print("Reprojecting", mapname) gdal.ReprojectImage(map1, map2, map1.GetProjection(), proj.ExportToWkt(), interp) return map2.ReadAsArray()
def run(self): try: conn = psycopg2.connect("dbname=" + str(self.database) + " user='******' host='" + str(self.host) + "' password='******'") except: print "I am unable to connect to the database" source_osr = osr.SpatialReference() source_osr.ImportFromEPSG(4326) target_osr = osr.SpatialReference() target_osr.ImportFromEPSG(32755) transformation = osr.CreateCoordinateTransformation(source_osr, target_osr) cur = conn.cursor() filter_query = "" if self.node_station.get_attribute_filter_sql_string(""): filter_query = "WHERE " + self.node_station.get_attribute_filter_sql_string("") cur.execute("SELECT * from station " + filter_query) rows = cur.fetchall() for r in rows: station = self.node_station.create_feature() station.SetField("dance_station_id", r[0]) print r pt = ogr.Geometry(ogr.wkbPoint) pt.SetPoint_2D(0, r[4], r[5]) pt.Transform(transformation) station.SetGeometry(pt) self.node_station.finalise()
def CoordinateTransform(vertexs, srs, des): transformer = osr.CreateCoordinateTransformation(srs, des) result = np.empty((0, 2), float) for i in range(len(vertexs)): coords = transformer.TransformPoint(vertexs[i][0], vertexs[i][1]) result = np.append(result, [[coords[0], coords[1]]], axis = 0) return result
def __init__(self, from_epsg: int, to_epsg: int): self._s_srs = osr.SpatialReference() self._s_srs.ImportFromEPSG(from_epsg) self._t_srs = osr.SpatialReference() self._t_srs.ImportFromEPSG(to_epsg) self._transform = osr.CreateCoordinateTransformation( self._s_srs, self._t_srs)
def proj_transform(self, srcSRS, dstSRS, points): sourceSRS = osr.SpatialReference() sourceSRS.ImportFromEPSG(srcSRS) destinationSRS = osr.SpatialReference() destinationSRS.ImportFromEPSG(dstSRS) tr = osr.CreateCoordinateTransformation(sourceSRS, destinationSRS) points = osr.CoordinateTransformation.TransformPoints(tr, points) return points
def get_transforms(self, sr_virtual, rect, rect_from='virtual'): """Retrieve the `to_work` and `to_virtual` conversion functions. Parameters ---------- sr_virtual: osr.SpatialReference rect: Footprint or extent or None rect_from: one of ('virtual', 'work') """ assert rect_from in ['virtual', 'work'] if self.sr_work is None: return None, None assert sr_virtual is not None to_work = osr.CreateCoordinateTransformation(sr_virtual, self.sr_work).TransformPoints to_virtual = osr.CreateCoordinateTransformation(self.sr_work, sr_virtual).TransformPoints to_work = self._make_transfo(to_work) to_virtual = self._make_transfo(to_virtual) if self.analyse_transformations: if rect_from == 'virtual': an = srs.Analysis(to_work, to_virtual, rect) else: an = srs.Analysis(to_virtual, to_work, rect) if rect is None: pass elif isinstance(rect, Footprint): if not an.ratio_valid: raise ValueError('Bad coord transformation for raster proxy: {}'.format( an.messages )) else: minx, maxx, miny, maxy = rect if minx != maxx and miny != maxy: if not an.inverse_valid: raise ValueError( 'Bad coord transformation for vector proxy: {}'.format(an.messages) ) return to_work, to_virtual
def __enter__(self): input_srs = osr.SpatialReference() input_srs.ImportFromEPSG(self.input_srid) data_srs = osr.SpatialReference() data_srs.ImportFromEPSG(self.datasource_srid) self.input_transform = osr.CreateCoordinateTransformation( input_srs, data_srs) self.dem = gdal.Open(self.datasource) self.data = self.dem.GetRasterBand(self.band) self.nodata = self.data.GetNoDataValue() return self
def test_osr_ct_6(): ct = osr.CreateCoordinateTransformation(None, None) assert ct is None utm_srs = osr.SpatialReference() utm_srs.SetUTM(11) utm_srs.SetWellKnownGeogCS('WGS84') ll_srs = osr.SpatialReference() ll_srs.SetWellKnownGeogCS('WGS84') ll_srs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER) ct = osr.CreateCoordinateTransformation(ll_srs, utm_srs) assert ct is not None result = ct.TransformPoints(((-117.5, 32.0, 0.0), (-117.5, 32.0))) for i in range(2): assert result[i][0] == pytest.approx(452772.06, abs=0.01) and result[i][1] == pytest.approx(3540544.89, abs=0.01) and result[i][2] == pytest.approx(0.0, abs=0.01), \ 'Wrong LL to UTM result'
def run(self): try: conn = psycopg2.connect("dbname=" + str(self.database) + " user='******' host='" + str(self.host) + "' password='******'") except: print("I am unable to connect to the database") source_osr = osr.SpatialReference() source_osr.ImportFromEPSG(4326) target_osr = osr.SpatialReference() target_osr.ImportFromEPSG( self.getSimulationConfig().getCoorindateSystem()) transformation = osr.CreateCoordinateTransformation( source_osr, target_osr) cur = conn.cursor() filter_query = "" if self.node_station.get_attribute_filter_sql_string(""): filter_query = "WHERE " + self.node_station.get_attribute_filter_sql_string( "") if filter_query == "" and self.filter != "": filter_query = "WHERE " + self.filter elif self.filter != "": filter_query = filter_query + " AND " + self.filter log(filter_query, Standard) cur.execute("SELECT * from " + self.station_table + " " + filter_query) rows = cur.fetchall() for r in rows: station = self.node_station.create_feature() station.SetField("dance_station_id", r[0]) station.SetField("name", r[1]) station.SetField("description", r[2]) station.SetField("short_description", r[3]) station.SetField("start_date", str(r[8])) station.SetField("end_date", str(r[9])) print(r) pt = ogr.Geometry(ogr.wkbPoint) pt.SetPoint_2D(0, r[4], r[5]) pt.Transform(transformation) station.SetGeometry(pt) self.node_station.finalise()
def test_osr_ct_6(): if gdaltest.have_proj4 == 0: pytest.skip() ct = osr.CreateCoordinateTransformation(None, None) assert ct is None utm_srs = osr.SpatialReference() utm_srs.SetUTM(11) utm_srs.SetWellKnownGeogCS('WGS84') ll_srs = osr.SpatialReference() ll_srs.SetWellKnownGeogCS('WGS84') ct = osr.CreateCoordinateTransformation(ll_srs, utm_srs) assert ct is not None result = ct.TransformPoints(((-117.5, 32.0, 0.0), (-117.5, 32.0))) for i in range(2): assert abs(result[i][0] - 452772.06) <= 0.01 and abs(result[i][1] - 3540544.89) <= 0.01 and abs(result[i][2] - 0.0) <= 0.01, \ 'Wrong LL to UTM result'
def LATLONG_TO_XY(path_to_tiff, lat, long): data = gdal.Open(path_to_tiff) target = osr.SpatialReference(wkt=data.GetProjection()) source = osr.SpatialReference() source.ImportFromEPSG(4326) transform = osr.CreateCoordinateTransformation(source, target) point = ogr.Geometry(ogr.wkbPoint) point.AddPoint(lat, long) point.Transform(transform) x, y = world_to_pixel(path_to_tiff, data.GetGeoTransform(), point.GetX(), point.GetY()) list1 = [x, y] return list1
def get_map_bounds(mapname): if mapname in maps: thismap = maps[mapname] else: print("Map", mapname, "does not exist.") return xsize, ysize = thismap.RasterXSize, thismap.RasterYSize gt = thismap.GetGeoTransform() proj = osr.SpatialReference() proj.ImportFromWkt(thismap.GetProjection()) transform = osr.CreateCoordinateTransformation(proj, wgs) minp = gm.transform(gt, (0, 0)) maxp = gm.transform(gt, (xsize, ysize)) xmin, ymin, _ = transform.TransformPoint(minp[0], minp[1]) xmax, ymax, _ = transform.TransformPoint(maxp[0], maxp[1]) north = max(ymin, ymax) # Maps might be reversed, so we're not sure which one is actually the maximum east = max(xmin, xmax) south = min(ymin, ymax) west = min(xmin, xmax) return (north, east, south, west)
def test_proj_transformation_grid(): import kart # noqa from osgeo import osr # note kart.__init__ sets PROJ_NETWORK=ON and PROJ_LIB to the proj data files # during tests $HOME is changed to a temporary dir, so downloaded grids in the # user proj data dir will be empty/missing # TODO: except for windows where somehow it's buggy and we get a network error print("PROJ/GDAL-related environment variables:") for k, v in os.environ.items(): if re.match(r"^(GDAL|PROJ|CPL)_", k): print(f"${k}={v}") print("osr.GetPROJSearchPaths():", osr.GetPROJSearchPaths()) print("osr.GetPROJAuxDbPaths():", osr.GetPROJAuxDbPaths()) # print("osr.GetPROJEnableNetwork():", osr.GetPROJEnableNetwork()) # not in the Python bindings yet # Do a test conversion to check the transformation grids are available nzgd49 = osr.SpatialReference() nzgd49.ImportFromEPSG(4272) # NZGD1949 nzgd2k = osr.SpatialReference() nzgd2k.ImportFromEPSG(4167) # NZGD2000 ct = osr.CreateCoordinateTransformation(nzgd49, nzgd2k) # Test point from: https://www.linz.govt.nz/data/geodetic-system/coordinate-conversion/geodetic-datum-conversions/datum-transformation-examples pt = ct.TransformPoint(-36.5, 175.0) # Equivalent commands: # $ echo 175.0 -36.5 | PROJ_DEBUG=2 CPL_DEBUG=ON gdaltransform -s_srs EPSG:4272 -t_srs EPSG:4167 # $ echo -36.5 175.0 0 | PROJ_DEBUG=2 cs2cs -v -f "%.8f" EPSG:4272 EPSG:4167 if not is_windows: # This is the (desired) accurate result expected when the transformation grid is available: assert pt == pytest.approx((-36.49819023, 175.00019297, 0.0), abs=1e-8) else: # This is the less accurate result which uses the 7-parameter transform, # which indicates that the transformation grid is not available # # Currently the Windows proj libraries are built without network # support, so we can't auto-fetch grids assert pt == pytest.approx((-36.49819267, 175.00018527, 0.0), abs=1e-8)
def create_coordinate_transformer( base_ref, target_ref, osr_axis_mapping_strategy=DEFAULT_OSR_AXIS_MAPPING_STRATEGY): """Create a spatial reference coordinate transformation function. Args: base_ref (osr spatial reference): A defined spatial reference to transform FROM target_ref (osr spatial reference): A defined spatial reference to transform TO osr_axis_mapping_strategy (int): OSR axis mapping strategy for ``SpatialReference`` objects. Defaults to ``utils.DEFAULT_OSR_AXIS_MAPPING_STRATEGY``. This parameter should not be changed unless you know what you are doing. Returns: An OSR Coordinate Transformation object """ # Make a copy of the base and target spatial references to avoid side # effects from mutation of setting the axis mapping strategy base_ref_wkt = base_ref.ExportToWkt() target_ref_wkt = target_ref.ExportToWkt() base_ref_copy = osr.SpatialReference() target_ref_copy = osr.SpatialReference() base_ref_copy.ImportFromWkt(base_ref_wkt) target_ref_copy.ImportFromWkt(target_ref_wkt) base_ref_copy.SetAxisMappingStrategy(osr_axis_mapping_strategy) target_ref_copy.SetAxisMappingStrategy(osr_axis_mapping_strategy) transformer = osr.CreateCoordinateTransformation(base_ref_copy, target_ref_copy) return transformer
def _get_center_coords(self, wkt, geotransform, data_shape): wgs84 = osr.SpatialReference() wgs84.ImportFromEPSG(4326) spatial = osr.SpatialReference() spatial.ImportFromWkt(wkt) affine_transform = AffineGlobalCoords(geotransform) if len(data_shape) == 3: y_size = data_shape[1] x_size = data_shape[2] else: y_size = data_shape[0] x_size = data_shape[1] transform = osr.CreateCoordinateTransformation(spatial, wgs84) proj_y, proj_x = affine_transform.getProjectedYX( y_size / 2, x_size / 2) center_lon, center_lat = transform.TransformPoint(proj_x, proj_y)[:2] return center_lon, center_lat
def convert_geometry( geometry: ogr.Geometry, new_spatialreference: osr.SpatialReference) -> ogr.Geometry: """Converts the geometry to the new spatial reference if possible Arguments: geometry - The geometry to transform new_spatialreference - The spatial reference to change to Returns: The transformed geometry or the original geometry. If either the new Spatial Reference parameter is None, or the geometry doesn't have a spatial reference, then the original geometry is returned. """ if not new_spatialreference or not geometry: return geometry return_geometry = geometry try: geom_sr = geometry.GetSpatialReference() if int(osgeo.__version__[0]) >= 3: # GDAL 3 changes axis order: https://github.com/OSGeo/gdal/issues/1546 # pylint: disable=no-member geom_sr.SetAxisMappingStrategy( osgeo.osr.OAMS_TRADITIONAL_GIS_ORDER) if geom_sr and not new_spatialreference.IsSame(geom_sr): transform = osr.CreateCoordinateTransformation( geom_sr, new_spatialreference) new_geom = geometry.Clone() if new_geom: new_geom.Transform(transform) return_geometry = new_geom except Exception as ex: logging.warning("Exception caught while transforming geometries: %s", str(ex)) logging.warning(" Returning original geometry") return return_geometry
def extract_grid_ppt(sub_netcdf_list, in_cat_shp, sub_out_cat_data_df, ppt_que): ''' Extract precipitation from a given list of netCDf files The catchments shapefile can have one more catchment polygons. Change names of variables and values inside the function, (not everything is specified through the arguments). ''' cat_vec = ogr.Open(in_cat_shp) lyr = cat_vec.GetLayer(0) spt_ref = lyr.GetSpatialRef() trgt = osr.SpatialReference() trgt.ImportFromEPSG(4326) tfm = osr.CreateCoordinateTransformation(spt_ref, trgt) back_tfm = osr.CreateCoordinateTransformation(trgt, spt_ref) #raise Exception feat_dict = {} feat_area_dict = {} cat_area_ratios_dict = {} cat_envel_dict = {} feat = lyr.GetNextFeature() while feat: geom = feat.GetGeometryRef() f_val = feat.GetFieldAsString('DN') if f_val is None: raise RuntimeError feat_area_dict[f_val] = geom.Area() # do before transform geom.Transform(tfm) feat_dict[f_val] = feat cat_envel_dict[f_val] = geom.GetEnvelope() # do after transform feat = lyr.GetNextFeature() for netcdf in sub_netcdf_list: #print 'Going through: %s' % netcdf in_nc = nc.Dataset(netcdf) lat_arr = in_nc.variables['latitude'][:] lon_arr = in_nc.variables['longitude'][:] apply_cell_correc = True # convert the netCDF time to regular time time_var = in_nc.variables['time'] time_arr = nc.num2date(in_nc.variables['time'][:], time_var.units, calendar=time_var.calendar) ppt_var = in_nc.variables['precip'] #print 'Counting time from (in the netCDF file):',time_var.units #print 'Start date in the netCDF: ', time_arr[0] #print 'End date in the netCDF: ', time_arr[-1] #print 'Total time steps in the netCDF: ', time_arr.shape[0] cell_size = round(lon_arr[1] - lon_arr[0], 3) x_l_c = lon_arr[0] x_u_c = lon_arr[-1] y_l_c = lat_arr[0] y_u_c = lat_arr[-1] #raise Exception if apply_cell_correc: # because CHIRPS has values at the center of the cell # so I shift it back x_l_c -= (cell_size/2.) x_u_c -= (cell_size/2.) y_l_c -= (cell_size/2.) y_u_c -= (cell_size/2.) x_coords = np.arange(x_l_c, x_u_c * 1.00000001, cell_size)# - (cell_size / 2) y_coords = np.arange(y_l_c, y_u_c * 1.00000001, cell_size)# - (cell_size / 2) cat_x_idxs_dict = {} cat_y_idxs_dict = {} for cat_no in list(feat_dict.keys()): #print 'Cat no:', cat_no geom = feat_dict[cat_no].GetGeometryRef() extents = cat_envel_dict[cat_no] cat_area = feat_area_dict[cat_no] inter_areas = [] x_low, x_hi, y_low, y_hi = extents # adjustment to get all cells intersecting the polygon x_low, x_hi, y_low, y_hi = x_low - cell_size, x_hi + cell_size, y_low - cell_size, y_hi + cell_size x_cors_idxs = np.where(np.logical_and(x_coords >= x_low, x_coords <= x_hi))[0] y_cors_idxs = np.where(np.logical_and(y_coords >= y_low, y_coords <= y_hi))[0] x_cors = x_coords[x_cors_idxs] y_cors = y_coords[y_cors_idxs] cat_x_idxs = [] cat_y_idxs = [] for x_idx in range(x_cors.shape[0] - 1): for y_idx in range(y_cors.shape[0] - 1): ring = ogr.Geometry(ogr.wkbLinearRing) ring.AddPoint(x_cors[x_idx], y_cors[y_idx]) ring.AddPoint(x_cors[x_idx + 1], y_cors[y_idx]) ring.AddPoint(x_cors[x_idx + 1], y_cors[y_idx + 1]) ring.AddPoint(x_cors[x_idx], y_cors[y_idx + 1]) ring.AddPoint(x_cors[x_idx], y_cors[y_idx]) poly = ogr.Geometry(ogr.wkbPolygon) poly.AddGeometry(ring) inter_poly = poly.Intersection(geom) # to get the area, I convert it to coordinate sys of the shapefile # that is hopefully in linear units inter_poly.Transform(back_tfm) inter_area = inter_poly.Area() inter_areas.append(inter_area) cat_x_idxs.append((x_cors[x_idx] - x_l_c) / cell_size) cat_y_idxs.append((y_cors[y_idx] - y_l_c) / cell_size) cat_area_ratios_dict[cat_no] = np.divide(inter_areas, cat_area) cat_x_idxs_dict[cat_no] = np.int64(np.round(cat_x_idxs, 6)) cat_y_idxs_dict[cat_no] = np.int64(np.round(cat_y_idxs, 6)) #print 'Normalized area sum:', np.sum(cat_area_ratios_dict[cat_no]) for idx, date in enumerate(time_arr): if date in sub_out_cat_data_df.index: all_ppt_vals = ppt_var[idx] for cat_no in list(feat_dict.keys()): ppt_vals = all_ppt_vals[cat_y_idxs_dict[cat_no], cat_x_idxs_dict[cat_no]] fin_ppt_vals = np.multiply(ppt_vals, cat_area_ratios_dict[cat_no]) sub_out_cat_data_df.loc[date][cat_no] = round(np.sum(fin_ppt_vals), 2) #print '\n\n' in_nc.close() ppt_que.put(sub_out_cat_data_df) cat_vec.Destroy() return
def features(self, request=None, clipGeom=None): settings = self.writer.settings mapTo3d = settings.mapTo3d() baseExtent = settings.baseExtent baseExtentGeom = baseExtent.geometry() rotation = baseExtent.rotation() prop = self.prop useZ = prop.useZ() if useZ: srs_from = osr.SpatialReference() srs_from.ImportFromProj4(str(self.layer.crs().toProj4())) srs_to = osr.SpatialReference() srs_to.ImportFromProj4(str(self.writer.settings.crs.toProj4())) ogr_transform = osr.CreateCoordinateTransformation(srs_from, srs_to) clipGeomWkb = bytes(clipGeom.exportToWkb()) if clipGeom else None ogr_clipGeom = ogr.CreateGeometryFromWkb(clipGeomWkb) if clipGeomWkb else None else: # z_func: function to get elevation at given point (x, y) on surface if prop.isHeightRelativeToDEM(): if self.geomType == QgsWkbTypes.PolygonGeometry and prop.type_index == 1: # Overlay z_func = lambda x, y: 0 else: # get elevation from DEM z_func = lambda x, y: self.writer.demProvider.readValue(x, y) else: z_func = lambda x, y: 0 feats = [] request = request or QgsFeatureRequest() for f in self.layer.getFeatures(request): geometry = f.geometry() if geometry is None: logMessage("null geometry skipped") continue # coordinate transformation - layer crs to project crs geom = QgsGeometry(geometry) if geom.transform(self.transform) != 0: logMessage("Failed to transform geometry") continue # check if geometry intersects with the base extent (rotated rect) if rotation and not baseExtentGeom.intersects(geom): continue # create feature feat = Feature(self.writer, self, f) # transform_func: function to transform the map coordinates to 3d coordinates relativeHeight = prop.relativeHeight(f) def transform_func(x, y, z): return mapTo3d.transform(x, y, z + relativeHeight) if useZ: ogr_geom = ogr.CreateGeometryFromWkb(bytes(geometry.exportToWkb())) # transform geometry from layer CRS to project CRS if ogr_geom.Transform(ogr_transform) != 0: logMessage("Failed to transform geometry") continue # clip geometry if ogr_clipGeom and self.geomType == QgsWkbTypes.LineGeometry: ogr_geom = ogr_geom.Intersection(ogr_clipGeom) if ogr_geom is None: continue # check if geometry is empty if ogr_geom.IsEmpty(): logMessage("empty geometry skipped") continue feat.geom = self.geomClass.fromOgrGeometry25D(ogr_geom, transform_func) else: # clip geometry if clipGeom and self.geomType in [QgsWkbTypes.LineGeometry, QgsWkbTypes.PolygonGeometry]: geom = geom.intersection(clipGeom) if geom is None: continue # skip if geometry is empty or null if geom.isEmpty() or geom.isNull(): logMessage("empty/null geometry skipped") continue if self.geomType == QgsWkbTypes.PolygonGeometry: feat.geom = self.geomClass.fromQgsGeometry(geom, z_func, transform_func, self.hasLabel()) if prop.type_index == 1 and prop.isHeightRelativeToDEM(): # Overlay and relative to DEM feat.geom.splitPolygon(self.writer.triangleMesh()) else: feat.geom = self.geomClass.fromQgsGeometry(geom, z_func, transform_func) if feat.geom is None: continue #yield feat feats.append(feat) return feats
def zonal_stats(vector_path, raster_path, nodata_value): # open raster layer rds = gdal.Open(raster_path, GA_ReadOnly) assert (rds) rb = rds.GetRasterBand(1) rgt = rds.GetGeoTransform() # set raster nodata value if nodata_value: nodata_value = float(nodata_value) rb.SetNoDataValue(nodata_value) # open vector layer vds = ogr.Open(vector_path, GA_ReadOnly) assert (vds) vlyr = vds.GetLayer(0) # compare EPSG values of vector and raster and change projection if necessary sourceSR = vlyr.GetSpatialRef() sourceSR.AutoIdentifyEPSG() EPSG_sourceSR = sourceSR.GetAuthorityCode(None) targetSR = osr.SpatialReference(wkt=rds.GetProjection()) targetSR.AutoIdentifyEPSG() EPSG_targetSR = targetSR.GetAuthorityCode(None) if EPSG_sourceSR != EPSG_sourceSR: # reproject vector geometry to same projection as raster print 'unequal projections' sourceSR = vlyr.GetSpatialRef() targetSR = osr.SpatialReference() targetSR.ImportFromWkt(rds.GetProjectionRef()) coordTrans = osr.CreateCoordinateTransformation(sourceSR, targetSR) """do the work""" global_src_extent = None mem_drv = ogr.GetDriverByName('Memory') driver = gdal.GetDriverByName('MEM') # Loop through vectors stats = [] feat = vlyr.GetNextFeature() while feat is not None: # print statement after each hunderds features fid = int(feat.GetFID()) prov = str(feat.GetField('NAME_1')) print("start with feature %s " % (fid)) print("province: %s " % (prov)) #if fid % 500 == 0: # print("finished first %s features" % (fid)) if not global_src_extent: #print 'bbox county' # use local source extent # fastest option when you have fast disks and well indexed raster (ie tiled Geotiff) # advantage: each feature uses the smallest raster chunk # disadvantage: lots of reads on the source raster src_offset = bbox_to_pixel_offsets(rgt, feat.geometry().GetEnvelope()) src_array = rb.ReadAsArray(*src_offset) # calculate new geotransform of the feature subset new_gt = ((rgt[0] + (src_offset[0] * rgt[1])), rgt[1], 0.0, (rgt[3] + (src_offset[1] * rgt[5])), 0.0, rgt[5]) # Create a temporary vector layer in memory mem_ds = mem_drv.CreateDataSource('out') mem_layer = mem_ds.CreateLayer('poly', None, ogr.wkbPolygon) mem_layer.CreateFeature(feat.Clone()) # Rasterize it rvds = driver.Create('', src_offset[2], src_offset[3], 1, gdal.GDT_Byte) rvds.SetGeoTransform(new_gt) gdal.RasterizeLayer(rvds, [1], mem_layer, burn_values=[1]) rv_array = rvds.ReadAsArray() # Mask the source data array with our current feature # we take the logical_not to flip 0<->1 to get the correct mask effect # we also mask out nodata values explictly try: masked = np.ma.MaskedArray(src_array, mask=np.logical_or( src_array == nodata_value, np.logical_not(rv_array))) #print 'feature ID: ',int(feat.GetFID()) # GET STATISTICS FOR EACH COUNTY print 'do something' print masked.shape #return masked values, counts = np.unique(masked, return_counts=True) print values, counts pixels = counts[0] total_pixels_prov = np.ma.count(masked) print pixels comb = [prov, pixels, total_pixels_prov] #county_stats = getStatsCounty(cnty_array = masked, feat=feat) stats.append(comb) rvds = None mem_ds = None feat = vlyr.GetNextFeature() except np.ma.MaskError: # catch MaskError, ignore feature containing no valid corresponding raster data set # in my case the the most southern county of hainan is not totally within the raster extent print 'feature ID: ', fid, ' maskError, ignore county and lets continue' rvds = None mem_ds = None feat = vlyr.GetNextFeature() vds = None rds = None return stats #, src_array, rv_array, masked
def get_transforms(self, sr_virtual, rect, rect_from='virtual'): """Retrieve the `to_work` and `to_virtual` conversion functions. Parameters ---------- sr_virtual: osr.SpatialReference rect: Footprint or extent or None rect_from: one of ('virtual', 'work') """ assert rect_from in ['virtual', 'work'] if self.sr_work is None: return None, None assert sr_virtual is not None to_work = osr.CreateCoordinateTransformation( sr_virtual, self.sr_work).TransformPoints to_virtual = osr.CreateCoordinateTransformation( self.sr_work, sr_virtual).TransformPoints to_work = self._make_transfo(to_work) to_virtual = self._make_transfo(to_virtual) if self.analyse_transformations: if rect_from == 'virtual': an = srs.Analysis(to_work, to_virtual, rect) else: an = srs.Analysis(to_virtual, to_work, rect) if rect is None: pass elif isinstance(rect, Footprint): if not an.ratio_valid: s = ( 'Error while checking if on-the-fly reprojection could be performed ' 'between between Dataset\'s `sr_work` and raster\'s `sr_virtual`. ' 'Cause: {} (The reprojection is too lossy).\n' 'Solutions:\n' '- Pass those tests by reducing `buzz.env.significant`.\n' '- First reproject the raster (using `gdalwarp` for example).\n' '- Bypass those tests by passing `analyse_transformation=False` to the ' 'Dataset\'s constructor.\n' '- Use smaller coordinates.\n' '- Use different spatial references.\n' '- Avoid reprojections at all.\n' '>>> help(Dataset) # for more informations.').format( an.messages) raise ValueError(s) else: minx, maxx, miny, maxy = rect if minx != maxx and miny != maxy and not an.inverse_valid: s = ( 'Error while checking if on-the-fly reprojection could be performed ' 'between between Dataset\'s `sr_work` and vector\'s `sr_virtual`. ' 'Cause: {} (The reprojection is too lossy).\n' 'Solutions:\n' '- Pass those tests by reducing `buzz.env.significant`.\n' '- Bypass those tests by passing `analyse_transformation=False` to the ' 'Dataset\'s constructor.\n' '- Use smaller coordinates.\n' '- Use different spatial references.\n' '- Avoid reprojections at all.\n' '>>> help(Dataset) # for more informations.').format( an.messages) raise ValueError(s) return to_work, to_virtual
def reproject(*args, **kwargs): """Transform coordinates from a source projection to a target projection. Call signatures:: reproject(C, **kwargs) reproject(X, Y, **kwargs) reproject(X, Y, Z, **kwargs) *C* is the np array of source coordinates. *X*, *Y* and *Z* specify arrays of x, y, and z coordinate values Parameters ---------- C : multidimensional :class:`numpy:numpy.ndarray` Array of shape (...,2) or (...,3) with coordinates (x,y) or (x,y,z) respectively X : :class:`numpy:numpy.ndarray` Array of x coordinates Y : :class:`numpy:numpy.ndarray` Array of y coordinates Z : :class:`numpy:numpy.ndarray` Array of z coordinates Keyword Arguments ----------------- projection_source : osr object defaults to EPSG(4326) projection_target : osr object defaults to EPSG(4326) area_of_interest : tuple tuple of floats (WestLongitudeDeg, SouthLatitudeDeg, EastLongitudeDeg, dfNorthLatitudeDeg), only gdal>=3 Returns ------- trans : :class:`numpy:numpy.ndarray` Array of reprojected coordinates x,y (...,2) or x,y,z (...,3) depending on input array. X, Y : :class:`numpy:numpy.ndarray` Arrays of reprojected x,y coordinates, shape depending on input array X, Y, Z: :class:`numpy:numpy.ndarray` Arrays of reprojected x,y,z coordinates, shape depending on input array Examples -------- See :ref:`/notebooks/georeferencing/wradlib_georef_example.ipynb`. """ if len(args) == 1: C = np.asanyarray(args[0]) cshape = C.shape numCols = C.shape[-1] C = C.reshape(-1, numCols) if numCols < 2 or numCols > 3: raise TypeError('Input Array column mismatch ' 'to %s' % ('reproject')) else: if len(args) == 2: X, Y = (np.asanyarray(arg) for arg in args) numCols = 2 elif len(args) == 3: X, Y, Z = (np.asanyarray(arg) for arg in args) zshape = Z.shape numCols = 3 else: raise TypeError('Illegal arguments to %s' % ('reproject')) xshape = X.shape yshape = Y.shape if xshape != yshape: raise TypeError('Incompatible X, Y inputs to %s' % ('reproject')) if 'Z' in locals(): if xshape != zshape: raise TypeError('Incompatible Z input to %s' % ('reproject')) C = np.concatenate( [X.ravel()[:, None], Y.ravel()[:, None], Z.ravel()[:, None]], axis=1) else: C = np.concatenate( [X.ravel()[:, None], Y.ravel()[:, None]], axis=1) projection_source = kwargs.get('projection_source', get_default_projection()) projection_target = kwargs.get('projection_target', get_default_projection()) area_of_interest = kwargs.get( 'area_of_interest', (np.float(C[..., 0].min()), np.float(C[..., 1].min()), np.float(C[..., 0].max()), np.float(C[..., 1].max()))) if gdal.VersionInfo()[0] >= '3': axis_order = osr.OAMS_TRADITIONAL_GIS_ORDER projection_source.SetAxisMappingStrategy(axis_order) projection_target.SetAxisMappingStrategy(axis_order) options = osr.CoordinateTransformationOptions() options.SetAreaOfInterest(*area_of_interest) ct = osr.CreateCoordinateTransformation(projection_source, projection_target, options) else: ct = osr.CoordinateTransformation(projection_source, projection_target) trans = np.array(ct.TransformPoints(C)) if len(args) == 1: # here we could do this one # return(np.array(ct.TransformPoints(C))[...,0:numCols])) # or this one trans = trans[:, 0:numCols].reshape(cshape) return trans else: X = trans[:, 0].reshape(xshape) Y = trans[:, 1].reshape(yshape) if len(args) == 2: return X, Y if len(args) == 3: Z = trans[:, 2].reshape(zshape) return X, Y, Z
def process_vector(self) -> str: try: # file_name_with_full_path = r'D:\test\vector_test\石嘴山市-3xq.json' # file_main_name = CFile.file_main_name(file_name_with_full_path) # file_path = CFile.file_path(file_name_with_full_path) xml_obj = self.metadata.metadata_xml() # <editor-fold desc="1.空间坐标信息"> wkt_info = 'POLYGON((${min_x} ${max_y},${max_x} ${max_y},' \ '${max_x} ${min_y},${min_x} ${min_y},${min_x} ${max_y}))' # 四至坐标 native_max_x = CUtils.to_decimal( xml_obj.get_element_text_by_xpath_one('/TileMetadata/MaxLon')) native_max_y = CUtils.to_decimal( xml_obj.get_element_text_by_xpath_one('/TileMetadata/MaxLat')) native_min_x = CUtils.to_decimal( xml_obj.get_element_text_by_xpath_one('/TileMetadata/MinLon')) native_min_y = CUtils.to_decimal( xml_obj.get_element_text_by_xpath_one('/TileMetadata/MinLat')) if (native_max_x is None) or (native_max_y is None) \ or (native_min_x is None) or (native_min_y is None): native_center_wkt = None native_bbox_wkt = None geom_native_wkt = None else: dict_native = { 'max_x': CUtils.any_2_str(native_max_x), 'max_y': CUtils.any_2_str(native_max_y), 'min_x': CUtils.any_2_str(native_min_x), 'min_y': CUtils.any_2_str(native_min_y) } # 中心坐标 center_x = (native_max_x - native_min_x) / 2 + native_min_x center_y = (native_max_y - native_min_y) / 2 + native_min_y native_center_wkt = 'POINT({0} {1})'.format(center_x, center_y) # 外边框、外包框 native_bbox_wkt = CUtils.replace_placeholder( wkt_info[:], dict_native) geom_native_wkt = native_bbox_wkt file_path = self.file_content.work_root_dir file_main_name = self.object_name native_center_filepath = CFile.join_file( file_path, file_main_name + '_native_center.wkt') CFile.str_2_file(native_center_wkt, native_center_filepath) native_bbox_filepath = CFile.join_file( file_path, file_main_name + '_native_bbox.wkt') CFile.str_2_file(native_bbox_wkt, native_bbox_filepath) native_geom_filepath = CFile.join_file( file_path, file_main_name + '_native_geom.wkt') CFile.str_2_file(geom_native_wkt, native_geom_filepath) projection = xml_obj.get_element_text_by_xpath_one( '/TileMetadata/SpatialReference/PRJ') if (projection is not None) and (not CUtils.equal_ignore_case( projection, '')): source_projection = osr.SpatialReference(wkt=projection) source = source_projection.GetAttrValue('GEOGCS', 0) # 坐标系名称 prosrs = osr.SpatialReference() if prosrs.ImportFromWkt(projection) == gdal.CE_None: proj_wkt = prosrs.ExportToWkt() native_wkt = proj_wkt else: native_wkt = projection native_proj4 = prosrs.ExportToProj4() spatial = None rb = (0, 0) lu = (0, 0) geosrs = prosrs.CloneGeogCS() ct = osr.CreateCoordinateTransformation(prosrs, geosrs) if ct is not None: rb = ct.TransformPoint(native_max_x, native_max_y) lu = ct.TransformPoint(native_min_x, native_min_y) wgs84_min_x = lu[0] wgs84_max_y = lu[1] wgs84_max_x = rb[0] wgs84_min_y = rb[1] dict_wgs84 = { 'max_x': CUtils.any_2_str(wgs84_max_x), 'max_y': CUtils.any_2_str(wgs84_max_y), 'min_x': CUtils.any_2_str(wgs84_min_x), 'min_y': CUtils.any_2_str(wgs84_min_y) } # 中心坐标 center_x = (wgs84_max_x - wgs84_min_x) / 2 + wgs84_min_x center_y = (wgs84_max_y - wgs84_min_y) / 2 + wgs84_min_y wgs84_center_wkt = 'POINT({0} {1})'.format( center_x, center_y) # 外边框、外包框 wgs84_bbox_wkt = CUtils.replace_placeholder( wkt_info[:], dict_wgs84) wgs84_geom_wkt = wgs84_bbox_wkt wgs84_center_filepath = CFile.join_file( file_path, file_main_name + '_wgs84_center.wkt') CFile.str_2_file(wgs84_center_wkt, wgs84_center_filepath) wgs84_bbox_filepath = CFile.join_file( file_path, file_main_name + '_wgs84_bbox.wkt') CFile.str_2_file(wgs84_bbox_wkt, wgs84_bbox_filepath) wgs84_geom_filepath = CFile.join_file( file_path, file_main_name + '_wgs84_geom.wkt') CFile.str_2_file(wgs84_geom_wkt, wgs84_geom_filepath) # </editor-fold> # <editor-fold desc="2.投影信息"> native_source = CResource.Prj_Source_Data # 坐标系 native_coordinate = None # 3度带/6度带 native_degree = None # 投影方式 native_project = None # 带号 native_zone = None # 创建SpatialReference对象,导入wkt信息 spatial_ref = osr.SpatialReference(wkt=native_wkt) if spatial_ref.IsProjected(): native_project = spatial_ref.GetAttrValue('PROJECTION') native_coordinate = spatial_ref.GetAttrValue('GEOGCS') # native_degree = spatial_ref.GetAttrValue('GEOGCS|UNIT', 1) native_degree, native_zone = self.get_prj_degree_zone( spatial_ref) elif spatial_ref.IsGeocentric(): native_project = None native_coordinate = spatial_ref.GetAttrValue('GEOGCS') native_degree = None native_zone = None # </editor-fold> result = CResult.merge_result(self.Success, '处理完毕!') result = CResult.merge_result_info(result, self.Name_Prj_Wkt, native_wkt) result = CResult.merge_result_info(result, self.Name_Prj_Proj4, native_proj4) result = CResult.merge_result_info(result, self.Name_Prj_Project, native_project) result = CResult.merge_result_info(result, self.Name_Prj_Coordinate, native_coordinate) result = CResult.merge_result_info(result, self.Name_Prj_Source, native_source) result = CResult.merge_result_info(result, self.Name_Prj_Zone, native_zone) result = CResult.merge_result_info(result, self.Name_Prj_Degree, native_degree) return result # return CResult.merge_result(self.Success, '处理完毕!') else: return CResult.merge_result(self.Success, '处理完毕!') except Exception as error: CLogger().warning('矢量数据的空间信息处理出现异常, 错误信息为: {0}'.format( error.__str__())) return CResult.merge_result( self.Failure, '矢量数据的空间信息处理出现异常,错误信息为:{0}!'.format(error.__str__()))
def zonal_stats(vector_path, raster_path, raster_type, fieldname, nodata_value=None, global_src_extent=False): rds = gdal.Open(raster_path, GA_ReadOnly) assert(rds) rb = rds.GetRasterBand(1) rgt = rds.GetGeoTransform() if nodata_value: nodata_value = float(nodata_value) rb.SetNoDataValue(nodata_value) vds = ogr.Open(vector_path, GA_ReadOnly) # TODO maybe open update if we want to write stats assert(vds) vlyr = vds.GetLayer(0) # Reproject vector geometry to same projection as raster sourceSR = vlyr.GetSpatialRef() targetSR = osr.SpatialReference() targetSR.ImportFromWkt(rds.GetProjectionRef()) coordTrans = osr.CreateCoordinateTransformation(sourceSR,targetSR) # create an in-memory numpy array of the source raster data # covering the whole extent of the vector layer if global_src_extent: # use global source extent # useful only when disk IO or raster scanning inefficiencies are your limiting factor # advantage: reads raster data in one pass # disadvantage: large vector extents may have big memory requirements src_offset = bbox_to_pixel_offsets(rgt, vlyr.GetExtent()) src_array = rb.ReadAsArray(*src_offset) # calculate new geotransform of the layer subset new_gt = ( (rgt[0] + (src_offset[0] * rgt[1])), rgt[1], 0.0, (rgt[3] + (src_offset[1] * rgt[5])), 0.0, rgt[5] ) mem_drv = ogr.GetDriverByName('Memory') driver = gdal.GetDriverByName('MEM') # Loop through vectors stats = [] feat = vlyr.GetNextFeature() while feat is not None: if not global_src_extent: # use local source extent # fastest option when you have fast disks and well indexed raster (ie tiled Geotiff) # advantage: each feature uses the smallest raster chunk # disadvantage: lots of reads on the source raster geom = feat.GetGeometryRef() # reproject the geometry geom.Transform(coordTrans) feat.SetGeometry(geom) src_offset = bbox_to_pixel_offsets(rgt, feat.geometry().GetEnvelope()) src_array = rb.ReadAsArray(*src_offset) # calculate new geotransform of the feature subset new_gt = ( (rgt[0] + (src_offset[0] * rgt[1])), rgt[1], 0.0, (rgt[3] + (src_offset[1] * rgt[5])), 0.0, rgt[5] ) # Create a temporary vector layer in memory mem_ds = mem_drv.CreateDataSource('out') mem_layer = mem_ds.CreateLayer('poly', None, ogr.wkbPolygon) mem_layer.CreateFeature(feat.Clone()) # Rasterize it rvds = driver.Create('', src_offset[2], src_offset[3], 1, gdal.GDT_Byte) rvds.SetGeoTransform(new_gt) gdal.RasterizeLayer(rvds, [1], mem_layer, burn_values=[1]) rv_array = rvds.ReadAsArray() # Mask the source data array with our current feature # we take the logical_not to flip 0<->1 to get the correct mask effect # we also mask out nodata values explicitly masked = np.ma.MaskedArray( src_array, mask=np.logical_or( src_array == nodata_value, np.logical_not(rv_array) ) ) if raster_type == 'landuse': unique, counts = np.unique(masked, return_counts=True) unique2 = [str(i) for i in unique.astype(int)] count = dict(zip(unique2, counts.astype(int))) feature_stats = { #'sum': float(masked.sum()), fieldname: str(feat.GetField(fieldname))} feature_stats.update(count) elif raster_type == 'population': feature_stats = { #'max': float(masked.max()), 'mean': float(masked.mean()), #'count': int(masked.count()), #'fid': int(feat.GetFID()), fieldname: str(feat.GetField(fieldname))} stats.append(feature_stats) rvds = None mem_ds = None feat = vlyr.GetNextFeature() vds = None rds = None return stats
def CoordinateTransformPoint(longitude, latitude, srs, des): transformer = osr.CreateCoordinateTransformation(srs, des) coord = transformer.TransformPoint(longitude, latitude) return coord[0], coord[1]
def transform_to_WGS84(self, geo_transform: tuple, image_size_x: int, image_size_y: int, projection: str) -> CJson: """ wgs84坐标系转换结果(wgs84节点) :param geo_transform: :param image_size_x: :param image_size_y: :param projection: :return: """ json_wgs84 = CJson() spatial_ref = osr.SpatialReference() spatial_ref.SetWellKnownGeogCS('WGS84') wgs84_wkt = spatial_ref.ExportToWkt() wgs84_proj4 = spatial_ref.ExportToProj4() spatial_ref.MorphToESRI() wgs84_esri = spatial_ref.ExportToWkt() json_wgs84_coordinate = CJson() json_wgs84_coordinate.set_value_of_name('wkt', wgs84_wkt) json_wgs84_coordinate.set_value_of_name('proj4', wgs84_proj4) json_wgs84_coordinate.set_value_of_name('esri', wgs84_esri) json_wgs84.set_value_of_name('coordinate', json_wgs84_coordinate.json_obj) if geo_transform is not None: point_left_top_x = geo_transform[0] point_left_top_y = geo_transform[3] point_right_bottom_x = geo_transform[0] + image_size_x * geo_transform[1] + image_size_y * geo_transform[2] point_right_bottom_y = geo_transform[3] + image_size_x * geo_transform[4] + image_size_y * geo_transform[5] rb = (0, 0) lu = (0, 0) if not CUtils.equal_ignore_case(projection, ''): source_projection = osr.SpatialReference(wkt=projection) source = source_projection.GetAttrValue('GEOGCS', 0) prosrs = osr.SpatialReference() prosrs.ImportFromWkt(projection) geosrs = prosrs.CloneGeogCS() if "GetPROJVersionMajor" in dir(osr) and osr.GetPROJVersionMajor() >= 6: # gdal>=3.0 prosrs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER) geosrs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER) ct = osr.CreateCoordinateTransformation(prosrs, geosrs) if ct is not None: rb = ct.TransformPoint(point_right_bottom_x, point_right_bottom_y) lu = ct.TransformPoint(point_left_top_x, point_left_top_y) json_bounding = CJson() json_bounding.set_value_of_name('left', lu[0]) json_bounding.set_value_of_name('top', lu[1]) json_bounding.set_value_of_name('right', rb[0]) json_bounding.set_value_of_name('bottom', rb[1]) json_wgs84.set_value_of_name('boundingbox', json_bounding.json_obj) json_wgs84.set_value_of_name('msg', 'boundingbox四至范围从{0}坐标系转wgs_84坐标系转换成功!'.format(source)) json_wgs84.set_value_of_name('result', self.Success) else: json_wgs84.set_value_of_name('msg', 'boundingbox四至范围从{0}坐标系转wgs_84坐标系转换失败!失败原因:构建坐标转换关系失败!可能是地方坐标系,无法转换。'.format( source)) json_wgs84.set_value_of_name('result', self.Failure) else: json_wgs84.set_value_of_name('msg', 'boundingbox四至范围从原坐标系转wgs_84坐标系转换失败!失败原因:文件不存在coordinate信息!') json_wgs84.set_value_of_name('result', self.Failure) else: json_wgs84.set_value_of_name('msg', 'boundingbox四至范围从原坐标系转wgs_84坐标系转换失败!失败原因:文件不存在仿射变换信息!') json_wgs84.set_value_of_name('result', self.Failure) return json_wgs84