def test_strip_srid(self): """ strip SRID """ geom1 = Geometry("010100000000000000000000000000000000000000") geom2 = Geometry("0101000020E610000000000000000000000000000000000000") self.assertIsNone(geom1.srid) self.assertEquals(geom2.srid, 4326) geom2.srid = None self.assertIsNone(geom2.srid) self.assertEquals(geom1.wkb, geom2.wkb) geom2.srid = None self.assertIsNone(geom2.srid) self.assertEquals(geom1.wkb, geom2.wkb)
def test_read_wkb_point(self): """ read WKB Point """ wkb = "010100000000000000000000000000000000000000" geom = Geometry(wkb) self.assertEquals(geom.type, "Point") self.assertIsNone(geom.srid) self.assertEquals(geom.dimz, False) self.assertEquals(geom.dimm, False) postgis_type = "geometry(Point)" self.assertEquals(geom.postgis_type, postgis_type) self.assertEquals(geom.__repr__(), "<Point: 'geometry(Point)'>") geom.srid = geom.srid # clear cached WKB self.assertEquals(geom.__str__().lower(), wkb.lower())
def _get_predicates(self, quals): query = None bounds = None for qual in quals: if qual.field_name == 'query' and qual.operator == '=': query = qual.value if qual.field_name == 'geom' and qual.operator in ['&&', '@']: # note A ~ B is transformed into B @ A shape = Geometry(qual.value).shapely bounds = shape.bounds elif qual.value == 'geom' and qual.operator == '&&': shape = Geometry(qual.field_name).shapely bounds = shape.bounds return query, bounds
def test_read_ewkb_point_srid(self): """ read EWKB Point,4326 """ wkb = "0101000020E610000000000000000000000000000000000000" geom = Geometry(wkb) self.assertEquals(geom.type, "Point") self.assertEquals(geom.srid, 4326) self.assertEquals(geom.dimz, False) self.assertEquals(geom.dimm, False) postgis_type = "geometry(Point,4326)" self.assertEquals(geom.postgis_type, postgis_type) self.assertEquals(geom.__repr__(), "<Point: 'geometry(Point,4326)'>") geom.srid = geom.srid # clear cached WKB self.assertEquals(geom.__str__().lower(), wkb.lower())
def test_shape(self): """ access using __geo_interface__ and shape """ point = Point.from_geojson(geojson_pt) geom = Geometry.shape(point) self.assertEquals(point.__geo_interface__, geom.__geo_interface__)
def containsPoint(request): #위험 지역 우회 global gu_coordinate pointlist = [] line = "" line_point = [] count = 0 gu_bound = Female2.objects.filter(female2_crime_type="구경계", gu="양천구").get() gis = Geometry(gu_bound.female2_crime_loc.hex()[8:]) gi = shape(gis) if request.method == "POST": pistes = request.POST.get('draw') pist = pistes.split(",") for p in pist: if (pist.index(p) % 2 == 0): x = p y = pist[pist.index(p) + 1] point = Point(float(y), float(x)) pointlist.append(point) linear = LineString(pointlist).buffer(0.003) for multi in global_contain_coordinate: if linear.contains(multi): linear = linear.difference(multi.buffer(0.0)) if linear.intersection(gi).geom_type == 'Polygon': line += "_" + str(linear.centroid.x) + "," + str(linear.centroid.y) else: for l in list(linear.intersection(gi)): line += "_" + str(l.centroid.x) + "," + str(l.centroid.y) return HttpResponse(json.dumps({'p': line[1:]}), content_type="application/json")
def test_shapely_load(self): """ convert from Shapely """ sgeom = geometry.Point(99, -99) point = Geometry.from_shapely(sgeom) self.assertEquals(sgeom.wkb_hex.upper(), point.wkb.upper())
def donglevel(request): map = folium.Map(location=[37.5518838, 126.9858763], zoom_start=12) dongm = DongLevel.objects.values('dong_level_tot', 'dong_nm') dong_df = pd.DataFrame(dongm) dongloc = DongLevel.objects.all() loc_list = [] for i in dongloc: gis = Geometry(i.dong_loc.hex()[8:]) crime_location = { "type": "Feature", "properties": { "dong_nm": i.dong_nm }, "geometry": gis.geojson } loc_list.append(crime_location) pistes = {"type": "FeatureCollection", "features": loc_list} folium.Choropleth(geo_data=pistes, data=dong_df, columns=('dong_nm', 'dong_level_tot'), fill_color='BuPu', key_on='feature.properties.dong_nm').add_to(map) maps = map._repr_html_() return render(request, 'home.html', {'map': maps})
def test_read_wkb_polygon(self): """ read WKB Polygon """ wkb = wkb_pg geom = Geometry(wkb) self.assertEquals(geom.type, "Polygon") self.assertEquals(geom.srid, None) self.assertEquals(geom.dimz, False) self.assertEquals(geom.dimm, False) postgis_type = "geometry(Polygon)" self.assertEquals(geom.exterior.type, "LineString") self.assertEquals(geom.postgis_type, postgis_type) self.assertEquals(geom.__repr__(), "<Polygon: 'geometry(Polygon)'>") geom.srid = geom.srid # clear cached WKB self.assertEquals(geom.__str__().lower(), wkb.lower())
def pathFinder(request): #위험지역 받는 함수 global startX,startY,endX,endY,startGu,endGu gu_list=['종로구','중구','용산구','성동구','광진구', '동대문구','중랑구','성북구','강북구','도봉구', '노원구','은평구','서대문구','마포구','양천구', '강서구','구로구','금천구','영등포구','동작구', '관악구','서초구','강남구','송파구','강동구',] loc_list=[] if request.method=="POST": startPoint=request.POST.get('start') endPoint=request.POST.get('end') startX=request.POST.get('startX') startY=request.POST.get('startY') endX=request.POST.get('endX') endY=request.POST.get('endY') for find_gu in gu_list: if find_gu in startPoint: startGu=find_gu else: pass if find_gu in endPoint: endGu=find_gu else: pass female_start=Female2.objects.filter(female2_crime_type="전체_전체",gu=startGu).all() female_end=Female2.objects.filter(female2_crime_type="전체_전체",gu=endGu).all() female_total=female_start.union(female_end,all=False) for loc in female_total: gis= Geometry(loc.female2_crime_loc.hex()[8:]) contain_coordinate=shape(gis.geojson) crime_location={"type":"Feature","geometry":gis.geojson} loc_list.append(crime_location) pistes = {"type":"FeatureCollection","features":loc_list} return HttpResponse(json.dumps({'result':pistes}),content_type="application/json")
def test_read_wkb_point_big_endian(self): """ read WKB Point """ geom = Geometry("000000000140000000000000004010000000000000") self.assertIsInstance(geom, Point) self.assertEqual((2, 4, None), (geom.x, geom.y, geom.z))
def showFemale(request): global g global getGu crime_type="" loc_list=[] if request.method=="POST": filter_value=request.POST['female_filter'] crime_type="전체_"+filter_value female_total=Female2.objects.filter(gu=getGu,female2_crime_type=crime_type).all() linear = cmp.LinearColormap( [ 'green','blue','red'], vmin=10, vmax=300) map = folium.Map(location=[37.55582994870823, 126.9726320033982],zoom_start=15) for loc in female_total: gis= Geometry(loc.female2_crime_loc.hex()[8:]) contain_coordinate=shape(gis.geojson) crime_location={"type":"Feature","properties":{'area':math.ceil(round(contain_coordinate.length,5)*100000)},"geometry":gis.geojson} folium.GeoJson(crime_location,style_function=lambda feature: { 'fillColor': linear(feature['properties']['area']), 'color': linear(feature['properties']['area']), 'weight': 1 }).add_to(map) linear.add_to(map) maps=map._repr_html_() return render(request, 'home.html',{'map':maps})
def converterFeature(geometry): g = Geometry(geometry) coord = g.geojson['coordinates'][0][0] saida = [] for c in coord: c.reverse() saida.append(c) return saida
def converterGeometryPolygon(geometry): g = Geometry(geometry) coord = g.geojson['coordinates'] saida = [] for c in coord[0]: c.reverse() saida.append(c) return saida
def test_read_wkb_linestring(self): """ read WKB LineString """ wkb = wkb_ln geom = Geometry(wkb) self.assertEquals(geom.type, "LineString") self.assertEquals(geom.srid, None) self.assertEquals(geom.dimz, False) self.assertEquals(geom.dimm, False) postgis_type = "geometry(LineString)" geom.vertices self.assertEquals(geom.postgis_type, postgis_type) self.assertEquals(geom.__repr__(), "<LineString: 'geometry(LineString)'>") geom.srid = geom.srid # clear cached WKB self.assertEquals(geom.__str__().lower(), wkb.lower())
def aStar(request): global startGu, endGu center = hexgrid.Point((float(startX) + float(endX)) / 2, (float(startY) + float(endY)) / 2) rate = 110.574 / (111.320 * math.cos(37.55582994870823 * math.pi / 180)) grid = hexgrid.Grid(hexgrid.OrientationFlat, center, Point(rate * 0.00015, 0.00015), morton.Morton(2, 32)) sPoint = grid.hex_at(Point(float(startX), float(startY))) ePoint = grid.hex_at(Point(float(endX), float(endY))) map_size = max(abs(sPoint.q), abs(sPoint.r)) road1 = Roadtohexgrid.objects.filter(is_danger=1, hexgrid_gu=startGu).all() road2 = Roadtohexgrid.objects.filter(is_danger=1, hexgrid_gu=endGu).all() total_road = road1.union(road2, all=False) wall1 = Roadtohexgrid.objects.filter(is_danger=0, hexgrid_gu=startGu).all() wall2 = Roadtohexgrid.objects.filter(is_danger=0, hexgrid_gu=endGu).all() total_wall = wall1.union(wall2, all=False) wh = GridWithWeights(layout_flat, Point(rate * 0.00015, 0.00015), center, map_size + 5) for r in total_road: gis = Geometry(r.hexgrid_loc.hex()[8:]) h = grid.hex_at(shape(gis.geojson)) wh.weights[(h.q, h.r)] = 1 for w in total_wall: gis = Geometry(w.hexgrid_loc.hex()[8:]) h = grid.hex_at(shape(gis.geojson)) wh.weights[(h.q, h.r)] = 200 start, goal = (sPoint.q, sPoint.r), (ePoint.q, ePoint.r) came_from, cost_so_far = a_star_search(wh, start, goal) pointList = reconstruct_path(came_from, start=start, goal=goal) plist = [] for p in pointList: point = wh.hex_to_pixel(hexgrid.Hex(p[0], p[1])) plist.append([point.x, point.y]) crime_location = { "type": "Feature", "geometry": { "type": "LineString", "coordinates": plist } } pistes = {"type": "FeatureCollection", "features": [crime_location]} return HttpResponse(json.dumps({'pistes': pistes}), content_type="application/json")
def test_read_wkb_multilinestring(self): """ read WKB MultiLineString """ wkb = wkb_mln geom = Geometry(wkb) self.assertEquals(geom.type, "MultiLineString") self.assertEquals(geom.srid, None) self.assertEquals(geom.dimz, False) self.assertEquals(geom.dimm, True) postgis_type = "geometry(MultiLineStringM)" self.assertEquals(geom.postgis_type, postgis_type) self.assertEquals(geom.__repr__(), "<MultiLineString: 'geometry(MultiLineStringM)'>") geom.srid = geom.srid # clear cached WKB self.assertEquals(geom.__str__().lower(), wkb.lower()) for g in geom.geometries: self.assertEquals(g.type, "LineString")
def test_read_wkb_multipolygon(self): """ read WKB MultiPolygon """ wkb = wkb_mpg geom = Geometry(wkb) self.assertEquals(geom.type, "MultiPolygon") self.assertEquals(geom.srid, None) self.assertEquals(geom.dimz, False) self.assertEquals(geom.dimm, False) postgis_type = "geometry(MultiPolygon)" self.assertEquals(geom.postgis_type, postgis_type) self.assertEquals(geom.__repr__(), "<MultiPolygon: 'geometry(MultiPolygon)'>") geom.srid = geom.srid # clear cached WKB self.assertEquals(geom.__str__().lower(), wkb.lower()) for g in geom.geometries: self.assertEquals(g.type, "Polygon")
def test_translate_geojson_pt(self): """ load and dump GeoJSON point """ geom = Geometry.from_geojson(geojson_pt) self.assertEquals(geom.srid, 4326) self.assertEquals(Point, type(geom)) geojson = geom.geojson self.assertEquals(geojson, geojson_pt)
def test_translate_geojson_mln(self): """ load and dump GeoJSON multiline """ geom = Geometry.from_geojson(geojson_mln) self.assertEquals(geom.srid, 4326) self.assertEquals(MultiLineString, type(geom)) geojson = geom.geojson self.assertEquals(geojson, geojson_mln)
def test_translate_geojson_gc(self): """ load and dump GeoJSON GeometryCollection """ geom = Geometry.from_geojson(geojson_gc) self.assertEquals(geom.srid, 4326) self.assertEquals(GeometryCollection, type(geom)) geojson = geom.geojson self.assertEquals(geojson, geojson_gc)
def test_translate_geojson_mpg(self): """ load and dump GeoJSON multipolygon """ geom = Geometry.from_geojson(geojson_mpg) self.assertEquals(geom.srid, 4326) self.assertEquals(MultiPolygon, type(geom)) geojson = geom.geojson self.assertEquals(geojson, geojson_mpg)
def test_bounds_geomcollection(self): """ check bounds of GeometryCollection """ geom = Geometry.from_geojson(geojson_gc) bounds = geom.bounds self.assertEquals(bounds[0], 10) self.assertEquals(bounds[1], 0) self.assertEquals(bounds[2], 12) self.assertEquals(bounds[3], 1)
def test_bounds_multipolygon(self): """ check bounds of MultiPolygon """ geom = Geometry.from_geojson(geojson_mpg) bounds = geom.bounds self.assertEquals(bounds[0], 1) self.assertEquals(bounds[1], 0) self.assertEquals(bounds[2], 111) self.assertEquals(bounds[3], 1)
def test_bounds_multilinestring(self): """ check bounds of MultiLineString """ geom = Geometry.from_geojson(geojson_mln) bounds = geom.bounds self.assertEquals(bounds[0], 0) self.assertEquals(bounds[1], 0) self.assertEquals(bounds[2], 3) self.assertEquals(bounds[3], 3)
def test_bounds_polygon(self): """ check bounds of Polygon """ geom = Geometry.from_geojson(geojson_pg) bounds = geom.bounds self.assertEquals(bounds[0], 100) self.assertEquals(bounds[1], 0) self.assertEquals(bounds[2], 101) self.assertEquals(bounds[3], 1)
def test_bounds_linestring(self): """ check bounds of LineString """ geom = Geometry.from_geojson(geojson_ln) bounds = geom.bounds self.assertEquals(bounds[0], 102) self.assertEquals(bounds[1], 59) self.assertEquals(bounds[2], 107) self.assertEquals(bounds[3], 60)
def test_read_wkb_geometrycollection(self): """ read WKB GeometryCollection """ wkb = wkb_gc geom = Geometry(wkb) self.assertEquals(geom.type, "GeometryCollection") self.assertEquals(geom.srid, None) self.assertEquals(geom.dimz, False) self.assertEquals(geom.dimm, False) postgis_type = "geometry(GeometryCollection)" self.assertEquals(geom.postgis_type, postgis_type) self.assertEquals( geom.__repr__(), "<GeometryCollection: 'geometry(GeometryCollection)'>") geom.srid = geom.srid # clear cached WKB self.assertEquals(geom.__str__().lower(), wkb.lower()) self.assertEquals(geom.geometries[0].type, "Point") self.assertEquals(geom.geometries[1].type, "LineString")
def test_bounds_multipoint(self): """ check bounds of MultiPoint """ geom = Geometry.from_geojson(geojson_mpt) bounds = geom.bounds self.assertEqual(bounds[0], 0) self.assertEqual(bounds[1], 0) self.assertEqual(bounds[2], 1) self.assertEqual(bounds[3], 1)
def test_bounds_point(self): """ check bounds of Point """ geom = Geometry.from_geojson(geojson_pt) bounds = geom.bounds self.assertEquals(bounds[0], 0.0) self.assertEquals(bounds[1], 0.0) self.assertEquals(bounds[2], 0.0) self.assertEquals(bounds[3], 0.0)