def convert_to_canonical(P=[]): """Convertion function to convert from shapely object to canonical form. Args: P: Shapely object representing a polygon. Returns: poly: A polygon represented in canonical form. [] otherwise. """ if type(P) is not Polygon: logger.warn("Polygon conversion requested but wrong input specified.") return None poly = [[], []] if not LinearRing(P.exterior.coords).is_ccw: poly[0] = list(P.exterior.coords)[::-1][:-1] else: poly[0] = list(P.exterior.coords)[:-1] for hole in P.interiors: if LinearRing(hole.coords).is_ccw: poly[1].append(list(hole.coords)[::-1][:-1]) else: poly[1].append(list(hole.coords)[:-1]) return poly
def __call__(self) -> gpd.GeoDataFrame: tri = self._grd.elements.triangulation idxs = np.vstack(list(np.where(tri.neighbors == -1))).T boundary_edges = [] for i, j in idxs: boundary_edges.append( (tri.triangles[i, j], tri.triangles[i, (j+1) % 3])) sorted_rings = sort_rings(edges_to_rings(boundary_edges), self._grd.nodes.coord) data = [] for bnd_id, rings in sorted_rings.items(): coords = self._grd.nodes.coord[rings['exterior'][:, 0], :] geometry = LinearRing(coords) data.append({ "geometry": geometry, "bnd_id": bnd_id, "type": 'exterior' }) for interior in rings['interiors']: coords = self._grd.nodes.coord[interior[:, 0], :] geometry = LinearRing(coords) data.append({ "geometry": geometry, "bnd_id": bnd_id, "type": 'interior' }) return gpd.GeoDataFrame(data, crs=self._grd.crs)
def hit(self, car): print('??') x = car.position.x * 32 y = car.position.y * 32 print(x, y) lenght = car.length line1 = LineString([(x - lenght, y - lenght), (x + lenght, y - lenght), (x - lenght, y + lenght), (x + lenght, y + lenght)]) line2 = LinearRing(self.inner_line) line3 = LinearRing(self.outer_line) intersection1 = (line1.intersection(line2)) intersection2 = (line1.intersection(line3)) if (isinstance(intersection1, shapely.geometry.multipoint.MultiPoint)): intersection1 = intersection1[len(intersection1) - 1] if (isinstance(intersection2, shapely.geometry.multipoint.MultiPoint)): intersection2 = intersection2[len(intersection2) - 1] if (len(intersection1.coords) > 0): return True if (len(intersection2.coords) > 0): return True return False
def find_linerings(self): if self.linerings_found: return # t = MapTools() firstpoint = self.lines[0][0] points = [] previousEnd = firstpoint[1] #print("First point:",firstpoint) self.linerings_found = True for line in self.lines: # print (line[0],line[1],line[0]==previousEnd,end='') if points == [] or (line[0] == previousEnd).all(): points.append(line[1]) else: ring = Polygon(LinearRing(points)) #print("Ring length:",len(ring.coords)) #pyglet.graphics.draw(len(ring.coords), pyglet.gl.GL_LINE_LOOP,ring) self.linerings.append(ring) #self.plot(ring) #print(ring) points = [] previousEnd = line[1] road = self.linerings[0].difference(self.linerings[1]) self.road = road #object.intersects(other) #Returns True if the boundary or interior of the object intersect in any way with those of the other. if points != []: ring = Polygon(LinearRing(points)) self.linerings.append(ring)
def normalise_compound_region(compound_region_indices, regions): '''Normalise a compound region so that exterior contours are counterclockwise and holes are clockwise. ''' _, sub_regions = compound_region_indices reference_orientation = LinearRing(regions[sub_regions[0]][1]).is_ccw reference_orientation_is_hole = is_reference_orientation_a_hole( regions, sub_regions) normalised_compound_region = [] for sub_region in sub_regions: name, region, child_number = regions[sub_region] oriented_as_reference = LinearRing( region).is_ccw == reference_orientation is_hole = (oriented_as_reference if reference_orientation_is_hole else (not oriented_as_reference)) normalised_region = region.copy() if is_hole and LinearRing(region).is_ccw: normalised_region = np.flip(region, axis=0) if not is_hole and not LinearRing(region).is_ccw: normalised_region = np.flip(region, axis=0) normalised_compound_region.append( [name, normalised_region, child_number]) return normalised_compound_region
def flatten_geometry(geometry: BaseGeometry) -> BaseGeometry: """ :param geometry: Shapely geometry object :return: geometry with Z values removed """ geometry_type = type(geometry) # strip 3rd dimension if 'POLYGON Z' in geometry.wkt: polygons = ([polygon for polygon in geometry] if geometry_type is MultiPolygon else [geometry]) for polygon_index, polygon in enumerate(polygons): exterior_2d = LinearRing( [vertex[:2] for vertex in polygon.exterior.coords]) interiors_2d = [ LinearRing([vertex[:2] for vertex in interior.coords]) for interior in polygon.interiors ] polygons[polygon_index] = Polygon(exterior_2d, interiors_2d) geometry = (MultiPolygon(polygons) if geometry_type is MultiPolygon else Polygon(polygons[0])) if not geometry.is_valid: geometry = geometry.buffer(0) return geometry
def __init__(self, raster_mask, no_data_value=None, ignore_labels=None): if ignore_labels is None: ignore_labels = [] self.geometries = [{ 'label': int(label), 'polygon': Polygon(LinearRing(shp['coordinates'][0]), [LinearRing(pts) for pts in shp['coordinates'][1:]]) } for index, (shp, label) in enumerate( rasterio.features.shapes(raster_mask, mask=None)) if (int(label) is not no_data_value) and ( int(label) not in ignore_labels)] self.areas = np.asarray( [entry['polygon'].area for entry in self.geometries]) self.decomposition = [ shapely.ops.triangulate(entry['polygon']) for entry in self.geometries ] self.label2cc = collections.defaultdict(list) for index, entry in enumerate(self.geometries): self.label2cc[entry['label']].append(index)
def findClosestStreet(pnt, streets, bld, sg=None): """ :param pnt: point to check closest street to :param streets: all streets in dataset :param bld: building to be checked against intersection with street :return: Tuple containing line length, street, street index and the LineString itself """ mylist = [] for i, street in enumerate(streets): if not sg: if bld.geom.intersects(street): continue pol_ext = LinearRing(street.exterior.coords) d = pol_ext.project(pnt) p = pol_ext.interpolate(d) clstpnt = list(p.coords)[0] nline = LineString([pnt, clstpnt]) mylist.append([nline.length, street, i, nline]) else: pol_ext = LinearRing(streets[sg].exterior.coords) d = pol_ext.project(pnt) p = pol_ext.interpolate(d) clstpnt = list(p.coords)[0] nline = LineString([pnt, clstpnt]) return [nline.length, streets[sg], sg, nline] smallest = min(mylist) return smallest
def test_linearring_from_coordinate_sequence(): expected_coords = [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (0.0, 0.0)] ring = LinearRing(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0))) assert ring.coords[:] == expected_coords ring = LinearRing([(0.0, 0.0), (0.0, 1.0), (1.0, 1.0)]) assert ring.coords[:] == expected_coords
def check_collision(self, car_point): car = LinearRing(car_point) outer = LinearRing(self.pointlist_out) inner = LinearRing(self.pointlist_in) if outer.intersects(car) or inner.intersects(car): return True else: return False
def test_linearring_from_empty(): ring = LinearRing() assert ring.is_empty assert isinstance(ring.coords, CoordinateSequence) assert ring.coords[:] == [] ring = LinearRing([]) assert ring.is_empty assert isinstance(ring.coords, CoordinateSequence) assert ring.coords[:] == []
def _resample_outer_and_inner_polygons(outer_polygon, inner_polygon, nodeinterval): # resample inner and outer polygons outer = LinearRing(outer_polygon) inner = LinearRing(inner_polygon) samples = int(outer.length/nodeinterval+0.5) outer_res = np.zeros((samples,2)) inner_res = np.zeros((samples,2)) for i in range(samples): outer_res[i,:] = outer.interpolate(i/samples, normalized=True) inner_res[i,:] = inner.interpolate(i/samples, normalized=True) return outer_res, inner_res
def get_lines(shape, gap): hlines = get_hlines(shape, gap) lines, hlines_by_heights = get_intersections(shape, hlines) connection_lines = LinearRing(shape.exterior).difference(MultiLineString(hlines)) connection_lines = geom_to_list(connection_lines) for hole in shape.interiors: extra_connection_lines = LinearRing(hole).difference(MultiLineString(hlines)) extra_connection_lines = geom_to_list(extra_connection_lines) connection_lines.extend(extra_connection_lines) connection_lines = remove_same_height_lines(lines, connection_lines) return lines, connection_lines, hlines_by_heights
def mock_geocoder() -> 'MockGeocoder': point_gdf = geo_data_frame([Point(-5, 17)]) point_dict = {'coord': ['{"type": "Point", "coordinates": [-5.0, 17.0]}']} polygon_gdf = geo_data_frame(MultiPolygon([ Polygon(LinearRing([(11, 12), (13, 14), (15, 13), (7, 4)])), Polygon(LinearRing([(10, 2), (13, 10), (12, 3)])) ]) ) polygon_dict = { 'coord': [ '{"type": "Polygon", "coordinates": [[[11.0, 12.0], [13.0, 14.0], [15.0, 13.0], [7.0, 4.0], [11.0, 12.0]]]}', '{"type": "Polygon", "coordinates": [[[10.0, 2.0], [13.0, 10.0], [12.0, 3.0], [10.0, 2.0]]]}' ] } class MockGeocoder(Geocoder): def __init__(self): self._get_geocodes_invoked = False self._limits_fetched = False self._centroids_fetched = False self._boundaries_fetched = False def get_test_point_dict(self): return point_dict def get_test_polygon_dict(self): return polygon_dict def get_test_geocodes(self) -> dict: return {'request': ['foo'], 'found name': ['FOO']} def get_geocodes(self): self._get_geocodes_invoked = True return DataFrame(self.get_test_geocodes()) def get_limits(self) -> GeoDataFrame: self._limits_fetched = True return polygon_gdf def get_centroids(self) -> GeoDataFrame: self._centroids_fetched = True return point_gdf def get_boundaries(self, resolution=None) -> GeoDataFrame: self._boundaries_fetched = True return polygon_gdf def assert_get_geocodes_invocation(self): assert self._get_geocodes_invoked, 'to_data_frame() invocation expected, but not happened' return MockGeocoder()
def plot_push_results(pushes, poses): bins = np.arange(-0.5125, 0.5375, 0.025) target_angles = np.arange(-0.5, 0.525, 0.025) bin_map = np.digitize([push.angle for push in pushes], bins) candidates = [[a, [], []] for a in target_angles] for i, (push, pose) in enumerate(zip(pushes, poses)): d = bin_map[i] - 1 ta = target_angles[d] candidates[d][1].append(push) candidates[d][2].append(pose) #if((candidates[d][1] is None) or abs(push.angle - ta) < abs(candidates[d][1].angle - ta)): # candidates[d] = [ta, push, pose] t_boxes = [] for c in candidates: target_angle = c[0] c_pushes = c[1] c_poses = c[2] if len(c_poses) > 0: x = np.median([p.position.x for p in c_poses]) y = np.median([p.position.y for p in c_poses]) push_angle = np.median([p.angle for p in c_pushes]) push_x = np.median([p.approach.position.x for p in c_pushes]) push_y = np.median([p.approach.position.y for p in c_pushes]) yaw = np.median(np.array([get_yaw(p) for p in c_poses])) cos_a = math.cos(yaw) sin_a = math.sin(yaw) transformed_box = affinity.affine_transform(get_box(0.162, 0.23), [cos_a, -sin_a, sin_a, cos_a, x, y]) push_line = get_line(push_x, push_y, c_pushes[0].distance - 0.004, push_angle + get_yaw(push.approach)) t_boxes.append((target_angle, transformed_box, push_line)) box = get_box(0.162, 0.23) #x, y = box.xy y, x = LinearRing(box.exterior.coords).xy plt.plot(x, y, color="black", linewidth=3) for angle, box, push_line in t_boxes: y, x = LinearRing(box.exterior.coords).xy plt.plot(x, y) y,x = push_line.xy plt.plot(x, y) plt.xlim(-0.2, 0.2) plt.ylim(-0.2, 0.2) plt.axes().set_aspect('equal', adjustable='box') plt.show()
def __generate_visivility_graph(self): def extend_line(line): return np.append(line, [line[0], line[1]], axis=0) H = self.__H join_style = JOIN_STYLE.mitre is_ccw = LinearRing(self.borders_points).is_ccw map_po = LineString(extend_line(self.borders_points)).parallel_offset( H, 'left' if is_ccw else 'right', join_style=join_style ) if map_po.geom_type == 'MultiLineString': geoms = list(map_po.geoms) map_po = list(chain(geoms[0].coords, geoms[1].coords)) self.__support_points = np.array(map_po) self.__holes = [] for item in self.items_border_points: if item.size > 0: is_ccw = LinearRing(item).is_ccw item_po = LineString(extend_line(item)).parallel_offset( H, 'right' if is_ccw else 'left', join_style=join_style ) if item_po.geom_type == 'MultiLineString': geoms = list(item_po.geoms) item_po = list(chain(geoms[0].coords, geoms[1].coords)) support_item_points = np.array(item_po) self.__holes.append(support_item_points) all_points = self.__support_points for hole in self.__holes: all_points = np.append(all_points, hole, axis=0) holes_p = [Polygon(h) for h in self.__holes] border_p = Polygon(self.__support_points) points_len = len(all_points) visibility_graph = np.zeros(shape=(points_len, points_len)) for i in range(all_points.shape[0]): for j in range(all_points.shape[0]): line = np.array((all_points[i], all_points[j])) if self.is_valid(LineString(line), border_p, holes_p): visibility_graph[i, j] = True return all_points, visibility_graph
def has_collision(P, edge): exterior = LinearRing(P[0]) holes = P[1] segment = LineString(edge) if exterior.intersects(segment): return True for hole in holes: interior = LinearRing(hole) if interior.intersects(segment): return True return False
def screen_building(self, building): building_polyline = LinearRing(list(building.exterior.coords)) points = [self.point.coords[0]] angles = np.linspace(-VIEWING_ANGLE / 2, VIEWING_ANGLE / 2, VIEWING_POINTS) is_sector_screened = False for angle in angles: v = rotate(self.center, angle, origin=self.center.coords[0], use_radians=False) intersection = building_polyline.intersection(v) if isinstance(intersection, Point): if intersection.distance(self.point) < ALLOWED_DISTANCE_ERROR: # Camera is placed on this building. points.append(v.coords[1]) continue points.append((intersection.x, intersection.y)) is_sector_screened = True elif isinstance(intersection, LineString): lines = [ LineString([(self.point.x, self.point.y), p]) for p in list(intersection.coords) ] line = min(lines, key=lambda l: l.length) points.append(line.coords[1]) is_sector_screened = True elif len(list(intersection)) > 1: pts = [] for entity in intersection: if isinstance(entity, Point): pts.append(entity) elif isinstance(entity, LineString): for pt in entity.coords: pts.append(Point(pt)) else: continue lines = [ LineString([(self.point.x, self.point.y), (p.x, p.y)]) for p in pts ] line = min(lines, key=lambda l: l.length) points.append(line.coords[1]) is_sector_screened = True else: points.append(v.coords[1]) if not is_sector_screened: return self.polyline = LinearRing(points) self.polygon = Polygon(points)
def segmentize_geometry(geometry, segmentize_value): """ Segmentize Polygon outer ring by segmentize value. Just Polygon geometry type supported. Parameters ---------- geometry : ``shapely.geometry`` segmentize_value: float Returns ------- geometry : ``shapely.geometry`` """ if geometry.geom_type != "Polygon": raise TypeError("segmentize geometry type must be Polygon") points = [] p_xy = None for xy in geometry.exterior.coords: if p_xy is not None: line_segment = LineString([p_xy, xy]) points.extend([ line_segment.interpolate(segmentize_value * i).coords[0] for i in range(int(line_segment.length / segmentize_value)) ]) p_xy = xy points.append(xy) return Polygon(LinearRing(points))
def v_type(p: Point2D, vertex: Point2D, n: Point2D) -> int: r = LinearRing([p, vertex, n]) if not r.is_valid: return FLAT if r.is_ccw: return REGULAR return NON_REGULAR
def build_circular_hatch(delta, offset, w, h): center_x = w / 2 center_y = h / 2 ls = [] for r in np.arange(offset, math.sqrt(w * w + h * h), delta): # make a tiny circle as point in the center if r == 0: r = 0.001 # compute a meaningful number of segment adapted to the circle's radius n = max(20, r) t = np.arange(0, 1, 1 / n) # A random phase is useful for circles that end up unmasked. If several such circles # start and stop at the same location, a disgraceful pattern will emerge when plotting. phase = random.random() * 2 * math.pi data = np.array([ center_x + r * np.cos(t * math.pi * 2 + phase), center_y + r * np.sin(t * math.pi * 2 + phase), ]).T ls.append(LinearRing(data)) mls = MultiLineString(ls) # Crop the circle to the final dimension p = Polygon([(0, 0), (w, 0), (w, h), (0, h)]) return mls.intersection(p)
def test_numpy_linearring_coords(): from numpy.testing import assert_array_equal ring = LinearRing(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0))) ra = np.asarray(ring.coords) expected = np.asarray([(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (0.0, 0.0)]) assert_array_equal(ra, expected)
def simplify_ring(ring: LinearRing) -> LinearRing: ring = ring.simplify(0) cs = ring.coords if v_type(cs[-2], cs[0], cs[1]) == FLAT: cs = cs[1:-1] ring = LinearRing(ring) return ring
def df_linear_ring(): from shapely.geometry import LinearRing df = geopandas.GeoDataFrame( {"geometry": [LinearRing(((0, 0), (0, 1), (1, 1), (1, 0)))]}, crs="epsg:4326") return df
def test_linearring_from_too_short_linestring(): # Creation of LinearRing request at least 3 coordinates (unclosed) or # 4 coordinates (closed) coords = [(0.0, 0.0), (1.0, 1.0)] line = LineString(coords) with pytest.raises(ValueError, match="requires at least 4 coordinates"): LinearRing(line)
def test_linearring_from_unclosed_linestring(): coords = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)] line = LineString(coords[:-1]) # Pass in unclosed line ring = LinearRing(line) assert len(ring.coords) == 4 assert ring.coords[:] == coords assert ring.geom_type == "LinearRing"
def sort_detection(self, temp_dir): origin_file = temp_dir output_file = "final_" + temp_dir if not os.path.isdir(output_file): os.mkdir(output_file) files = glob.glob(origin_file + '*.txt') files.sort() for i in files: out = i.replace(origin_file, output_file) fin = open(i, 'r').readlines() fout = open(out, 'w') for iline, line in enumerate(fin): ptr = line.strip().split(',####') rec = ptr[1] cors = ptr[0].split(',') assert (len(cors) % 2 == 0), 'cors invalid.' pts = [(int(cors[j]), int(cors[j + 1])) for j in range(0, len(cors), 2)] try: pgt = Polygon(pts) except Exception as e: print(e) print('An invalid detection in {} line {} is removed ... '. format(i, iline)) continue if not pgt.is_valid: print('An invalid detection in {} line {} is removed ... '. format(i, iline)) continue pRing = LinearRing(pts) if pRing.is_ccw: pts.reverse() outstr = '' for ipt in pts[:-1]: outstr += (str(int(ipt[0])) + ',' + str(int(ipt[1])) + ',') outstr += (str(int(pts[-1][0])) + ',' + str(int(pts[-1][1]))) outstr = outstr + ',####' + rec fout.writelines(outstr + '\n') fout.close() os.chdir(output_file) def zipdir(path, ziph): # ziph is zipfile handle for root, dirs, files in os.walk(path): for file in files: ziph.write(os.path.join(root, file)) zipf = zipfile.ZipFile('../det.zip', 'w', zipfile.ZIP_DEFLATED) zipdir('./', zipf) zipf.close() os.chdir("../") # clean temp files shutil.rmtree(origin_file) shutil.rmtree(output_file) return "det.zip"
def parse_query(self, query): super(MapPlotter, self).parse_query(query) self.projection = query.get('projection') self.area = query.get('area') names = [] centroids = [] all_rings = [] data = None for idx, a in enumerate(self.area): if isinstance(a, basestring): a = a.encode("utf-8") sp = a.split('/', 1) if data is None: data = list_areas(sp[0], simplify=False) b = [x for x in data if x.get('key') == a] a = b[0] self.area[idx] = a else: p = np.array(a['polygons']) p[:, :, 1] = pyresample.utils.wrap_longitudes(p[:, :, 1]) a['polygons'] = p.tolist() del p rings = [LinearRing(po) for po in a['polygons']] if len(rings) > 1: u = cascaded_union(rings) else: u = rings[0] all_rings.append(u) if a.get('name'): names.append(a.get('name')) centroids.append(u.centroid) nc = sorted(zip(names, centroids)) self.names = [n for (n, c) in nc] self.centroids = [c for (n, c) in nc] data = None if len(all_rings) > 1: combined = cascaded_union(all_rings) else: combined = all_rings[0] self.combined_area = combined combined = combined.envelope self.centroid = list(combined.centroid.coords)[0] self.bounds = combined.bounds self.show_bathymetry = bool(query.get('bathymetry')) self.show_area = bool(query.get('showarea')) self.quiver = query.get('quiver') self.contour = query.get('contour')
def gettheordertime(self): polys = sf.Reader("shapefiles/test/wholeArea.shp") polygon = polys.shapes() shpfilePoints = [] for shape in polygon: shpfilePoints = shape.points polygon = Polygon(shpfilePoints) # #[锦里,九眼桥,锦江宾馆, 仁恒置地, 桐梓林, 骡马寺] # currentPoint = [30.662447, 104.072469] # 天府广场 # points = [[30.650817,104.056385], [30.645582,104.095192], [30.654087,104.072528], # [30.658646,104.072563], [30.621274,104.073749], [30.672531,104.071962]] # destination = [30.599595,104.040745] # 交界点 point = Point(104.072469, 30.662447) # 天府广场 # point = Point(104.040745,30.599595) # keyPoint # point = Point(104.042779,30.620844) # point in polygon test if polygon.contains(point): print 'inside' else: print 'OUT' polExt = LinearRing(polygon.exterior.coords) d = polExt.project(point) p = polExt.interpolate(d) closest_point_coords = list(p.coords)[0] print list(p.coords) print d
def buffer_polygon(polygon, points): """ Given a set of points outside a polygon, expand the polygon to include points within 250 meters Args: polygon - shapely polygon points - list of shapely points Returns: new polygon with buffered points added """ not_close = [] add_buffers = [] poly_ext = LinearRing(polygon.exterior.coords) for point in points: # Find the distance between the point and the city polygon dist = polygon.distance(point) if dist > 250: not_close.append(point) else: # Create a line between the polygon and the point, # and buffer it point2 = poly_ext.interpolate(poly_ext.project(point)) line = LineString([(point.x, point.y), (point2.x, point2.y)]) buff = line.buffer(50) add_buffers.append(buff) for buff in add_buffers: polygon = polygon.union(buff) if not_close: print("{} crashes fell outside the buffered city polygon".format( len(not_close))) else: print("Expanded city polygon to include all crash locations") return polygon