def test_invalid_multipolygon(self): with self.assertRaises(ValueError) as cm: geojson.MultiPolygon([1], validate=True) self.assertIn("Each polygon must be a list of linear rings", str(cm.exception)) poly1 = [(2.38, 57.322), (23.194, -20.28), (-120.43, 19.15), (25.44, -17.91)] poly2 = [(2.38, 57.322), (23.194, -20.28), (-120.43, 19.15), (2.38, 57.322)] multipoly = geojson.MultiPolygon([poly1, poly2]) self.assertEqual(multipoly.is_valid, False)
def test_cant_add_task_if_not_supplied_feature_type(self): # Arrange invalid_feature = geojson.MultiPolygon([[(2.38, 57.322), (23.194, -20.28), (-120.43, 19.15), (2.38, 10.33)]]) # Arrange with self.assertRaises(InvalidGeoJson): Task.from_geojson_feature(1, invalid_feature)
def to_arcgis(): try: request_data = request.get_json() response = geojson.Feature(geometry=geojson.MultiPolygon(request_data)) return json.dumps(response) except Exception as e: abort(400, e)
def _as_multipolygons(elements): """Parse an iterable of elements to retrieve a FeatureCollection of multipolygons. Parameters ---------- elements : list of dict JSON response elements. Returns ------- feature_collection : dict Output GeoJSON FeatureCollection. """ features = [] elements = [ e for e in elements if e.get('type') == 'relation' and e['tags']['type'] == 'multipolygon' ] for elem in elements: coords = [] for member in elem['members']: member_coords = [] for node in member['geometry']: member_coords.append([node['lon'], node['lat']]) coords.append(member_coords) geom = geojson.MultiPolygon(coordinates=[coords]) features.append(geojson.Feature(elem['id'], geom, elem['tags'])) return geojson.FeatureCollection(features)
def tryToConvertToPolygon(tags, lines, polygonize, isMultiPolygon = False): """ Creates a Polygon or LineString based on the given lines tags: tags of the base object lines: coordinates (basically nested lists) polygonize: boolean, if True -> tries to convert every Line to Polygon isMultiPolygon: boolean, if each line is an extra polygon else lines = [boundary, holes..] """ # as sometimes tags like "area":"no" exists, which are obviously no polygons tags = {tag: v for tag, v in tags.items() if not v == "no"} # osm-multipolygon: means just as complex area ... but geojson polygons can also handle holes # sometimes they are real multipolygons? (see Dresdener Heide) --> isMultiPolygon if POLYGON_TAGS.intersection(tags) or tags.get("type") == "multipolygon" or polygonize: if isMultiPolygon: # creating a polygon array for each line (only exterior lines, no holes currently) lines = [[line] for line in lines] polygon = geojson.MultiPolygon(lines) else: polygon = geojson.Polygon(lines) if not polygon.errors(): return polygon elif not polygonize: # with polygonize == true it is expected that this wont work every time logging.debug("Could not be converted to a polygon with tags {}".format(tags)) if len(lines) == 1: return geojson.LineString(lines[0], validate=True) else: if LINESTRING_TAGS.intersection(tags): logging.debug("To many lines for a simple line for object with tags: {}".format(tags)) return geojson.MultiLineString(lines, validate=True)
def test_valid_multipolygon(self): poly1 = [(2.38, 57.322), (23.194, -20.28), (-120.43, 19.15), (2.38, 57.322)] poly2 = [(-5.34, 3.71), (28.74, 31.44), (28.55, 19.10), (-5.34, 3.71)] poly3 = [(3.14, 23.17), (51.34, 27.14), (22, -18.11), (3.14, 23.17)] multipoly = geojson.MultiPolygon([poly1, poly2, poly3]) self.assertEqual(is_valid(multipoly)['valid'], YES)
def test_invalid_multipolygon(self): poly1 = [(2.38, 57.322), (23.194, -20.28), (-120.43, 19.15), (25.44, -17.91)] poly2 = [(2.38, 57.322), (23.194, -20.28), (-120.43, 19.15), (2.38, 57.322)] multipoly = geojson.MultiPolygon([poly1, poly2]) self.assertEqual(is_valid(multipoly)['valid'], NO)
def es_geoshape_to_geojson(index, doc_type, geoshape_field, outfile, query={}): #input: ES index, doctype, and field that is mapped as a geoshape #output: Geojson feature collection es_full_url = 'http://' + ES_username + ':' + ES_password + '@' + ES_url + ':9200' es = Elasticsearch(es_full_url) features = [] docs = helpers.scan(es, index=index, doc_type=doc_type, query=json.dumps(query)) for doc in docs: #define the geojson shape type based on ES geoshape type if doc['_source'][geoshape_field]['type'].lower() == 'point': shape = geojson.Point( doc['_source'][geoshape_field]['coordinates']) if doc['_source'][geoshape_field]['type'].lower() == 'linestring': shape = geojson.LineString( doc['_source'][geoshape_field]['coordinates']) if doc['_source'][geoshape_field]['type'].lower() == 'polygon': shape = geojson.Polygon( doc['_source'][geoshape_field]['coordinates']) if doc['_source'][geoshape_field]['type'].lower() == 'multipolygon': shape = geojson.MultiPolygon( doc['_source'][geoshape_field]['coordinates']) #print geojson.is_valid(shape) props = deepcopy(doc['_source']) props.pop(geoshape_field, None) features.append(geojson.Feature(geometry=shape, properties=props)) with open(outfile, 'w') as out: geojson.dump(geojson.FeatureCollection(features), out)
def geometry(self): try: if self.type() == 'node': if not self.lon() or not self.lat(): self._raiseException('Cannot build geometry: geometry information not included.') return geojson.Point((self.lon(), self.lat())) elif self.type() == 'way': if not self.__getElement('geometry'): self._raiseException('Cannot build geometry: geometry information not included.') cs = self.__geometry_csToList(self.__getElement('geometry')) if self.__geometry_equal(cs[0], cs[-1]): return geojson.Polygon([cs]) else: return geojson.LineString(cs) elif self.type() == 'relation': members = copy.deepcopy(self.__members()) membersOuter = self.__geometry_extract(members, 'outer') if len(membersOuter) == 0: self._raiseException('Cannot build geometry: no outer rings found.') membersInner = self.__geometry_extract(members, 'inner') ringsOuter = self.__geometry_buildRings(membersOuter) ringsInner = self.__geometry_buildRings(membersInner) ringsOuter = self.__geometry_orientRings(ringsOuter, positive=True) ringsInner = self.__geometry_orientRings(ringsInner, positive=False) polygons = self.__geometry_buildPolygons(ringsOuter, ringsInner) if len(polygons) > 1: return geojson.MultiPolygon(polygons) else: return geojson.Polygon(polygons[0]) else: self._raiseException('Cannot build geometry: type of element unknown.') except Exception as e: _extendAndRaiseException(e, ' ({}/{})'.format(self.type(), self.id()))
def json2geojson(ls): logger = logging.getLogger('root') feats = [] for dict in ls: #IPython.embed() if type(dict['properties']['ingestion_time']) == datetime.datetime: dttm = dict['properties']['ingestion_time'] dttmstr = dttm.strftime("%Y-%m-%d %H:%M:%S") dict['properties']['ingestion_time'] = dttmstr if dict['geometry'] is None or len( dict['geometry']['coordinates']) == 0: feats.append( geojson.Feature(geometry=None, properties=dict['properties'])) else: ## mixing poly and multipoly is not accepted by postgis. we will force Polygon into MultiPolygon mp = geojson.MultiPolygon() ## now we have to correct syntax of MultiPolygon which was forced from Polygon so it generates valid geojson in the end if dict["geometry"]["type"] == 'Polygon': dict["geometry"]["coordinates"] = [ dict["geometry"]["coordinates"] ] #if len(poly['geometry']['coordinates'])==1: # mp=geojson.Polygon() mp['coordinates'] = dict['geometry']['coordinates'] feats.append( geojson.Feature(geometry=mp, properties=dict['properties'])) return geojson.FeatureCollection(feats)
def test_multipolygon(self): g = geojson.MultiPolygon([ ([(3.78, 9.28), (-130.91, 1.52), (35.12, 72.234), (3.78, 9.28)],), ([(23.18, -34.29), (-1.31, -4.61), (3.41, 77.91), (23.18, -34.29)],)]) itr = coords(g) pairs = list(itr) self.assertEqual(pairs[0], (3.78, 9.28)) self.assertEqual(pairs[-1], (23.18, -34.29))
def relation2geometry(relation): """ Convert relation data into a GeoJSON object. """ if check(relation, 'type', 'multipolygon'): outer = relation['outer'] inner = relation['inner'] if not inner: return geojson.MultiPolygon([(o['coordinates'], ) for o in outer]) if len(outer) == 1: polygons = [outer[0]['coordinates']] for way in inner: polygons.append(way['coordinates']) return geojson.MultiPolygon([polygons]) raise ValueError('Unknown inner/outer configuration %r' % relation) else: raise ValueError('Unknown relation type %r' % relation)
def test_map_multipolygon(self): g = geojson.MultiPolygon([ ([(3.78, 9.28), (-130.91, 1.52), (35.12, 72.234), (3.78, 9.28)],), ([(23.18, -34.29), (-1.31, -4.61), (3.41, 77.91), (23.18, -34.29)],)]) result = map_coords(lambda x: x, g) self.assertEqual(result['type'], 'MultiPolygon') self.assertEqual(result['coordinates'][0][0][0], (3.78, 9.28)) self.assertEqual(result['coordinates'][-1][-1][-1], (23.18, -34.29))
def test_invalid_multipolygon(self): multipolygon = geojson.MultiPolygon() self.assertFalse(multipolygon.is_valid()) multipolygon.coordinates = [] self.assertFalse(multipolygon.is_valid()) multipolygon.coordinates = [[[[D('102.0'), D('2.0')], [D('103.0'), D('2.0')], [D('102.0'), D('3.0')]]]] self.assertFalse(multipolygon.is_valid())
def test_cant_create_aoi_with_invalid_multipolygon(self): bad_multipolygon = geojson.MultiPolygon([[(2.38, 57.322), (23.194, -20.28), (-120.43, 19.15), (2.38)]]) bad_feature = geojson.Feature(geometry=bad_multipolygon) bad_feature_collection = geojson.FeatureCollection([bad_feature]) # Act / Assert with self.assertRaises(InvalidGeoJson): # Only geometries of type MultiPolygon are valid GridService.merge_to_multi_polygon(geojson.dumps(bad_feature_collection), dissolve=True)
def pd_to_geojson(df, filename, geo_col, prop_cols): features = [] insert_features = lambda x: features.append( geojson.Feature(geometry=geojson.MultiPolygon(x[geo_col]), properties=x[prop_cols].to_dict())) df.apply(insert_features, axis=1) with open('{}.geojson'.format(filename), 'w', encoding='utf8') as fp: geojson.dump(geojson.FeatureCollection(features), fp, sort_keys=True, ensure_ascii=False)
def create_feature(geometry, geo_type, val, feature_id=None, color=(255, 0, 0), weight=10, opacity=1.0, props={}): """ :param geometry: Geometry structure that creates geojson string. Options are: Point: (lng, lat) as tuple MultiPoint: [Point, Point] as array of points Line(string): [Point, Point, Point] as array of points Multiline(string): [Line, Line] as array of lines Polygon without holes: [Point1, Point, Point, Point1] as array of points, first and last point in array are the same point (example makes a triangle). Polygon with hole: [[Point1, Point, Point, Point1], [Point2, Point, Point, Point2]] as array of polygons, second polygon is the hole. Multipolygon: [Polygon, Polygon] as array of polygons (must confirm...?) :param geo_type: string indicating the geometry type, must match id strings from class geojson_geometry :param val: value to put into properties.value for mapping and style color matching :param feature_id: id for the geojson string :param color: a 3 value tuple containing an rgb value :param weight: for lines/polygons, line width; for points, point size :param opacity: opacity of layer in leaflet, 1.0 = 100%, 0 = 0% :returns: dictionary with geojson feature string and a leaflet style created from input parameters """ try: if geo_type == GeojsonGeometry.point: geo = geojson.Point(geometry) elif geo_type == GeojsonGeometry.multipoint: geo = geojson.MultiPoint(geometry) elif geo_type == GeojsonGeometry.line: geo = geojson.LineString(geometry) elif geo_type == GeojsonGeometry.multiline: geo = geojson.MultiLineString(geometry) elif geo_type == GeojsonGeometry.polygon: geo = geojson.Polygon(geometry) elif geo_type == GeojsonGeometry.multipolygon: geo = geojson.MultiPolygon(geometry) else: print("Unsupported geometry type: " + geo_type) return except Exception as e: print(e, "\n probably wrong input data structure for " + geo_type) return style = None # leaflet_style_creator() props['value'] = val geo = geojson.Feature(id=feature_id, geometry=geo, properties=props) ret = {'geojson': geo, 'style': style} return ret
def find_intersecting_polygons(all_polygons_file, bounding_polygon, output_file, id_prefix): # Load all polygons into a feature set with open(all_polygons_file, mode="r") as in_file: all_polygons = geojson.load(in_file) total_area = 0 num_polys = 0 intersecting_polygons = [] # Find the intersecting polygons for feature in all_polygons["features"]: polygon = geometry.shape(feature["geometry"]) if not polygon.is_valid: if DEBUG: print("Attempting to fix invalid polygon") polygon = polygon.buffer(0) # If it's still not valid, just skip it if not polygon.is_valid: if DEBUG: print("Fix was unsuccessful. Skipping polygon") continue intersection = bounding_polygon.intersection(polygon) # If polygon overlaps with bounds, we want to include it if intersection.area > 0: num_polys += 1 # Construct new geojson polygon for intersection area if intersection.geom_type == 'MultiPolygon': new_polygon = geojson.MultiPolygon( geometry.mapping(intersection)["coordinates"]) else: new_polygon = geojson.Polygon( geometry.mapping(intersection)["coordinates"]) #Create feature and add to list new_feature = geojson.Feature(geometry=new_polygon) new_feature["properties"]["id"] = id_prefix + str(uuid.uuid4()) # Add to list of features to return intersecting_polygons.append(new_feature) # Add all features to a feature set new_feature_collection = geojson.FeatureCollection(intersecting_polygons) # Output to a file with open(output_file, mode="w") as out_file: geojson.dump(new_feature_collection, out_file, indent=4)
def merge_pols(sceneMasks): mergedPolygon = shapely.geometry.Polygon() for fname in sceneMasks: with open(pths.s2aIn + '/' + fname) as geojson1: poly_geojson = json.load(geojson1) for feat in poly_geojson['features']: poly = shapely.geometry.asShape(feat['geometry']) mergedPolygon = mergedPolygon.union(poly) # using geojson module to convert from WKT back into GeoJSON format geojson_out = geojson.MultiPolygon(geometry=mergedPolygon) return (geojson_out)
def to_geojson(): try: request_data = request.get_json() input = request_data.operationalLayers[3].featureCollection.layers[ 0].featureSet.features coord_set = [x["geometry"] for x in input] polygon_list = [Polygon(cc) for cc in coord_set] multipolygon = MultiPolygon(polygon_list) response = geojson.Feature(geometry=geojson.MultiPolygon(coord_set)) response["bbox"] = multipolygon.bounds return json.dumps(response) except Exception as e: abort(400, e)
def aggr2geojson(polys): feats = [] for poly in polys: oid = json.loads(json.dumps(poly['_id'], default=json_util.default)) dttm = poly['properties']['ingestion_time'] dttmstr = dttm.strftime("%Y-%m-%d %H:%M:%S") poly['properties']['ingestion_time'] = dttmstr del poly['_id'] poly['properties']['oid'] = oid['$oid'] ### rename to insert into postgis if 'platformname' in poly['properties']: poly['properties']['source_id'] = poly['properties'].pop( 'platformname') if poly['properties']['source_id'] == 'Sentinel-1': poly['properties']['source_id'] = 1 elif poly['properties']['source_id'] == 'Sentinel-2': poly['properties']['source_id'] = 2 elif 'source_id' in poly['properties']: print( 'dealing with correct geojson attributes, no need to change anything\n' ) else: print( 'probably one of the first scenes to be processed, before adding sentinel-2, so it must be sentinel-1! passing 1 as source_id.\n' ) poly['properties']['source_id'] = 1 if poly['geometry'] is None: feats.append( geojson.Feature(geometry=None, properties=poly['properties'])) else: ## mixing poly and multiply is not accepted by postgis. we will force Polygon into MultiPolygon if len(poly['geometry']['coordinates']) > 0: mp = geojson.MultiPolygon() ## now we have to correct syntax of MultiPolygon which was forced from Polygon so it generates valid geojson in the end if poly["geometry"]["type"] == 'Polygon': poly["geometry"]["coordinates"] = [ poly["geometry"]["coordinates"] ] #if len(poly['geometry']['coordinates'])==1: # mp=geojson.Polygon() mp['coordinates'] = poly['geometry']['coordinates'] feats.append( geojson.Feature(geometry=mp, properties=poly['properties'])) feat_col = geojson.FeatureCollection(feats) return (feat_col)
def test_geometry_collection(self): geometries = geojson.GeometryCollection() geometries.geometries = [ geojson.Point(coordinates=[ random.randint(-180, 180), random.randint(-90, 90) ]) for _ in xrange(10) ] self.assertTrue(geometries.is_valid()) multipolygon = geojson.MultiPolygon() multipolygon.coordinates = [[[[D('102.0'), D('2.0')], [D('103.0'), D('2.0')], [D('103.0'), D('3.0')], [D('102.0'), D('3.0')], [D('102.0'), D('2.0')]]], [[[D('100.0'), D('0.0')], [D('101.0'), D('0.0')], [D('101.0'), D('1.0')], [D('100.0'), D('1.0')], [D('100.0'), D('0.0')]], [[D('100.2'), D('0.2')], [D('100.8'), D('0.2')], [D('100.8'), D('0.8')], [D('100.2'), D('0.8')], [D('100.2'), D('0.2')]]]] geometries.geometries[4] = multipolygon multipolygon = geojson.MultiPolygon() multipolygon.coordinates = [[[[D('102.0'), D('2.0')], [D('103.0'), D('2.0')], [D('103.0'), D('3.0')], [D('102.0'), D('3.0')], [D('102.0'), D('2.0')]]]] geometries.geometries.append(multipolygon) self.assertTrue(geometries.is_valid()) self.assertEquals(len(geometries), 11) for idx, geometry in enumerate(geometries): self.assertDictEquals(geometry.to_dict(), geometries[idx].to_dict())
def main(): parser = argparse.ArgumentParser() parser.add_argument("--image", type=str, default="GoogleSatellite-x215782-y99255-z18.jpg", help="the base map image") parser.add_argument( "--bounds", type=str, default= "[[39.98553841480973, 116.33148193359375], [39.98659063142852, 116.33285522460938]]", help="the latitude-longitude bounds of the base map image") parser.add_argument("--input", type=str, default="input.txt", help="the input file") parser.add_argument("--output", type=str, default="output.json", help="the output file") parser.add_argument( "--input-is-percent", action="store_true", help="whether the input coordinate is percent (or int)") args = parser.parse_args() image_ = image.imread(args.image) image_height, image_width = image_.shape[0], image_.shape[1] bounds = json.loads(args.bounds) lat_min, lon_min, lat_max, lon_max, lat_span, lon_span = bounds[0][ 0], bounds[0][1], bounds[1][0], bounds[1][1], ( bounds[1][0] - bounds[0][0]), (bounds[1][1] - bounds[0][1]) input_lines = open(args.input).readlines( ) # image coordinate system origin: top left corner, coordinate order: x,y feature_collection = geojson.FeatureCollection([ geojson.Feature(id=str(i), geometry=geojson.MultiPolygon(json.loads(line))) for i, line in enumerate(input_lines) ]) if args.input_is_percent: feature_collection = geojson.utils.map_tuples( lambda c: (lon_min + lon_span * c[0], lat_min + lat_span * (1.0 - c[1])), feature_collection) else: feature_collection = geojson.utils.map_tuples( lambda c: (lon_min + lon_span * (c[0] / image_width), lat_min + lat_span * (1.0 - c[1] / image_height)), feature_collection) open(args.output, "wt").write(geojson.dumps(feature_collection, indent=2))
def validate_multi_polygon(multipolygon_coordinates: List[List[List[float]]]): """according: https://en.wikipedia.org/wiki/GeoJSON""" multipolygon = geojson.MultiPolygon(multipolygon_coordinates) if not multipolygon.is_valid: raise ValueError('MultiPolygon is not valid') for level_01 in multipolygon.coordinates: for level_02 in level_01: for level_03 in level_02: latitude_valid = validate_latitude(level_03[0]) longitude_valid = validate_longitude(level_03[1]) if not latitude_valid or not longitude_valid: raise ValueError('coordinates is not valid')
def _add_polygon(self): """ Computes polygon, removes water bodies, and stores. """ # Get points without outliers. fpoints = list( zip( self.data.loc[~self.data.outlier_status, "decimalLongitude"], self.data.loc[~self.data.outlier_status, "decimalLatitude"], )) # Get convex hull around points. rawpoly = shapely.geometry.Polygon(fpoints) conv_hull = rawpoly.convex_hull # Get intersection with global LAND to remove water bodies. clean_hull = conv_hull.intersection(LAND) # Store [Multi]Polygon as the geographic range. self.georange = clean_hull # If the resulting shape is a single Polygon, write it. if clean_hull.geom_type == "Polygon": outline = clean_hull.boundary.coords coords = list(zip(outline.xy[0], outline.xy[1])) geometry = geojson.Polygon(coordinates=[coords], validate=True) feature = geojson.Feature(geometry=geometry, properties={"type": "geographic_range"}) # For a MultiPolygon, combine the pieces one at a time. elif clean_hull.geom_type == "MultiPolygon": geometry = geojson.MultiPolygon() for poly in clean_hull: coords = list( zip( poly.boundary.coords.xy[0], poly.boundary.coords.xy[1], )) subgeometry = geojson.Polygon([coords], validate=True) geometry.coordinates.append(subgeometry.coordinates) feature = geojson.Feature(geometry=geometry, properties={"type": "geographic_range"}) else: raise ValueError(f"odd shaped hull error: {clean_hull.geom_type}") # Append to feature collection. self.feature_collection['features'].append(feature)
def l2geojson(l, type='Polygon'): features_l = [] for ll in l: if type == 'Polygon': p = geojson.Polygon(ll) elif type == 'Point': p = geojson.Point(ll) else: p = geojson.MultiPolygon(ll) f = geojson.Feature(geometry=p) features_l.append(f) geodata = geojson.dumps(geojson.FeatureCollection(features=features_l)) return geodata
def test_nested_constructors(self): a = [5, 6] b = [9, 10] c = [-5, 12] mp = geojson.MultiPoint([geojson.Point(a), b]) self.assertEqual(mp.coordinates, [a, b]) mls = geojson.MultiLineString([geojson.LineString([a, b]), [a, c]]) self.assertEqual(mls.coordinates, [[a, b], [a, c]]) outer = [a, b, c, a] poly = geojson.Polygon(geojson.MultiPoint(outer)) other = [[1, 1], [1, 2], [2, 1], [1, 1]] poly2 = geojson.Polygon([outer, other]) self.assertEqual(geojson.MultiPolygon([poly, poly2]).coordinates, [[outer], [outer, other]])
def build_features(shp, dbf): ''' Builds a GeoJSON object from a PySAL shapefile and DBF object shp - shapefile opened using pysal.open(file) dbf - dbase table opened using pysal.open(file) Only polygonal lattices are supported. ''' shp_bak = ps.open(shp.dataPath) dbf_bak = ps.open(dbf.dataPath) chains = shp_bak.read() dbftable = dbf_bak.read() shp_bak.close() dbf_bak.close() #shptype = str(shp_bak.type).strip("<class 'pysal.cg.shapes.").strip("'>") if 'Polygon' in str(shp_bak.type): ftype = 'Polygon' elif 'Point' in str(type(shp_bak.type)): raise NotImplementedError('Point data is not implemented yet') if ftype == "Polygon": feats = [] for idx in range(len(chains)): chain = chains[idx] if len(chain.parts) > 1: #shptype = 'MultiPolygon' geom = gj.MultiPolygon([[[list(coord) for coord in part]] for part in chain.parts]) else: #shptype = 'Polygon' geom = gj.Polygon(coordinates=[[list(coord) for coord in part] for part in chain.parts]) prop = { head: val for head, val in zip(dbf_bak.header, dbftable[idx]) } bbox = chain.bbox feats.append( gj.Feature(None, geometry=geom, properties=prop, bbox=bbox)) return gj.FeatureCollection(feats, bbox=shp_bak.bbox)
def test_entity_add_country_shape(air_quality_observed): air_quality_observed.pop('location') air_quality_observed['address']['value'] = { "addressCountry": "MX", } r = geocoding.add_location(air_quality_observed) assert r is air_quality_observed assert 'location' in r assert r['location']['type'] == 'geo:json' geo = r['location']['value'] assert geo['type'] == 'MultiPolygon' multi_polygon = geojson.MultiPolygon(geo['coordinates']) assert multi_polygon.is_valid
def test_geometrycollection(self): p1 = geojson.Point((-115.11, 37.11)) p2 = geojson.Point((-115.22, 37.22)) ln = geojson.LineString( [(-115.3, 37.3), (-115.4, 37.4), (-115.5, 37.5)]) g = geojson.MultiPolygon([ ([(3.78, 9.28), (-130.91, 1.52), (35.12, 72.234), (3.78, 9.28)],), ([(23.18, -34.29), (-1.31, -4.61), (3.41, 77.91), (23.18, -34.29)],)]) itr = coords(geojson.GeometryCollection([p1, p2, ln, g])) pairs = set(itr) self.assertEqual(pairs, set([ (-115.11, 37.11), (-115.22, 37.22), (-115.3, 37.3), (-115.4, 37.4), (-115.5, 37.5), (3.78, 9.28), (-130.91, 1.52), (35.12, 72.234), (3.78, 9.28), (23.18, -34.29), (-1.31, -4.61), (3.41, 77.91), (23.18, -34.29) ]))