def test_numpy(self): from numpy import array, asarray from numpy.testing import assert_array_equal # Construct from a numpy array geom = MultiPoint(array([[0.0, 0.0], [1.0, 2.0]])) self.assertIsInstance(geom, MultiPoint) self.assertEqual(len(geom.geoms), 2) self.assertEqual(dump_coords(geom), [[(0.0, 0.0)], [(1.0, 2.0)]]) # Geo interface (cont.) geom = MultiPoint((Point(1.0, 2.0), Point(3.0, 4.0))) assert_array_equal(array(geom), array([[1., 2.], [3., 4.]])) # Adapt a Numpy array to a multipoint a = array([[1.0, 2.0], [3.0, 4.0]]) geoma = asMultiPoint(a) assert_array_equal(geoma.context, array([[1., 2.], [3., 4.]])) self.assertEqual(dump_coords(geoma), [[(1.0, 2.0)], [(3.0, 4.0)]]) # Now, the inverse self.assertEqual(geoma.__array_interface__, geoma.context.__array_interface__) pas = asarray(geoma) assert_array_equal(pas, array([[1., 2.], [3., 4.]]))
def test_multipoint(self): # From coordinate tuples geom = MultiPoint(((1.0, 2.0), (3.0, 4.0))) self.assertEqual(len(geom.geoms), 2) self.assertEqual(dump_coords(geom), [[(1.0, 2.0)], [(3.0, 4.0)]]) # From points geom = MultiPoint((Point(1.0, 2.0), Point(3.0, 4.0))) self.assertEqual(len(geom.geoms), 2) self.assertEqual(dump_coords(geom), [[(1.0, 2.0)], [(3.0, 4.0)]]) # From another multi-point geom2 = MultiPoint(geom) self.assertEqual(len(geom2.geoms), 2) self.assertEqual(dump_coords(geom2), [[(1.0, 2.0)], [(3.0, 4.0)]]) # Sub-geometry Access self.assertIsInstance(geom.geoms[0], Point) self.assertEqual(geom.geoms[0].x, 1.0) self.assertEqual(geom.geoms[0].y, 2.0) with self.assertRaises(IndexError): # index out of range geom.geoms[2] # Geo interface self.assertEqual(geom.__geo_interface__, {'type': 'MultiPoint', 'coordinates': ((1.0, 2.0), (3.0, 4.0))}) # Adapt a coordinate list to a line string coords = [[5.0, 6.0], [7.0, 8.0]] geoma = asMultiPoint(coords) self.assertEqual(dump_coords(geoma), [[(5.0, 6.0)], [(7.0, 8.0)]])
def find_nearest_neighbor(x, y, num_neighbors=1): ''' :param x: object borders as an m x 2 numpy array, where m is the number of points :param y: object borders as an n x 2 numpy array, where n is the number of points :param num_neighbors: :return: ''' if isinstance(x, sg.Point) or isinstance(x, sg.MultiPoint): # x was input as a shapely point/multipoint object point_x = x elif x.ndim == 1 or np.shape(x)[0] == 1: # x is a vector, either shape (2,) or shape (1,2) point_x = sg.asPoint(np.squeeze(x)) else: # x is an m x 2 array of multiple points (m > 1) point_x = sg.asMultiPoint(x) if isinstance(y, sg.Point) or isinstance(y, sg.MultiPoint): # y was input as a shapely point/multipoint object point_y = y elif y.ndim == 1 or np.shape(y)[0] == 1: # y is a vector, either shape (2,) or shape (1,2) point_y = sg.asPoint(np.squeeze(y)) else: # y is an m y 2 array of multiple points (m > 1) point_y = sg.asMultiPoint(y) # if type(y) is sg.Point: # point_y = y # else: # point_y = sg.asPoint(y) near_x, near_y = so.nearest_points(point_x, point_y) nn_dist = near_x.distance(near_y) # left over from when I thought it would be useful to find the n nearest points. Right now, just finds the nearest points # pts_diff = y - x # # dist_from_x = np.linalg.norm(pts_diff, axis=1) # # sorted_dist_idx = np.argsort(dist_from_x) # sorted_dist = np.sort(dist_from_x) # # return sorted_dist[:num_neighbors], sorted_dist_idx[:num_neighbors] return nn_dist, near_y
def test_multipoint_adapter(self): arr = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]]) tarr = arr.T shape = geometry.asMultiPoint(tarr) coords = reduce(lambda x, y: x + y, [list(g.coords) for g in shape]) self.assertEqual(coords, [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)])
def rescale_points(points, image_size): """ Rescales [0, 1] normalized points to the specified Width x Height. """ coordinates = ( np.array([p.xy for p in points]).squeeze(-1) * image_size ).round() return list(asMultiPoint(coordinates))
def test_multipoint(self): a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]]) t = a.T s = geometry.asMultiPoint(t) coords = reduce(lambda x, y: x + y, [list(g.coords) for g in s]) self.failUnlessEqual( coords, [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
def filter_inside(points: Union[MultiPoint, np.ndarray], poly: BaseGeometry) -> MultiPoint: if isinstance(points, np.ndarray): points = asMultiPoint(points) prep_polygon = prep(poly) points = [i for i in points if prep_polygon.contains(i)] points = MultiPoint(points) return points
def test_multipoint(self): arr = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]]) tarr = arr.T shape = geometry.asMultiPoint(tarr) coords = reduce(lambda x, y: x + y, [list(g.coords) for g in shape]) self.assertEqual( coords, [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
def simulate_patch_sampling(points, size, n=None): '''returns rectangles of given size sampled with centres at given by points''' if not isinstance(points, MultiPoint): points = MultiPoint(asMultiPoint(points)) if isinstance(size, int): w = h = size else: w, h = size return MultiPolygon([CentredRectangle(*np.asarray(p.centroid).tolist(), w,h) \ for p in points[:n]])
def bounds(self): """ return bounding rect of the arc """ # determine all angles pointing in possible extreme directions thetas = [t for t in np.linspace(0, 4*np.pi, 9) if self.start < t < self._end] thetas.append(self.start) thetas.append(self.end) # determine the bounding rect for all these points points = geometry.asMultiPoint(self.get_point(thetas)) bounds = points.bounds return Rectangle.from_points(bounds[:2], bounds[2:])
def _sample_points_(cnt, n_points=None, spacing=None, mode='uniform_random', random_seed=None): '''sample point within an oblong contour with shapely [deprecated] ''' if (n_points is None) and (spacing is None): raise ValueError('either `spacing` or `n_points` must be specified') if isinstance(cnt, Polygon): pg = cnt else: pg = Polygon(cnt) center, sz, angle_ = cv2.minAreaRect(np.asarray(pg.boundary, dtype=int)) w, h = sz if n_points is None: n_points = h * w / spacing**2 pg_rot = rotate(pg, -angle_) x0, y0, x1, y1 = pg_rot.bounds # calculate area ratio and increment number of sampled points accordingly area_ratio = pg_rot.area / Polygon([(x0, y0), (x0, y1), (x1, y1), (x1, y0)]).area n_points = int(np.ceil(n_points / area_ratio)) if mode == 'grid': points_rot = sample_grid(w, h, n_points=n_points, spacing=spacing, angle=angle_) points_rot = points_rot + np.r_[x0, y0] elif mode == 'rotated_grid': points_rot = sample_grid(w, h, n_points=n_points, spacing=spacing) points_rot = points_rot + np.r_[x0, y0] elif mode == 'uniform_random': np.random.seed(random_seed) points_rot = np.random.rand( n_points, 2, ) * np.r_[w, h] + np.r_[x0, y0] else: raise ValueError('unknown mode:%s' % mode) points_rot = MultiPoint(asMultiPoint(points_rot)) points_rot = points_rot.intersection(pg_rot) points = rotate(points_rot, angle_) return points
def viewport_to_shapely_box(viewport): """Convert a Google or OpenCage viewport to a shapely box. Argument viewport: A viewport is a dict of form: {'northeast': {'lat': -33.9806474, 'lng': 150.0169685}, 'southwest': {'lat': -39.18316069999999, 'lng': 140.9616819}} Returns: shapely box """ points = geometry.asMultiPoint([[p['lng'], p['lat']] for p in viewport.values()]) return geometry.box(*points.bounds)
def insert_multipoint(conn, points, test_name='test'): multipoint = asMultiPoint(points) wkb = multipoint.wkb # print(wkb) query = """ INSERT INTO concave (test_name, Geometry) VALUES (?, MPointFromWKB(?, -1)) """ conn.execute(query, (test_name, wkb)) conn.commit()
def np_to_wkb(np_array, in_server): from shapely import wkb np_array = np.array(np_array) if len(np_array.shape) <= 1: #print len(np_array.shape) from shapely.geometry import asPoint np_shapely = asPoint(np_array) else: from shapely.geometry import asMultiPoint np_shapely = asMultiPoint(np_array) return wkb.dumps(np_shapely, hex=in_server)
def np_to_wkb(np_array,in_server): from shapely import wkb np_array = np.array(np_array) if len(np_array.shape)<=1: #print len(np_array.shape) from shapely.geometry import asPoint np_shapely = asPoint(np_array) else: from shapely.geometry import asMultiPoint np_shapely = asMultiPoint(np_array) return wkb.dumps(np_shapely, hex=in_server)
def insert_multipoint(connection, points, test_name='test'): multipoint = asMultiPoint(points) wkb = multipoint.wkb # print(wkb) query = """ INSERT INTO concave (test_name, Geometry) VALUES (%s, ST_GeomFromWKB(%s, -1)) """ with connection.cursor() as cursor: cursor.execute(query, (test_name, wkb)) # print("Size of WKB:", sys.getsizeof(wkb)) connection.commit()
def test_numpy_adapter(self): from numpy import array, asarray from numpy.testing import assert_array_equal # Adapt a Numpy array to a multipoint a = array([[1.0, 2.0], [3.0, 4.0]]) geoma = asMultiPoint(a) assert_array_equal(geoma.context, array([[1., 2.], [3., 4.]])) self.assertEqual(dump_coords(geoma), [[(1.0, 2.0)], [(3.0, 4.0)]]) # Now, the inverse self.assertEqual(geoma.__array_interface__, geoma.context.__array_interface__) pas = asarray(geoma) assert_array_equal(pas, array([[1., 2.], [3., 4.]]))
def points_in_domain(self, domain): ''' Returns a boolean field that identifies the points inside the given domain. Domain: a polygon from shapely.geometry.Polygon ''' idx = (self.lon > -9000) & (self.lat > -9000) traj = geometry.asMultiPoint(list(zip(self.lon[idx], self.lat[idx]))) hits = domain.intersection(traj) if hits.is_empty: return None hits_array = np.array(hits) if np.shape(hits_array) == () or hits_array.ndim == 1: return None idx = np.in1d(self.lat, hits_array[:, 1]) return idx
def points_in_domain(self, domain): ''' Returns a boolean field that identifies the points inside the given domain. Domain: a polygon from shapely.geometry.Polygon ''' idx = (self.lon > -9000) & (self.lat > -9000) traj = geometry.asMultiPoint(list(zip(self.lon[idx], self.lat[idx]))) hits = domain.intersection(traj) if hits.is_empty: return None hits_array = np.array(hits) if np.shape(hits_array)==() or hits_array.ndim==1: return None idx = np.in1d(self.lat, hits_array[:,1]) return idx
def create_shortest_path(line_shp_name, start_node_id, end_node_id): """Calculates the shortest path from a network of lines. Args: line_shp_name (str): Input shapefile name start_node_id (int): Start node ID end_node_id (int): End node ID Returns: None: Creates a graph of nodes (coordinate pairs) connecting a start node with an end node in the defined ``line_shp_name``. """ # load shapefile nx_load_shp = nx.read_shp(line_shp_name) # with not all graphs connected, take the largest connected subgraph by using the connected_component_subgraphs function. nx_list_subgraph = list( nx.connected_component_subgraphs(nx_load_shp.to_undirected()))[0] # get all the nodes in the network nx_nodes = np.array(nx_list_subgraph.nodes()) # output the nodes to a GeoJSON file network_nodes = asMultiPoint(nx_nodes) write_geojson( line_shp_name.split(".shp")[0] + "_nodes.geojson", network_nodes.__geo_interface__) # Compute the shortest path. Dijkstra's algorithm. nx_short_path = nx.shortest_path(nx_list_subgraph, source=tuple(nx_nodes[start_node_id]), target=tuple(nx_nodes[end_node_id]), weight='distance') # create numpy array of coordinates representing result path nx_array_path = get_full_path(nx_short_path, nx_list_subgraph) # convert numpy array to Shapely Linestring shortest_path = asLineString(nx_array_path) write_geojson( line_shp_name.split(".shp")[0] + "_Xpath.geojson", shortest_path.__geo_interface__)
def get_starts(known_wall_points, line, step, min_len): if line.length < min_len: return None ts = 0.0 # TODO: maybe optimize if known_wall_points is not None and len(known_wall_points) > 0: known_wall_points = asMultiPoint(known_wall_points) try_starts = np.arange(0.0, line.length, step / 4) found_start = False for ts in try_starts: if line.interpolate(ts).distance(known_wall_points) > step: found_start = True break if not found_start: return None starts = np.arange(ts, line.length, step) return starts
def line_convex_hull_intersect(line1, points): if type(line1) is sg.LineString: sg_line1 = line1 else: sg_line1 = sg.asLineString(line1) if type(points) is sg.MultiPoint: sg_points = points else: sg_points = sg.asMultiPoint(points) cvhull_poly = sg_points.convex_hull if cvhull_poly.intersects(sg_line1): line_hull_intersect = cvhull_poly.intersection(sg_line1) else: line_hull_intersect = None return line_hull_intersect
def createConvexHull(points,order, clusters,shapefilename): m = len(clusters) point_sets = [[] for i in range(m+1)] for i,id in enumerate(order): p = list(points[id]) p.append(.0) cluster_id = -1 for cluster in clusters: if cluster.start <= i <= cluster.end: cluster_id = cluster.id break point_sets[cluster_id].append(p) convex_hull_set = [] from shapely.geometry import MultiPoint, asMultiPoint for i,point_set in enumerate(point_sets): mp = asMultiPoint(point_set) convex_hull_set.append(mp.convex_hull) shapeType = shapelib.SHPT_POLYGONZ shapeFile = shapelib.create(shapefilename, shapeType) dbfName = shapefilename[:-3]+ 'dbf' dbf = dbflib.create(dbfName) dbf.add_field('ID', dbflib.FTInteger, 50,0) dbf.add_field('Cluster', dbflib.FTInteger, 50,0) for i,convex_hull in enumerate(convex_hull_set): cluster_id = i if cluster_id == m: cluster_id = -1 shapeObject = np.array(convex_hull.exterior) n = len(shapeObject) shapeObject = np.append(shapeObject,[[.0] for j in range(n)],axis=1) shapeObject = [tuple(j) for j in shapeObject] obj = shapelib.SHPObject(shapeType, -1, [shapeObject]) shapeFile.write_object(-1, obj) dbf.write_record(i, {'ID':id,'Cluster':cluster_id}) shapeFile.close() dbf.close()
def _buffer_cluster_layers(self): """ Buffers all points not removed after _remove_veg (or all points of self.remove_veg is set to False) :return: """ from shapely.geometry import asMultiPoint # Subset to only complete layers multi_points = self.points[self.points['bins_z'].isin( self._complete_layers)] keep_bins_z = multi_points["bins_z"].values multi_points = asMultiPoint(multi_points[['x', 'y']].values) buffer_points = gpd.GeoDataFrame( gpd.GeoSeries(multi_points.geoms).buffer(self.buffer_distance)) ## TODO handle for veg removal buffer_points["bins_z"] = keep_bins_z labels = [ item for sublist in self._cluster_all_layers() for item in sublist ] buffer_points["labels"] = labels # Fix some GPD quirks buffer_points = buffer_points.set_geometry(0) buffer_points[0].geom_type = buffer_points.geom_type return (buffer_points)
] print(rec_name_to_array_idx_map) #process each scene in this episode #count # of ep.scenes for sc_i, sc in enumerate(ep.scenes): #print('Processing scene # ', sc_i) polygon_list = [] polygon_z = [] polygons_of_interest_idx_list = [] rec_present = [] for obj in sc.objects: if len(obj.receivers) == 0: continue #do not process objects that are not receivers obj_polygon = geometry.asMultiPoint( obj.vertice_array[:, (0, 1)]).convex_hull # check if object is inside the analysis_area if obj_polygon.within(analysis_polygon): # if the object is a receiver and is within the analysis area if len(obj.receivers) > 0: rec_array_idx = rec_name_to_array_idx_map.index(obj.name) for rec in obj.receivers: #for all receivers ray_i = 0 isLOSChannel = 0 for ray in rec.rays: #for all rays #gather all info thisRayInfo = np.zeros(numVariablePerRay) thisRayInfo[0] = ray.path_gain thisRayInfo[1] = ray.time_of_arrival thisRayInfo[2] = ray.departure_elevation thisRayInfo[3] = ray.departure_azimuth
# grover 40.868393, -104.226126 # Wellington 40.702324, -105.005497 # # buffer 64373.76 # # +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs # # +proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs original = CRS.from_proj4("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs") destination = CRS.from_proj4( "+proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 +lat_2=45.5 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs" ) transprojr = Transformer.from_proj(original, destination) ma = asMultiPoint(np.array([[40.868393, -104.226126], [40.702324, -105.005497]])) out = [] for pt in transprojr.itransform( np.array([[-104.226126, 40.868393], [-105.005497, 40.702324]]) ): print(pt) out.append(pt) print(out) ma = asMultiPoint(out) print(ma) # small_rect = ma.buffer(80467.2).minimum_rotated_rectangle (minx, miny, maxx, maxy) = ma.buffer(80467.2).bounds small_rect = shapely.geometry.box(minx, miny, maxx, maxy) # big_rect = ma.buffer(100000).minimum_rotated_rectangle (minx, miny, maxx, maxy) = ma.buffer(160000).bounds
def test_multipoint_adapter_deprecated(): coords = [[5.0, 6.0], [7.0, 8.0]] with pytest.warns(ShapelyDeprecationWarning, match="proxy geometries"): asMultiPoint(coords)
af = AffinityPropagation(damping=0.9,max_iter=10000,convergence_iter=150,affinity='euclidean').fit(pos_xyz ) cluster_number = af.labels_ cluster_centers_indices = af.cluster_centers_indices_ n_clusters_ = len(cluster_centers_indices) cluster_number = af.labels_ #maintenant on a pour chaque classe la position , et le numero du cluster associé #on va calculer les formes géoémtriques patatoides pour chaque cluster import shapely from shapely.geometry import MultiPoint from shapely.geometry import asMultiPoint mps = [] ;#list de multipoints, séparé par cluster for i in range(0,n_clusters_): mps.append(asMultiPoint(pos_xyz[cluster_number==i])) bb_mps = [] #liste de multipoints double bufferisé (morpho math !) for i in range(0,n_clusters_): bb_mps.append( mps[i].buffer(1.0).buffer(-0.95) ) ###plot madness ! #tracer les patatoides from matplotlib.patches import Polygon from matplotlib import colors; polygons = bb_mps; a_colour_map = cmap.get_cmap('jet') jet = cmap.get_cmap('jet') cNorm = colors.Normalize(vmin=0, vmax= 1 )
def test_multipoint_adapter(self): # Adapt a coordinate list to a line string coords = [[5.0, 6.0], [7.0, 8.0]] geoma = asMultiPoint(coords) self.assertEqual(dump_coords(geoma), [[(5.0, 6.0)], [(7.0, 8.0)]])
# use Networkx to load a Noded shapefile # returns a graph where each node is a coordinate pair # and the edge is the line connecting the two nodes nx_load_shp = nx.read_shp("../geodata/shp/e01_network_lines_3857.shp") # A graph is not always connected, so we take the largest connected subgraph # by using the connected_component_subgraphs function. nx_list_subgraph = list(nx.connected_component_subgraphs(nx_load_shp.to_undirected()))[0] # get all the nodes in the network nx_nodes = np.array(nx_list_subgraph.nodes()) # output the nodes to a GeoJSON file to view in QGIS network_nodes = asMultiPoint(nx_nodes) write_geojson("../geodata/ch08_final_netx_nodes.geojson", network_nodes.__geo_interface__ ) # this number represents the nodes position # in the array to identify the node start_node_pos = 30 end_node_pos = 21 # Compute the shortest path. Dijkstra's algorithm. nx_short_path = nx.shortest_path(nx_list_subgraph, source=tuple(nx_nodes[start_node_pos]), target=tuple(nx_nodes[end_node_pos]), weight='distance')
nturns -= 1 else: heading = nturns * np.pi / 3 points.append(points[-1] + [np.cos(heading), np.sin(heading)]) # Create curve geometry. curve = geometry.LineString(points) # Create exterior of coaster. exterior = curve.envelope.buffer(1).exterior # Connect curve to exterior. for _ in range(2): proj = exterior.interpolate(exterior.project(geometry.Point(points[0]))) points = points[::-1] + [proj] i = np.argmin([pt.distance(proj) for pt in geometry.asMultiPoint(exterior)]) points += exterior.coords[i:] points += exterior.coords[:i + 1] # Determine bounding box for artwork. minx, miny, maxx, maxy = exterior.bounds pad = 1 minx -= pad maxx += pad miny -= pad maxy += pad width = maxx - minx height = maxy - miny # Write SVG document. print('<svg xmlns="http://www.w3.org/2000/svg"')
def operation_example(): patch = Point(0.0, 0.0).buffer(10.0) print('patch = {}.'.format(patch)) print('patch.area = {}.'.format(patch.area)) line = LineString([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)]) dilated = line.buffer(0.5) eroded = dilated.buffer(-0.3) ring = LinearRing([(0, 0), (1, 1), (1, 0)]) point = Point(0.5, 0.5) polygon = Polygon([(0, 0), (0, 1), (1, 1), (1, 0)]) print('polygon.contains(point) = {}.'.format(polygon.contains(point))) #box = shapely.geometry.box(minx, miny, maxx, maxy, ccw=True) pa = asPoint(np.array([0.0, 0.0])) la = asLineString(np.array([[1.0, 2.0], [3.0, 4.0]])) ma = asMultiPoint(np.array([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])) data = {'type': 'Point', 'coordinates': (0.0, 0.0)} geom = shapely.geometry.shape(data) #geom = shapely.geometry.asShape(data) #-------------------- #geom = Polygon([(0, 0), (0, 1), (1, 1), (1, 0)]) geom = LineString([(0, 0), (10, 0), (10, 5), (20, 5)]) print('polygon.has_z = {}.'.format(geom.has_z)) if isinstance(geom, LinearRing): print('polygon.is_ccw = {}.'.format(geom.is_ccw)) # LinearRing only. print('polygon.is_empty = {}.'.format(geom.is_empty)) print('polygon.is_ring = {}.'.format(geom.is_ring)) print('polygon.is_simple = {}.'.format(geom.is_simple)) print('polygon.is_valid = {}.'.format(geom.is_valid)) print('polygon.coords = {}.'.format(geom.coords)) print('polygon.area = {}.'.format(geom.area)) print('polygon.bounds = {}.'.format(geom.bounds)) print('polygon.length = {}.'.format(geom.length)) print('polygon.minimum_clearance = {}.'.format(geom.minimum_clearance)) print('polygon.geom_type = {}.'.format(geom.geom_type)) print('polygon.boundary = {}.'.format(geom.boundary)) print('polygon.centroid = {}.'.format(geom.centroid)) print('polygon.convex_hull.exterior.coords.xy = {}.'.format(list((x, y) for x, y in zip(*geom.convex_hull.exterior.coords.xy)))) print('polygon.envelope = {}.'.format(geom.envelope)) print('polygon.minimum_rotated_rectangle = {}.'.format(geom.minimum_rotated_rectangle)) #polygon.parallel_offset(distance, side, resolution=16, join_style=1, mitre_limit=5.0) #polygon.simplify(tolerance, preserve_topology=True) #-------------------- poly1 = Polygon([(3, 3), (5, 3), (5, 5), (3, 5)]) poly2 = Polygon([(1, 1), (4, 1), (4, 3.5), (1, 3.5)]) print('poly1.intersection(poly2) = {}.'.format(poly1.intersection(poly2))) print('poly1.difference(poly2) = {}.'.format(poly1.difference(poly2))) print('poly1.symmetric_difference(poly2) = {}.'.format(poly1.symmetric_difference(poly2))) print('poly1.union(poly2) = {}.'.format(poly1.union(poly2))) print('poly1.equals(poly2) = {}.'.format(poly1.equals(poly2))) print('poly1.almost_equals(poly2, decimal=6) = {}.'.format(poly1.almost_equals(poly2, decimal=6))) print('poly1.contains(poly2) = {}.'.format(poly1.contains(poly2))) print('poly1.covers(poly2) = {}.'.format(poly1.covers(poly2))) print('poly1.crosses(poly2) = {}.'.format(poly1.crosses(poly2))) print('poly1.disjoint(poly2) = {}.'.format(poly1.disjoint(poly2))) print('poly1.intersects(poly2) = {}.'.format(poly1.intersects(poly2))) print('poly1.overlaps(poly2) = {}.'.format(poly1.overlaps(poly2))) print('poly1.touches(poly2) = {}.'.format(poly1.touches(poly2))) print('poly1.within(poly2) = {}.'.format(poly1.within(poly2))) #-------------------- poly1 = Polygon([(40, 50), (60, 50), (60, 90), (40, 90)]) poly2 = Polygon([(10, 100), (100, 100), (100, 150), (10, 150)]) print('The distance between two convex polygons = {}.'.format(poly1.distance(poly2))) print('The Hausdorff distance between two convex polygons = {}.'.format(poly1.hausdorff_distance(poly2))) print('The representative point of a polygon = {}.'.format(poly1.representative_point())) #-------------------- lines = [ ((0, 0), (1, 1)), ((0, 0), (0, 1)), ((0, 1), (1, 1)), ((1, 1), (1, 0)), ((1, 0), (0, 0)), ((1, 1), (2, 0)), ((2, 0), (1, 0)), ((5, 5), (6, 6)), ((1, 1), (100, 100)), ] polys = shapely.ops.polygonize(lines) result, dangles, cuts, invalids = shapely.ops.polygonize_full(lines) merged_line = shapely.ops.linemerge(lines) # Efficient unions. polygons = [Point(i, 0).buffer(0.7) for i in range(5)] shapely.ops.unary_union(polygons) shapely.ops.cascaded_union(polygons) # Delaunay triangulation. points = MultiPoint([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)]) triangles = shapely.ops.triangulate(points) # Voronoi diagram. #points = MultiPoint([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)]) #regions = shapely.ops.voronoi_diagram(points) # Nearest points. triangle = Polygon([(0, 0), (1, 0), (0.5, 1), (0, 0)]) square = Polygon([(0, 2), (1, 2), (1, 3), (0, 3), (0, 2)]) nearest_points = shapely.ops.nearest_points(triangle, square) square = Polygon([(1,1), (2, 1), (2, 2), (1, 2), (1, 1)]) line = LineString([(0,0), (0.8, 0.8), (1.8, 0.95), (2.6, 0.5)]) result = shapely.ops.snap(line, square, 0.5) g1 = LineString([(0, 0), (10, 0), (10, 5), (20, 5)]) g2 = LineString([(5, 0), (30, 0), (30, 5), (0, 5)]) forward, backward = shapely.ops.shared_paths(g1, g2) pt = Point((1, 1)) line = LineString([(0, 0), (2, 2)]) result = shapely.ops.split(line, pt) ls = LineString((i, 0) for i in range(6)) shapely.ops.substring(ls, start_dist=1, end_dist=3) shapely.ops.substring(ls, start_dist=3, end_dist=1) shapely.ops.substring(ls, start_dist=1, end_dist=-3) shapely.ops.substring(ls, start_dist=0.2, end_dist=-0.6, normalized=True)
# y_offset = -26.6000003815 x_offset = 0 y_offset = 0 # for i in range(len(contours)): res = 0.05 for i in range(len(ver)): ver[i] = (ver[i][0] / res + x_offset, ver[i][1] / res + y_offset) # ver[i] = (ver[i][0], ver[i][1]) ver = np.array(ver) # plt.scatter((ver[:, 0]), (ver[:, 1])) # plt.imshow(gray) # # plt.show() # ver = np.array(sorted(ver, key=lambda row: row[0])) vr = asMultiPoint(ver) for i in range(len(corners)): if i in [11, 14, 25, 28, 52, 53, 54, 0, 45, 44, 49, 50, 63]: corners[i] = [0, 0] # corners = np.array([x for (k,x) in enumerate(corners) if k not in [11,14,25, 28, 52, 53, 54, 0, 45, 44, 49, 50, 63 ]]) segms2, idc, v3 = [], [], [] # for i in range(len(corners)-1): p = [[31, 27], [27, 8], [27, 30], [8, 7], [7, 29], [29, 13], [13, 12], [12, 3], [3, 4], [4, 24], [24, 21], [21, 22], [21, 5], [5, 6], [6, 17], [17, 18], [18, 1], [1, 2], [2, 19], [19, 15], [15, 20], [15, 9], [9, 10], [10, 16], [16, 23], [23, 37], [37, 42], [42, 32], [32, 33], [33, 35], [33, 51], [51, 56], [56, 36], [36, 38], [38, 57], [38, 39], [57, 58], [58, 43], [43, 41], [43, 46], [46, 47], [46, 59], [59, 60], [60, 48], [48, 55], [55, 61], [61, 62], [62, 31]] # poli = [] #
def joiner(self, data): """ Entry point for the class Join. This function identiefs junctions (intersection points) of shared paths. The join function is the second step in the topology computation. The following sequence is adopted: 1. extract 2. join 3. cut 4. dedup 5. hashmap Detects the junctions of shared paths from the specified hash of linestrings. After decomposing all geometric objects into linestrings it is necessary to detect the junctions or start and end-points of shared paths so these paths can be 'merged' in the next step. Merge is quoted as in fact only one of the shared path is kept and the other path is removed. Parameters ---------- data : dict object created by the method topojson.extract. quant_factor : int, optional (default: None) quantization factor, used to constrain float numbers to integer values. - Use 1e4 for 5 valued values (00001-99999) - Use 1e6 for 7 valued values (0000001-9999999) Returns ------- dict object expanded with - new key: junctions - new key: transform (if quant_factor is not None) """ # presimplify linestrings if required if self.options.presimplify > 0: # set default if not specifically given in the options if type(self.options.presimplify) == bool: simplify_factor = 2 else: simplify_factor = self.options.presimplify data["linestrings"] = simplify( data["linestrings"], simplify_factor, algorithm=self.options.simplify_algorithm, package=self.options.simplify_with, input_as="linestring", ) # compute the bounding box of input geometry lsbs = geometry.asMultiLineString(data["linestrings"]).bounds ptbs = geometry.asMultiPoint(data["coordinates"]).bounds data["bbox"] = compare_bounds(lsbs, ptbs) # prequantize linestrings if required if self.options.prequantize > 0: # set default if not specifically given in the options if type(self.options.prequantize) == bool: quant_factor = 1e6 else: quant_factor = self.options.prequantize data["linestrings"], data["transform"] = quantize( data["linestrings"], data["bbox"], quant_factor) data["coordinates"], data["transform"] = quantize( data["coordinates"], data["bbox"], quant_factor) if not self.options.topology or not data["linestrings"]: data["junctions"] = self.junctions return data if self.options.shared_paths == "coords": def _get_verts(geom): # get coords of each LineString return [x for x in geom.coords] geoms = {} junctions = [] for ls in data["linestrings"]: verts = _get_verts(ls) for i, vert in enumerate(verts): ran = geoms.pop(vert, None) neighs = sorted([ verts[i - 1], verts[i + 1 if i < len(verts) - 1 else 0] ]) if ran and ran != neighs: junctions.append(vert) geoms[vert] = neighs self.junctions = [geometry.Point(xy) for xy in set(junctions)] else: # create list with unique combinations of lines using a rdtree line_combs = select_unique_combs(data["linestrings"]) # iterate over index combinations for i1, i2 in line_combs: g1 = data["linestrings"][i1] g2 = data["linestrings"][i2] # check if geometry are equal # being equal meaning the geometry object coincide with each other. # a rotated polygon or reversed linestring are both considered equal. if not g1.equals(g2): # geoms are unique, let's find junctions self.shared_segs(g1, g2) # self.segments are nested lists of LineStrings, get coordinates of each nest s_coords = [] for segment in self.segments: s_coords.extend([[(x.xy[0][y], x.xy[1][y]) for x in segment for y in range(len(x.xy[0]))]]) # s_coords.extend([[y for x in segment for y in list(x.coords)]]) # only keep junctions that appear only once in each segment (nested list) # coordinates that appear multiple times are not junctions for coords in s_coords: self.junctions.extend([ geometry.Point(i) for i in coords if coords.count(i) == 1 ]) # junctions can appear multiple times in multiple segments, remove duplicates self.junctions = [ loads(xy) for xy in list(set([x.wkb for x in self.junctions])) ] # prepare to return object data["junctions"] = self.junctions return data
def as_polygon(self, axis=(0, 1)): if geometry is None: raise NotImplementedError('shapely module was not found') return geometry.asMultiPoint(self.as_vertice_array()[:, axis]).convex_hull
def maybe_as_multipoint(points: Union[np.ndarray, MultiPoint]) -> MultiPoint: if isinstance(points, np.ndarray): points = asMultiPoint(points) return points
def _xyz_to_wkt(xyz): '''Converts the xy of the xyz into a wkt MultiPoint format''' return asMultiPoint(xyz[:, :-1]).wkt