def verify_geom(self, geom, model_field): """ Verifies the geometry -- will construct and return a GeometryCollection if necessary (for example if the model field is MultiPolygonField while the mapped shapefile only contains Polygons). """ # Downgrade a 3D geom to a 2D one, if necessary. if self.coord_dim != geom.coord_dim: geom.coord_dim = self.coord_dim if self.make_multi(geom.geom_type, model_field): # Constructing a multi-geometry type to contain the single geometry multi_type = self.MULTI_TYPES[geom.geom_type.num] g = OGRGeometry(multi_type) g.add(geom) else: g = geom # Transforming the geometry with our Coordinate Transformation object, # but only if the class variable `transform` is set w/a CoordTransform # object. if self.transform: g.transform(self.transform) # Returning the WKT of the geometry. return g.wkt
def test05_multilinestring(self): "Testing MultiLineString objects." prev = OGRGeometry('POINT(0 0)') for mls in self.geometries.multilinestrings: mlinestr = OGRGeometry(mls.wkt) self.assertEqual(5, mlinestr.geom_type) self.assertEqual('MULTILINESTRING', mlinestr.geom_name) self.assertEqual(mls.n_p, mlinestr.point_count) self.assertEqual(mls.coords, mlinestr.tuple) self.assertEqual(True, mlinestr == OGRGeometry(mls.wkt)) self.assertEqual(True, mlinestr != prev) prev = mlinestr for ls in mlinestr: self.assertEqual(2, ls.geom_type) self.assertEqual('LINESTRING', ls.geom_name) self.assertRaises(OGRIndexError, mlinestr.__getitem__, len(mlinestr))
def test_multipolygons(self): "Testing MultiPolygon objects." OGRGeometry('POINT(0 0)') for mp in self.geometries.multipolygons: mpoly = OGRGeometry(mp.wkt) self.assertEqual(6, mpoly.geom_type) self.assertEqual('MULTIPOLYGON', mpoly.geom_name) if mp.valid: self.assertEqual(mp.n_p, mpoly.point_count) self.assertEqual(mp.num_geom, len(mpoly)) msg = 'Index out of range when accessing geometry in a collection: %s.' with self.assertRaisesMessage(IndexError, msg % len(mpoly)): mpoly.__getitem__(len(mpoly)) for p in mpoly: self.assertEqual('POLYGON', p.geom_name) self.assertEqual(3, p.geom_type) self.assertEqual(mpoly.wkt, OGRGeometry(mp.wkt).wkt)
def test17_pickle(self): "Testing pickle support." import cPickle g1 = OGRGeometry('LINESTRING(1 1 1,2 2 2,3 3 3)', 'WGS84') g2 = cPickle.loads(cPickle.dumps(g1)) self.assertEqual(g1, g2) self.assertEqual(4326, g2.srs.srid) self.assertEqual(g1.srs.wkt, g2.srs.wkt)
def test_from_gml(self): self.assertEqual( OGRGeometry('POINT(0 0)'), OGRGeometry.from_gml( '<gml:Point gml:id="p21" srsName="http://www.opengis.net/def/crs/EPSG/0/4326">' ' <gml:pos srsDimension="2">0 0</gml:pos>' '</gml:Point>'), )
def polymask(self,threshold): get_pts = self.get_pts sims = self.simplifiers list_of_pts = [get_pts(sim,threshold) for sim in sims] if self.return_OGR: return OGRGeometry(self.poly2wkt(list_of_pts),srs=self.geom_srs) else: return [get_pts(sim,threshold) for sim in sims]
def set_simple_linestrings(self, tolerance=500): """ Simplifies the source linestrings so they don't use so many points. Provide a tolerance score the indicates how sharply the the lines should be redrawn. Returns True if successful. """ # Get the list of SRIDs we need to update srid_list = self.get_srid_list() # Loop through each for srid in srid_list: # Fetch the source polygon source_field_name = 'linestring_%s' % str(srid) source = getattr(self, source_field_name) # Fetch the target polygon where the result will be saved target_field_name = 'simple_%s' % source_field_name # If there's nothing to transform, drop out now. if not source: setattr(self, target_field_name, None) continue if srid != 900913: # Transform the source out of lng/lat before the simplification copy = source.transform(900913, clone=True) else: copy = deepcopy(source) # Simplify the source simple = copy.simplify(tolerance, True) # If the result is a polygon ... if simple.geom_type == 'LineString': # Create a new Multipolygon shell ml = OGRGeometry(OGRGeomType('MultiLineString')) # Transform the new poly back to its SRID simple.transform(srid) # Stuff it in the shell ml.add(simple.wkt) # Grab the WKT target = ml.wkt # If it's not a polygon... else: # It should be ready to go, so transform simple.transform(srid) # And grab the WKT target = simple.wkt # Stuff the WKT into the field setattr(self, target_field_name, target) return True
def test_multilinestring(self): "Testing MultiLineString objects." prev = OGRGeometry('POINT(0 0)') for mls in self.geometries.multilinestrings: mlinestr = OGRGeometry(mls.wkt) self.assertEqual(5, mlinestr.geom_type) self.assertEqual('MULTILINESTRING', mlinestr.geom_name) self.assertEqual(mls.n_p, mlinestr.point_count) self.assertEqual(mls.coords, mlinestr.tuple) self.assertEqual(mlinestr, OGRGeometry(mls.wkt)) self.assertNotEqual(mlinestr, prev) prev = mlinestr for ls in mlinestr: self.assertEqual(2, ls.geom_type) self.assertEqual('LINESTRING', ls.geom_name) msg = 'Index out of range when accessing geometry in a collection: %s.' with self.assertRaisesMessage(IndexError, msg % len(mlinestr)): mlinestr.__getitem__(len(mlinestr))
def test_polygons_templates(self): # Accessing Polygon attributes in templates should work. engine = Engine() template = engine.from_string('{{ polygons.0.wkt }}') polygons = [ OGRGeometry(p.wkt) for p in self.geometries.multipolygons[:2] ] content = template.render(Context({'polygons': polygons})) self.assertIn('MULTIPOLYGON (((100', content)
def handle(self, *args, **options): wards = Ward.objects.all() for ward in wards: tifs = TifDistrict.objects.filter(geom__overlaps=ward.geom) for tif in tifs: shape = OGRGeometry(ward.geom.intersection(tif.geom).wkt) overlap_geom = verify_geom(shape, Overlap._meta.get_field('overlap')) overlap = Overlap(ward=ward, tif=tif, overlap=overlap_geom) overlap.save()
def test_cascaded_union(self): geometry = Geometry( OGRGeometry( 'MULTIPOLYGON (((0 0,0 5,5 5,0 0)),((0 0,5 0,5 5,0 0)))') ).cascaded_union() self.assertIsInstance(geometry, Geometry) self.assertEqual(geometry.geometry.geom_name, 'MULTIPOLYGON') self.assertEqual(geometry.wkt, 'MULTIPOLYGON (((0 0,0 5,5 5,5 0,0 0)))')
def add_aois_to_shapefile(self, ds, job_object): aois = job_object.aois.all() if len(aois) == 0: return geo_field = aois[0].polygon # Get the right geometry type number for ogr ogr_type = OGRGeomType(geo_field.geom_type).num # Set up the native spatial reference of the geometry field using the srid native_srs = SpatialReference(geo_field.srid) # create the AOI layer layer = lgdal.OGR_DS_CreateLayer(ds, 'lyr', native_srs._ptr, ogr_type, None) # Create the fields that each feature will have fields = AOI._meta.fields attributes = [] for field in fields: if field.name in 'id, active, name, created_at, updated_at, analyst, priority, status, properties': attributes.append(field) for field in attributes: data_type = 4 if field.name == 'id': data_type = 0 fld = lgdal.OGR_Fld_Create(str(field.name), data_type) added = lgdal.OGR_L_CreateField(layer, fld, 0) check_err(added) # Getting the Layer feature definition. feature_def = lgdal.OGR_L_GetLayerDefn(layer) # Loop through queryset creating features for item in aois: feat = lgdal.OGR_F_Create(feature_def) for idx, field in enumerate(attributes): if field.name == 'properties': value = json.dumps(item.properties) else: value = getattr(item, field.name) string_value = str(value)[:80] lgdal.OGR_F_SetFieldString(feat, idx, string_value) # Transforming & setting the geometry geom = item.polygon ogr_geom = OGRGeometry(geom.wkt, native_srs) check_err(lgdal.OGR_F_SetGeometry(feat, ogr_geom._ptr)) # create the feature in the layer. check_err(lgdal.OGR_L_CreateFeature(layer, feat)) check_err(lgdal.OGR_L_SyncToDisk(layer))
def test01b_gml(self): "Testing GML output." for g in self.geometries.wkt_out: geom = OGRGeometry(g.wkt) exp_gml = g.gml if GDAL_VERSION >= (1, 8): # In GDAL 1.8, the non-conformant GML tag <gml:GeometryCollection> was # replaced with <gml:MultiGeometry>. exp_gml = exp_gml.replace('GeometryCollection', 'MultiGeometry') self.assertEqual(exp_gml, geom.gml)
def test_transform_multipolygon(self): geometry = Geometry( OGRGeometry('MULTIPOLYGON (((0 0,0 5,5 5,0 0)))')).transform( SpatialReference(26917)) self.assertIsInstance(geometry, Geometry) self.assertEqual(geometry.geometry.geom_name, 'MULTIPOLYGON') self.assertEqual( geometry.wkt, 'MULTIPOLYGON (((-85.488743884706892 0.0,-85.488743884708271 0.000045096879048,-85.488699089723454 0.000045096881835,-85.488743884706892 0.0)))' )
def test_transform_multipolygon(self): geometry = Geometry( OGRGeometry('MULTIPOLYGON (((0 0,0 5,5 5,0 0)))')).transform( SpatialReference(26917)) self.assertIsInstance(geometry, Geometry) self.assertEqual(geometry.geometry.geom_name, 'MULTIPOLYGON') assertRegex( self, geometry.wkt, r'MULTIPOLYGON \(\(\(-85.488743884\d{6} 0.0,-85.488743884\d{6} 0.000045096\d{6},-85.488699089\d{6} 0.000045096\d{6},-85.488743884\d{6} 0.0\)\)\)' )
def test_unary_union(self): boundary = Boundary( shape='MULTIPOLYGON (((0 0,0 5,2.5 5.0001,5 5,0 0)))') boundary.unary_union( Geometry(OGRGeometry('MULTIPOLYGON (((0 0,5 0,5 5,0 0)))'))) self.assertEqual(boundary.shape.ogr.wkt, 'MULTIPOLYGON (((5 5,5 0,0 0,0 5,2.5 5.0001,5 5)))') self.assertEqual(boundary.simple_shape.ogr.wkt, 'MULTIPOLYGON (((5 5,5 0,0 0,0 5,5 5)))')
def test04_linestring(self): "Testing LineString objects." prev = OGRGeometry('POINT(0 0)') for ls in self.geometries.linestrings: linestr = OGRGeometry(ls.wkt) self.assertEqual(2, linestr.geom_type) self.assertEqual('LINESTRING', linestr.geom_name) self.assertEqual(ls.n_p, linestr.point_count) self.assertEqual(ls.coords, linestr.tuple) self.assertEqual(True, linestr == OGRGeometry(ls.wkt)) self.assertEqual(True, linestr != prev) self.assertRaises(OGRIndexError, linestr.__getitem__, len(linestr)) prev = linestr # Testing the x, y properties. x = [tmpx for tmpx, tmpy in ls.coords] y = [tmpy for tmpx, tmpy in ls.coords] self.assertEqual(x, linestr.x) self.assertEqual(y, linestr.y)
def processa(self): for arquivo, arqsaida in self.getArquivos(): f = open(arquivo, 'r') dados = [] for line in f: dados.append(line.split()) f.close() ano = int(dados[3][1][:4]) mes = 1 dia = 1 hora = int(dados[3][3][:2]) minuto = int(dados[3][3][-2:]) datahora = datetime(ano, mes, dia, hora, minuto) dias = int(dados[3][1][-3:]) - 1 datahora = datahora + timedelta(days=dias) datareg = datetime.utcnow() for reg in dados[5:]: _posicao = 'SRID=4326;POINT({0} {1})'.format(reg[0], reg[1]) _Satzen = float(reg[2]) _PixSize = float(reg[3]) _T4 = float(reg[4]) _T11 = float(reg[5]) _FireSize = float(reg[6]) _Temp = int(reg[7].replace('.', '')) _FRP = int(reg[8].replace('.', '')) _Ecosystem = int(reg[9].replace('.', '')) _FireFlag = int(reg[10].replace('.', '')) ponto = OGRGeometry('POINT ({0} {1})'.format(reg[0], reg[1])) self.layer.spatial_filter = ponto.extent if len(self.layer) > 0: regFocoItem = FocoWFABBA(dataUTC=datahora, dataregUTC=datareg, arquivo=arquivo, posicao=_posicao, Satzen=_Satzen, PixSize=_PixSize, T4=_T4, T11=_T11, FireSize=_FireSize, Temp=_Temp, FRP=_FRP, Ecosystem=_Ecosystem, FireFlag=_FireFlag) regFocoItem.save() self.layer.spatial_filter = None shutil.move(arquivo, arqsaida)
def handle(self, *args, **kwargs): tree_id = int(args[0]) level = int(args[1]) shape_file = args[2] ds = DataSource(shape_file) layer = ds[0] with Area.objects.delay_mptt_updates(): for feat in layer: parent_id = feat['ID_%s' % (level - 1, )].value area_id = feat['ID_%s' % level].value area_name = unicode(feat['NAME_%s' % level].value, 'iso-8859-1') try: area_varname = unicode(feat['VARNAME_%s' % level].value, 'iso-8859-1') except: area_varname = '' area_type = unicode(feat['TYPE_%s' % level].value, 'iso-8859-1') try: Area.objects.get(tree_id=tree_id, level=level, shape_id=area_id) except Area.DoesNotExist: pass else: continue mpgeom = OGRGeometry('MultiPolygon') mpgeom.add(feat.geom) area_geom = GEOSGeometry(mpgeom.wkt) print "%s (%s): %s (%s)" % (area_id, parent_id, area_name, area_type) area = Area() area.shape_id = area_id area.parent_id = Area.objects.get(tree_id=tree_id, level=(level - 1), shape_id=parent_id).pk area.name = area_name area.varname = area_varname area.type = area_type area.save() areageom = Geom(area=area) areageom.geom = area_geom areageom.save()
def __init__(self, geo_input, srid=None): """ The base constructor for GEOS geometry objects, and may take the following inputs: * string: WKT * string: HEXEWKB (a PostGIS-specific canonical form) * buffer: WKB The `srid` keyword is used to specify the Source Reference Identifier (SRID) number for this Geometry. If not set, the SRID will be None. """ if isinstance(geo_input, basestring): if isinstance(geo_input, UnicodeType): # Encoding to ASCII, WKT or HEXEWKB doesn't need any more. geo_input = geo_input.encode('ascii') wkt_m = wkt_regex.match(geo_input) if wkt_m: # Handling WKT input. if wkt_m.group('srid'): srid = int(wkt_m.group('srid')) g = from_wkt(wkt_m.group('wkt')) elif hex_regex.match(geo_input): # Handling HEXEWKB input. g = from_hex(geo_input, len(geo_input)) elif GEOJSON and json_regex.match(geo_input): # Handling GeoJSON input. wkb_input = str(OGRGeometry(geo_input).wkb) g = from_wkb(wkb_input, len(wkb_input)) else: raise ValueError( 'String or unicode input unrecognized as WKT EWKT, and HEXEWKB.' ) elif isinstance(geo_input, GEOM_PTR): # When the input is a pointer to a geomtry (GEOM_PTR). g = geo_input elif isinstance(geo_input, buffer): # When the input is a buffer (WKB). wkb_input = str(geo_input) g = from_wkb(wkb_input, len(wkb_input)) else: # Invalid geometry type. raise TypeError('Improper geometry input type: %s' % str(type(geo_input))) if bool(g): # Setting the pointer object with a valid pointer. self._ptr = g else: raise GEOSException( 'Could not initialize GEOS Geometry with given input.') # Post-initialization setup. self._post_init(srid)
def processa(self): for arquivo, arqsaida in self.getArquivos(): f = open(arquivo, 'r') dados = [] for line in f: dados.append(line.split(',')) f.close() for reg in dados[1:]: mask = '{0} {1}:00'.format(reg[5], reg[6]) _dataRegUTC = datetime.utcnow() _posicao = 'SRID=4326;POINT({0} {1})'.format(reg[1], reg[0]) _bright = float(reg[2]) _scan = float(reg[3]) _track = float(reg[4]) _dataUTC = parser.parse(mask) _satellite = reg[7] _confidence = float(reg[8]) _version = reg[9] _brightT31 = float(reg[10]) _frp = float(reg[11]) ponto = OGRGeometry(_posicao) self.layer.spatial_filter = ponto.extent query = FocoFIRMS.objects.filter(dataUTC = _dataUTC,\ posicao = _posicao,\ satellite = _satellite) if (len(self.layer) > 0 and len(query) == 0): regFocoItem = FocoFIRMS(dataregUTC = _dataRegUTC,\ posicao = _posicao,\ bright = _bright,\ scan = _scan,\ track = _track,\ dataUTC = _dataUTC,\ satellite = _satellite,\ confidence = _confidence,\ version = _version,\ brightT31 = _brightT31,\ frp = _frp\ ) regFocoItem.save() self.layer.spatial_filter = None # Se já foi processado apaga if path.isfile(arqsaida): remove(arqsaida) shutil.move(arquivo, arqsaida)
def add_features_subset_to_shapefile(self, ds, features, layer_name): if len(features) == 0: return geo_field = features[0].the_geom # Get the right geometry type number for ogr ogr_type = OGRGeomType(geo_field.geom_type).num # Set up the native spatial reference of the geometry field using the srid native_srs = SpatialReference(geo_field.srid) # create the Feature layer layer = lgdal.OGR_DS_CreateLayer(ds, layer_name, native_srs._ptr, ogr_type, None) # Create the fields that each feature will have fields = Feature._meta.fields attributes = [] for field in fields: if field.name in 'id, analyst, template, created_at, updated_at, job, project': attributes.append(field) for field in attributes: data_type = 4 if field.name == 'id': data_type = 0 fld = lgdal.OGR_Fld_Create(str(field.name), data_type) added = lgdal.OGR_L_CreateField(layer, fld, 0) check_err(added) # Getting the Layer feature definition. feature_def = lgdal.OGR_L_GetLayerDefn(layer) # Loop through queryset creating features for item in features: feat = lgdal.OGR_F_Create(feature_def) for idx, field in enumerate(attributes): value = getattr(item, field.name) # if field.name == 'template': # value = value.name string_value = str(value) lgdal.OGR_F_SetFieldString(feat, idx, string_value) # Transforming & setting the geometry geom = item.the_geom ogr_geom = OGRGeometry(geom.wkt, native_srs) check_err(lgdal.OGR_F_SetGeometry(feat, ogr_geom._ptr)) # create the feature in the layer. check_err(lgdal.OGR_L_CreateFeature(layer, feat)) check_err(lgdal.OGR_L_SyncToDisk(layer))
def get_extent_from_text(points, srid_in, srid_out): """Transform an extent from srid_in to srid_out.""" proj_in = SpatialReference(srid_in) proj_out = SpatialReference(srid_out) if srid_out == 900913: if int(float(points[0])) == -180: points[0] = -179 if int(float(points[1])) == -90: points[1] = -89 if int(float(points[2])) == 180: points[2] = 179 if int(float(points[3])) == 90: points[3] = 89 wkt = 'POINT(%f %f)' % (float(points[0]), float(points[1])) wkt2 = 'POINT(%f %f)' % (float(points[2]), float(points[3])) ogr = OGRGeometry(wkt) ogr2 = OGRGeometry(wkt2) if hasattr(ogr, 'srs'): ogr.srs = proj_in ogr2.srs = proj_in else: ogr.set_srs(proj_in) ogr2.set_srs(proj_in) ogr.transform_to(proj_out) ogr2.transform_to(proj_out) wkt = ogr.wkt wkt2 = ogr2.wkt mins = wkt.replace('POINT (', '').replace(')', '').split(' ') maxs = wkt2.replace('POINT (', '').replace(')', '').split(' ') mins.append(maxs[0]) mins.append(maxs[1]) return mins
def test07b_closepolygons(self): "Testing closing Polygon objects." # Both rings in this geometry are not closed. poly = OGRGeometry('POLYGON((0 0, 5 0, 5 5, 0 5), (1 1, 2 1, 2 2, 2 1))') self.assertEqual(8, poly.point_count) print "\nBEGIN - expecting IllegalArgumentException; safe to ignore.\n" try: c = poly.centroid except OGRException: # Should raise an OGR exception, rings are not closed pass else: self.fail('Should have raised an OGRException!') print "\nEND - expecting IllegalArgumentException; safe to ignore.\n" # Closing the rings -- doesn't work on GDAL versions 1.4.1 and below: # http://trac.osgeo.org/gdal/ticket/1673 if GDAL_VERSION <= (1, 4, 1): return poly.close_rings() self.assertEqual(10, poly.point_count) # Two closing points should've been added self.assertEqual(OGRGeometry('POINT(2.5 2.5)'), poly.centroid)
def test_linestring(self): "Testing LineString objects." prev = OGRGeometry('POINT(0 0)') for ls in self.geometries.linestrings: linestr = OGRGeometry(ls.wkt) self.assertEqual(2, linestr.geom_type) self.assertEqual('LINESTRING', linestr.geom_name) self.assertEqual(ls.n_p, linestr.point_count) self.assertEqual(ls.coords, linestr.tuple) self.assertEqual(linestr, OGRGeometry(ls.wkt)) self.assertNotEqual(linestr, prev) msg = 'Index out of range when accessing points of a line string: %s.' with self.assertRaisesMessage(IndexError, msg % len(linestr)): linestr.__getitem__(len(linestr)) prev = linestr # Testing the x, y properties. x = [tmpx for tmpx, tmpy in ls.coords] y = [tmpy for tmpx, tmpy in ls.coords] self.assertEqual(x, linestr.x) self.assertEqual(y, linestr.y)
def test07b_closepolygons(self): "Testing closing Polygon objects." # Both rings in this geometry are not closed. poly = OGRGeometry( 'POLYGON((0 0, 5 0, 5 5, 0 5), (1 1, 2 1, 2 2, 2 1))') self.assertEqual(8, poly.point_count) print( "\nBEGIN - expecting IllegalArgumentException; safe to ignore.\n") try: c = poly.centroid except OGRException: # Should raise an OGR exception, rings are not closed pass else: self.fail('Should have raised an OGRException!') print("\nEND - expecting IllegalArgumentException; safe to ignore.\n") poly.close_rings() self.assertEqual( 10, poly.point_count) # Two closing points should've been added self.assertEqual(OGRGeometry('POINT(2.5 2.5)'), poly.centroid)
def polygon_to_multipolygon(geom): """ Convert polygons to multipolygons so all features are homogenous in the database. """ if geom.__class__.__name__ == 'Polygon': g = OGRGeometry(OGRGeomType('MultiPolygon')) g.add(geom) return g elif geom.__class__.__name__ == 'MultiPolygon': return geom else: raise ValueError('Geom is neither Polygon nor MultiPolygon.')
def rasterize(geom, rast, burn_value=1, all_touched=False, add=False): """ Rasterize a geometry. The result is aligned with the input raster. """ # Create in memory target raster rasterized = rast.warp({'name': 'rasterized.MEM', 'driver': 'MEM'}) # Set all values to zero if add option is off. if not add: rasterized.bands[0].data(numpy.zeros(rast.width * rast.height)) # Set zero as nodata rasterized.bands[0].nodata_value = 0 # Make sure geom is an OGR geometry if not isinstance(geom, OGRGeometry): geom = OGRGeometry(geom.ewkt) geom.transform(rast.srs) # Set rasterization parameters nr_of_bands_to_rasterize = 1 band_indices_to_rasterize = (c_int * 1)(1) nr_of_geometries = 1 burn_value = (c_double * 1)(burn_value) geometry_list = (c_void_p * 1)(geom.ptr) # Setup papsz options papsz_options = [] if all_touched: papsz_options.append('ALL_TOUCHED=TRUE'.encode()) if add: papsz_options.append('MERGE_ALG=ADD'.encode()) papsz_options = (c_char_p * len(papsz_options))(*papsz_options) # Rasterize this geometry rasterize_geometries( rasterized.ptr, nr_of_bands_to_rasterize, band_indices_to_rasterize, nr_of_geometries, geometry_list, None, None, # Transform parameters burn_value, papsz_options, None, None # Progress functions ) return rasterized
def transform_geom(wkt, srid_in, srid_out): proj_in = SpatialReference(int(srid_in)) proj_out = SpatialReference(int(srid_out)) ogr = OGRGeometry(wkt) if hasattr(ogr, 'srs'): ogr.srs = proj_in else: ogr.set_srs(proj_in) ogr.transform_to(proj_out) return ogr.wkt
def geometry_to_multipolygon(geometry): """ Converts a Polygon to a MultiPolygon. """ value = geometry.__class__.__name__ if value == 'MultiPolygon': return geometry elif value == 'Polygon': multipolygon = OGRGeometry(OGRGeomType('MultiPolygon')) multipolygon.add(geometry) return multipolygon else: raise ValueError(_('The geometry is a %(value)s but must be a Polygon or a MultiPolygon.') % {'value': value})