def test_calculate_angle(): a = Point(0, 0) b = Point(1, 1) c = Point(2, 0) angle = calculate_angle(a, b, c) assert np.isclose(angle, 90.0)
def circle_sensor(SensorName, Sensor_coord, r=1): """ SensorName : nom du(des) sensor(s) souhaité(s), Sensor_coord : résultat de la fonction reading_gps_file r : rayon en metre, 1.00 m par défaut Output : list_coord_circle = list des coordonnes des extremites de chaque cercle Shape_to_json = list Proprietes geometriques de chaque cercle circle_name = list de noms des sensors """ list_coord_circle = [] Shape_to_json = [] circle_name = [] for SensorName in SensorName: sensor_GPS = Sensor_coord.loc[Sensor_coord['SensorName'] == str( SensorName)] center = Point(sensor_GPS["x"], sensor_GPS["y"]) # point central circle = center.buffer(r) x_circle, y_circle = circle.exterior.xy #Val de chaque extremitees du cercle list_coord_circle.append([np.array(x_circle), np.array(y_circle)]) # Transfo des donnees en Geoseries : #Json -> https://fr.wikipedia.org/wiki/JavaScript_Object_Notation # Format qui contient toutes les proprietes + points ext du cercle Shape_to_json.append(gpd.GeoSeries([circle]).to_json()) circle_name.append(sensor_GPS['SensorName']) return list_coord_circle, Shape_to_json, circle_name
def test_get_intersects_select_nearest(self): pt = Point(-99, 39) return_indices = [True, False] use_spatial_index = [True, False] select_nearest = [True, False] abstraction = ['polygon', 'point'] bounds = [True, False] for args in itertools.product(return_indices, use_spatial_index, select_nearest, abstraction, bounds): ri, usi, sn, a, b = args sdim = self.get_sdim(bounds=b) sdim.abstraction = a ret = sdim.get_intersects(pt.buffer(1), select_nearest=sn, return_indices=ri) ## return_indice will return a tuple if True if ri: ret, ret_slc = ret if sn: ## select_nearest=True always returns a single element self.assertEqual(ret.shape, (1, 1)) try: self.assertTrue(ret.geom.polygon.value[0,0].centroid.almost_equals(pt)) ## polygons will not be present if the abstraction is point or there are no bounds on the created ## spatial dimension object except ImproperPolygonBoundsError: if a == 'point' or b is False: self.assertTrue(ret.geom.point.value[0, 0].almost_equals(pt)) else: raise ## if we are not returning the nearest geometry... else: ## bounds with a spatial abstraction of polygon will have this dimension if b and a == 'polygon': self.assertEqual(ret.shape, (3, 3)) ## with points, there is only intersecting geometry else: self.assertEqual(ret.shape, (1, 1))
def calc_distance_and_angle(p: LocationLocal, ref_p: LocationLocal, rel_angle=0): # if type(p) is LocationGlobal or LocationGlobalRelative: # p = latlon_to_xy() p = Point(p.east, p.north) ref_p = Point(ref_p.east, ref_p.north) # transform to local coordinates p_local = affine_transform(p, [1,0,0,1, -ref_p.x, -ref_p.y]) # alpha = -90 # plus 90 so north is a heading of 0 degrees.With shapely positive rotations are counter clockwise # p_local = rotate(p_local, alpha, origin=(0,0)) # take into account the relative angle of the plane # # convert to polar coordinates # distance = math.sqrt(pow(p.x - ref_p.x, 2) + pow(p.y - ref_p.y, 2)) # angle = math.atan((p.x - ref_p.x) / (p.y - ref_p.y)) (distance, angle) = cmath.polar(complex(p_local.x, p_local.y)) # angle is in radians # convert to degrees and change axis # +90 to set north to heading 0 angle = 90 - math.degrees(angle) - rel_angle # only positive angles if angle < 0: angle+=360 # only angles under 360 if angle > 360: angle-=360 return (distance, angle)
def match_shapes(self, shapes, buffer=0.01): """ checks if shapes are completely within each others buffers, aggregates routes for these :return: """ # buffer for spatial self join first_points = shapes["geometry"].apply(lambda x: Point(x.coords[0])) last_points = shapes["geometry"].apply(lambda x: Point(x.coords[-1])) points = pd.concat([first_points, last_points]) point_df = points.to_frame(name='geometry') #point_df = point_df.set_geometry(point_df["geometry"], crs=self.crs_eurefin) point_df = point_df.set_geometry(point_df["geometry"], crs=self.crs_wgs) #buffer = point_df.buffer(30) #buffer = GeoDataFrame(crs=self.crs_eurefin, geometry=point_df.buffer(buffer)) buffer = GeoDataFrame(crs=self.crs_wgs, geometry=point_df.buffer(buffer)) buffer["everything"] = 1 gdf_poly = buffer.dissolve(by="everything") polygons = None for geoms in gdf_poly["geometry"]: polygons = [polygon for polygon in geoms] #single_parts = GeoDataFrame(crs=self.crs_eurefin, geometry=polygons) single_parts = GeoDataFrame(crs=self.crs_wgs, geometry=polygons) single_parts['new_stop_I'] = single_parts.index gdf_joined = sjoin(shapes, single_parts, how="left", op='within') return gdf_joined
def contains(x1, y1, x2, y2, radius, origin1=WGS84, origin2=WGS84, destination=PA_SP_SOUTH): ''' :param x: x coordinate or longitude :param y: y coordiante or latitude :param radius: radius in miles :param projection: :return: ''' # project input x1,y1 to PA state plane try: x, y = pyproj.transform(pyproj.Proj(origin1), pyproj.Proj(destination, preserve_units=True), x1, y1) # get circle from first input p = Point(x, y) circle = p.buffer(radius * MILES) # project x2, y2 to same plane x, y = pyproj.transform(pyproj.Proj(origin2), pyproj.Proj(destination, preserve_units=True), x2, y2) p = Point(x, y) return circle.contains(p) except: return False
def IsArcStrictIntersectPoly(arc, poly): # First check if two points in it is in poly. # Touching is OK. if poly.contains(Point(*arc.AngleToPoint(arc.MidAngle()))): return True # Then, check if arc intersect any of the poly's boundaries. intersections = CirclePolygonIntersections(arc, poly) # Now, classify the intersections that belongs to the arcs (including boundaries) angles = [] for intersection in intersections: if arc.IsPointOnArcOrOnArcBoundary(intersection): angles.append(arc.PointToAngle(intersection)) angles.append(arc._begin_radian) angles.append(arc._end_radian) angles.sort( key=lambda angle: (angle - arc._begin_radian) % (math.pi * 2.0)) for p1, p2 in zip(angles, angles[1:]): if abs(p1 - p2) <= EPS: continue dist = (p2 - p1) % (math.pi * 2.0) midangle = (p1 + dist / 2.0) % (math.pi * 2.0) point = arc.AngleToPoint(midangle) if poly.contains(Point(point[0], point[1])): return True return False
def gen_poly3(x1, x2, x3, y1, y2, y3): # roundabout poly1 = Polygon( ((0, 0), (0, (y1 + y2 + y3) / 2 - y2), ((x1 + x2 + x3) / 2 - y2 * 3, (y1 + y2 + y3) / 2 - y2), ((x1 + x2 + x3) / 2 - x2, (y1 + y2 + y3) / 2 - y2 * 3), ((x1 + x2 + x3) / 2 - x2, 0))) poly2 = Polygon(((0, (y1 + y2 + y3) / 2 + y2), (0, y1 + y2 + y3), ((x1 + x2 + x3) / 2 - x2, y1 + y2 + y3), ((x1 + x2 + x3) / 2 - x2, (y1 + y2 + y3) / 2 + y2 * 3), ((x1 + x2 + x3) / 2 - y2 * 3, (y1 + y2 + y3) / 2 + y2))) poly3 = Polygon( (((x1 + x2 + x3) / 2 + x2, 0), ((x1 + x2 + x3) / 2 + x2, (y1 + y2 + y3) / 2 - y2 * 3), ((x1 + x2 + x3) / 2 + y2 * 3, (y1 + y2 + y3) / 2 - y2), (x1 + x2 + x3, (y1 + y2 + y3) / 2 - y2), (x1 + x2 + x3, 0))) poly4 = Polygon( (((x1 + x2 + x3) / 2 + y2 * 3, (y1 + y2 + y3) / 2 + y2), ((x1 + x2 + x3) / 2 + x2, (y1 + y2 + y3) / 2 + y2 * 3), ((x1 + x2 + x3) / 2 + x2, y1 + y2 + y3), (x1 + x2 + x3, y1 + y2 + y3), (x1 + x2 + x3, (y1 + y2 + y3) / 2 + y2))) p = Point((x1 + x2 + x3) / 2, (y1 + y2 + y3) / 2) circle = p.buffer(y2) polyc = list(circle.exterior.coords) poly5 = Polygon(polyc) polys = [poly1, poly2, poly3, poly4, poly5] return gp.GeoDataFrame(geometry=polys)
def intersects(self, polygon): ## do the initial grid subset grid = self.grid.subset(polygon=polygon) ## a prepared polygon prep_polygon = prepared.prep(polygon) ## the fill arrays geom = np.ones(grid.shape, dtype=object) geom = np.ma.array(geom, mask=True) geom_mask = geom.mask try: row = grid.row.value col = grid.column.value for ii, jj in product(range(row.shape[0]), range(col.shape[0])): pt = Point(col[jj], row[ii]) geom[ii, jj] = pt if prep_polygon.intersects(pt): geom_mask[ii, jj] = False else: geom_mask[ii, jj] = True ## NcGridMatrixDimension correction except AttributeError: _row = grid.row _col = grid.column for ii, jj in iter_array(_row): pt = Point(_col[ii, jj], _row[ii, jj]) geom[ii, jj] = pt if prep_polygon.intersects(pt): geom_mask[ii, jj] = False else: geom_mask[ii, jj] = True ret = self.__class__(grid=grid, geom=geom, uid=grid.uid) return (ret)
def draw_xg_circle (fig, ax, distance_x,distance_y,radius,color, e_color): p = Point(distance_x,distance_y) circle = p.buffer(radius) x,y = circle.exterior.xy x = np.array(x) / 1.05 y = np.array(y) / 0.6 ax.fill(x, y, alpha=0.5, fc=color, ec=e_color) return
def _choose_lilly_pad_position(self, pad_radius): min_x, min_y, max_x, max_y = self.pond.circle.get_bounds() while True: x = random.uniform(min_x, max_x) y = random.uniform(min_y, max_y) pad = Circle(Point(x, y), pad_radius) if self.pond.lilly_pad_in_pond(pad) and not self._is_overlapping_current_lilly_pads(pad): return Point(x, y)
def flowbandwidth(flowline1, flowline2, offsets): widths = np.empty(0) for i, pt in enumerate(flowline1.x): widths = np.append( widths, Point(flowline1.x[i], flowline1.y[i]).distance( Point(flowline2.x[i], flowline2.y[i]))) return widths
def iou(params0, params1): row0, col0, rad0 = params0 row1, col1, rad1 = params1 shape0 = Point(row0, col0).buffer(rad0) shape1 = Point(row1, col1).buffer(rad1) return (shape0.intersection(shape1).area / shape0.union(shape1).area)
def create_base_stations_points(centers, radius): Bx = [] for center in centers: point = Point(center[0], center[1]) circle = point.buffer(radius) Bx.append(circle) return Bx
def calculate_fitness(worm, radius, city): circles = [] for center in worm: point = Point(center[0], center[1]) circles.append(point.buffer(radius)) base_stations_polygon = cascaded_union(circles) intersection_area = base_stations_polygon.intersection(city).area return base_stations_polygon.intersection(city).area / city.area
def test_move_to_lilly_pad_calls_lilly_pad_visit_method(self): # arrange mock_pad = mock.create_autospec(LillyPad) mock_pad.circle = Circle(Point(0, 0), 3) position = Point(2, 2) frog = Frog(position, 1, 0) # act frog._move_to_lilly_pad(mock_pad) # assert assert mock_pad.visit.called
def test_move_to_lilly_pad_updates_frog_current_lilly_pad(self): # arrange mock_pad = mock.create_autospec(LillyPad) mock_pad.circle = Circle(Point(0, 0), 3) position = Point(2, 2) frog = Frog(position, 1, 0) # act frog._move_to_lilly_pad(mock_pad) # assert assert frog.current_lilly_pad == mock_pad
def test_find_possible_pads_returns_no_pads_if_nearby_pad_occupied(self): # arrange position = Point(2, 2) frog = Frog(position, 5, 0) pad = LillyPad(Point(2, 4), 1) pad.currently_occupied = True # act possible_pads = frog._find_possible_lilly_pads([pad]) # assert assert len(possible_pads) == 0
def test_find_possible_lilly_pads_returns_empty_list_when_none_are_available( self): # arrange position = Point(20, 20) frog = Frog(position, 1, 0) pad = LillyPad(Point(2, 4), 1) # act possible_pads = frog._find_possible_lilly_pads([pad]) # assert assert len(possible_pads) == 0
def test_find_possible_lilly_pads_returns_list_of_lilly_pads_when_some_are_available( self): # arrange position = Point(2, 2) frog = Frog(position, 1, 0) pad = LillyPad(Point(2, 4), 1) # act possible_pads = frog._find_possible_lilly_pads([pad]) # assert assert pad in possible_pads
def get_egocentric_spatial_relation_pivot(self, ref_point: Point, route: GeoDataFrame) -> str: line = LineString(route['geometry'].tolist()) dist_projected = line.project(ref_point) cut_geometry = util.cut(line, dist_projected) first_segment = cut_geometry[0] coords = list(first_segment.coords) return self.calc_spatial_relation_for_line(ref_point, Point(coords[-1]), Point(coords[-2]))
def geo_valid(self, json_input): """ In order to make a guess at MoT we have to have OSM data. geoms is a list of geometries (closed polygons) that define the regions of validity of this model. This function returns a list of visit id's that are valid TODO: If we don't specify a lat and lon, go look this up. :param visits: A list of dictionaries containing a lat, a lon and a visit id :param CONFIG: The parsed config file :return: Will output a list of visits that are within the regions of validity """ # geoms = read_geo_valid(CONFIG) p = pd.DataFrame(json_input) p = p[p['mot'] == 'train'] if p.empty: logging.debug('No train journey within json') return [], [] # Is within region of geovalidity is_within = p.apply(lambda x: np.all([ geom.contains(Point(x['start_lon'], x['start_lat'])) and geom. contains(Point(x['end_lon'], x['end_lat'])) for geom in self.geoms ]), axis=1).values # is greater than the min distance is_gt_min_dist = p.apply(lambda x: vincenty( (x['start_lat'], x['start_lon']), (x['end_lat'], x['end_lon'])).meters > CONFIG.getint( 'geovalidity', 'MIN_DIST_BTW_PTS'), axis=1).values # If trips need to be discarded, log in in the failed trips table if any(~is_within) or any(~is_gt_min_dist): p['failure_cause'] = '' p['datetime_created'] = datetime.utcnow() error_msg = 'Not within region of geo-validity ({}). ' p.loc[~is_within, 'failure_cause'] += error_msg.format( CONFIG.get('geovalidity', 'VALID_REGION_WKT')) error_msg = 'Start and end point of MoT segment too close (within {} meters of each-other). ' p.loc[~is_gt_min_dist, 'failure_cause'] += error_msg.format( CONFIG.getint('geovalidity', 'MIN_DIST_BTW_PTS')) col_list = [ 'mot_segment_id', 'failure_cause', 'datetime_created', 'bound_from_id', 'bound_to_id' ] failed_trips = p.loc[p['failure_cause'] != '', col_list] update_postgres(failed_trips, 'train_trips_failed', DB) mask = np.logical_and(is_within, is_gt_min_dist) loc_bounds = p.loc[mask, ['mot_segment_id', 'bound_from_id', 'bound_to_id']] return p.loc[mask, 'mot_segment_id'].tolist(), loc_bounds
def test_create_line_from_points(self): geo_point_1 = Point(0.0, 0.0) geo_point_2 = Point(1.0, 1.0) expected_line = LineString([ [0.0, 0.0], [1.0, 1.0], ]) geo_line = geo_fields.GeoLine.from_points(self.env.cr, geo_point_1, geo_point_2) self.assertEqual(geo_line, expected_line)
def is_square(test_geom): if isinstance(test_geom, Polygon): if len(test_geom.exterior.coords) is 5: x_pts, y_pts = test_geom.exterior.coords.xy perimeter = zip(x_pts, y_pts) len_sides = [] for i in range(len(perimeter)): len_sides.append(Point(perimeter[i]).distance(Point(perimeter[i-1]))) len_sides.remove(0.0) if len(set(len_sides)) <= 1: #print(">>> SQUARE: "+ str(perimeter)+ " | SIDES: " + str(len_sides)) return True
def test_move_to_lilly_pad_calls_leave_on_current_lilly_pad(self): # arrange mock_current_pad = mock.create_autospec(LillyPad) mock_dest_pad = mock.create_autospec(LillyPad) mock_dest_pad.circle = Circle(Point(0, 0), 3) position = Point(2, 2) frog = Frog(position, 1, 0) frog.current_lilly_pad = mock_current_pad # act frog._move_to_lilly_pad(mock_dest_pad) # assert assert mock_current_pad.leave.called
def find_stations_in_geometry(shape, contour_dist=0, start_date=None, end_date=None): stations = Station.get_stations(start_date, end_date) # For performance purposes, find a cutoff distance beyond which stations are ignored center = shape.centroid hull_points = [ Point(x, y) for x, y in zip(*shape.convex_hull.exterior.xy) ] furthest_point = max(hull_points, key=lambda x: center.distance(x)) max_dist = Station.distance(center.y, center.x, furthest_point.y, furthest_point.x) max_dist += contour_dist # Evaluate the distance with all stations shapes = shape if shape.geom_type == 'MultiPolygon' else [shape] distances = [] for station in stations: # First get an approximate distance from the centroid distance_approx = station.distance_from(center.y, center.x) if distance_approx > max_dist: distances.append(None) continue # Points inside the borders have a distance of 0 station_point = Point(station.longitude, station.latitude) if any(sub_shape.contains(station_point) for sub_shape in shapes): distances.append(0) continue # Otherwise, evaluate the real distance from the region borders distance = 99999 for sub_shape in shapes: exterior = sub_shape.exterior projection = exterior.interpolate( exterior.project(station_point)) distance = min( distance, station.distance_from(projection.y, projection.x)) distances.append(distance if distance < contour_dist else None) distances = np.array(distances) # Sort stations based on their distance closest = [(station, distance) for station, distance in zip(stations, distances) if distance is not None] closest.sort(key=lambda x: x[1]) # Return the sorted stations and distances return closest
def test_selecting_single_value(self): rd = self.test_data.get_rd('cancm4_tas') lat_index = 32 lon_index = 97 with nc_scope(rd.uri) as ds: lat_value = ds.variables['lat'][lat_index] lon_value = ds.variables['lon'][lon_index] data_values = ds.variables['tas'][:, lat_index, lon_index] ops = ocgis.OcgOperations(dataset=rd, geom=[lon_value, lat_value]) ret = ops.execute() actual = ret.get_element(variable_name='tas').get_masked_value() values = np.squeeze(actual) self.assertNumpyAll(data_values, values.data) self.assertFalse(np.any(values.mask)) geom = Point(lon_value, lat_value).buffer(0.001) ops = ocgis.OcgOperations(dataset=rd, geom=geom) ret = ops.execute() actual = ret.get_element(variable_name='tas').get_masked_value() values = np.squeeze(actual) self.assertNumpyAll(data_values, values.data) self.assertFalse(np.any(values.mask)) geom = Point(lon_value - 360., lat_value).buffer(0.001) ops = ocgis.OcgOperations(dataset=rd, geom=geom) ret = ops.execute() actual = ret.get_element(variable_name='tas').get_masked_value() values = np.squeeze(actual) self.assertNumpyAll(data_values, values.data) self.assertFalse(np.any(values.mask)) geom = Point(lon_value - 360., lat_value).buffer(0.001) ops = ocgis.OcgOperations(dataset=rd, geom=geom, aggregate=True, spatial_operation='clip') ret = ops.execute() actual = ret.get_element(variable_name='tas').get_masked_value() values = np.squeeze(actual) self.assertNumpyAll(data_values, values.data) self.assertFalse(np.any(values.mask)) ops = ocgis.OcgOperations(dataset=rd, geom=[lon_value, lat_value], search_radius_mult=0.1, output_format='nc') ret = ops.execute() with nc_scope(ret) as ds: values = np.squeeze(ds.variables['tas'][:]) self.assertNumpyAll(data_values, values)
def test_halve_line(line): """There should be - two lines returned - they should be of equal length - The last point in the first half should match the first point in the second half - The midpoint should intersect the original line """ halves = split_line(line) assert len(halves) == 2 assert np.allclose(halves[0].length, halves[1].length) midpoint = Point(halves[0].coords[-1]) assert midpoint == Point(halves[1].coords[0]) assert midpoint.buffer(.00000001).intersects(line)
def get_bbox_from_url(wms_url): """ Parses wms url for BBOX parameter an returns these points as suitable values for ViewServiceRecord. Args: wms_url (str): wms url which includes a BBOX parameter to parse. Returns: set of two shapely.geometry.point.Point: min and max coordinates of bounding box. """ _, params = parse_url(wms_url) bbox = params.get('BBOX') if bbox is None or len(bbox[0].split(',')) != 4: return None, None points = bbox[0].split(',') return Point(float(points[0]), float(points[1])), Point(float(points[2]), float(points[3]))
def get_linestring_distance(line: LineString) -> int: '''Calculate the line length in meters. Arguments: route: The line that length calculation will be performed on. Returns: Line length in meters. ''' dist = 0 point_1 = Point(line.coords[0]) for coord in line.coords[1:]: point_2 = Point(coord) dist += get_distance_between_points(point_1, point_2) point_1 = point_2 return dist
def get_line_length(line: LineString) -> float: '''Calculate the length of a line in meters. Arguments: line: The line to calculate its length. Returns: The length of the line in meters ''' dist = 0 point_1 = Point(line.coords[0]) for coord in line.coords[1:]: point_2 = Point(coord) dist += get_distance_between_points(point_1, point_2) point_1 = point_2 return dist
def __init__(self, coords, groups, velocity, angle): super().__init__(*groups) self.image = load_image('enemy_bullet.png') self.image = pygame.transform.scale(self.image, (4, 4)) self.rect = self.image.get_rect().move(*coords) self.velocity, self.angle = velocity, angle self.hitbox = Point(coords[0] + 2, coords[1] + 2).buffer(2.0)
def CircleLineSegmentIntersections(circle, segment): center = Point(circle.center[0], circle.center[1]) distance = segment.distance(center) if distance > circle.radius + EPS: return [] super_point = ShortestToLine(segment, circle.center) super_point_p = Point(super_point[0], super_point[1]) orig_point = segment.coords[0] dest_point = segment.coords[1] dist = Point(orig_point[0], orig_point[1]).distance(super_point_p) if ((dest_point[0] - orig_point[0]) * (orig_point[0] - super_point[0]) >= 0 and (dest_point[1] - orig_point[1]) * (orig_point[1] - super_point[1]) >= 0): dist *= -1 distance = center.distance(super_point_p) if distance > circle.radius + EPS: return [] val = circle.radius**2 - distance**2 if val < 0: val = 0 front_side = math.sqrt(val) intersections = [] for i in range(-1, 2, 2): if i == 1 and front_side < EPS: break new_dist = dist + front_side * i if new_dist < -EPS or new_dist > segment.length + EPS: continue intersection_point = segment.interpolate(new_dist) intersections.append([intersection_point.x, intersection_point.y]) return intersections
def main(): spatialReference = osr.SpatialReference() spatialReference.ImportFromProj4('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs') driver = ogr.GetDriverByName("ESRI Shapefile") shp_dir = "praries_basins" shutil.rmtree(shp_dir) shapeData = driver.CreateDataSource(shp_dir) layer = shapeData.CreateLayer('layer1', spatialReference, ogr.wkbPolygon) #assert isinstance(layer, Layer) layer.CreateField(ogr.FieldDefn("BasinId")) layerDefinition = layer.GetLayerDefn() input_path = "data/praries_basins/Boundaries_lat_lon.txt" lines = open(input_path).readlines() lons2d = polar_stereographic.lons lats2d = polar_stereographic.lats id_to_points = {} anomaly_i = 1 point_prev = None for line in lines: if line.strip() == "": continue fields = line.split() the_id = fields[0] lon = float(fields[1]) lat = float(fields[2]) if the_id not in id_to_points: id_to_points[the_id] = [] if int(the_id) >= 16: the_point = Point(lon, lat) if point_prev is not None: the_dist = the_point.distance(point_prev) if the_dist > 0.5: id_to_points[the_id + "_{0}".format(anomaly_i)] = id_to_points[the_id] id_to_points[the_id] = [] anomaly_i += 1 point_prev = the_point id_to_points[the_id].append((lon, lat)) pass polygons = [] featureIndex = 0 for the_id, points in id_to_points.items(): if not len(points): continue feature = ogr.Feature(layerDefinition) feature.SetField("BasinId", the_id) #create a polygon using shapely p = Polygon(shell=points) #print p.wkt polygons.append(p) pGdal = ogr.CreateGeometryFromWkb(p.wkb) feature.SetGeometry(pGdal) feature.SetFID(featureIndex) layer.CreateFeature(feature) featureIndex += 1 shapeData.Destroy() pass
def simple_polygon(self): pt = Point(200,0.0) return(pt.buffer(8,1))
def get_mesh2_variables(features): """ :param features: A features sequence as returned from :func:`ugrid.helpers.get_features_from_shapefile`. :type features: :class:`collections.deque` :returns: A tuple of arrays with index locations corresponding to: ===== ================ ============================= Index Name Type ===== ================ ============================= 0 Mesh2_face_nodes :class:`numpy.ma.MaskedArray` 1 Mesh2_face_edges :class:`numpy.ma.MaskedArray` 2 Mesh2_edge_nodes :class:`numpy.ndarray` 3 Mesh2_node_x :class:`numpy.ndarray` 4 Mesh2_node_y :class:`numpy.ndarray` 5 Mesh2_face_links :class:`numpy.ndarray` ===== ================ ============================= Information on individual variables may be found here: https://github.com/ugrid-conventions/ugrid-conventions/blob/9b6540405b940f0a9299af9dfb5e7c04b5074bf7/ugrid-conventions.md#2d-flexible-mesh-mixed-triangles-quadrilaterals-etc-topology :rtype: tuple (see table for array types) """ # construct the links between faces (e.g. neighbors) Mesh2_face_links = deque() for idx_source in range(len(features)): ref_object = features[idx_source]['geometry']['object'] for idx_target in range(len(features)): # skip if it is checking against itself if idx_source == idx_target: continue else: # if the objects only touch they are neighbors and share nodes if ref_object.touches(features[idx_target]['geometry']['object']): Mesh2_face_links.append([features[idx_source]['fid'], features[idx_target]['fid']]) else: continue # convert to numpy array for faster comparisons Mesh2_face_links = np.array(Mesh2_face_links, dtype=np.int32) # the number of faces nMesh2_face = len(features) # for polygon geometries the first coordinate is repeated at the end of the sequence. nMaxMesh2_face_nodes = max([len(feature['geometry']['coordinates'][0]) - 1 for feature in features]) Mesh2_face_nodes = np.ma.array(np.zeros((nMesh2_face, nMaxMesh2_face_nodes), dtype=np.int32), mask=True) # the edge mapping has the same shape as the node mapping Mesh2_face_edges = np.zeros_like(Mesh2_face_nodes) # holds the start and nodes for each edge Mesh2_edge_nodes = deque() # holds the raw coordinates of the nodes Mesh2_node_x = deque() Mesh2_node_y = deque() # flag to indicate if this is the first face encountered first = True # global point index counter idx_point = 0 # global edge index counter idx_edge = 0 # holds point geometry objects points_obj = deque() # loop through each polygon for feature in features: # reference the face index fid = feature['fid'] # just load everything if this is the first polygon if first: # store the point values. remember to ignore the last coordinate. for ii in range(len(feature['geometry']['coordinates'][0]) - 1): coords = feature['geometry']['coordinates'][0][ii] # create and store the point geometry object points_obj.append(Point(coords[0], coords[1])) # store the x and y coordinates Mesh2_node_x.append(coords[0]) Mesh2_node_y.append(coords[1]) # increment the point index idx_point += 1 # map the node indices for the face Mesh2_face_nodes[fid, 0:idx_point] = range(0, idx_point) # construct the edges. compress the node slice to remove any masked values at the tail. for start_node_idx, end_node_idx in iter_edge_nodes(Mesh2_face_nodes[fid, :].compressed()): Mesh2_edge_nodes.append((start_node_idx, end_node_idx)) idx_edge += 1 # map the edges to faces Mesh2_face_edges[fid, 0:idx_edge] = range(0, idx_edge) # switch the loop flag to indicate the first face has been dealt with first = False else: # holds new node coordinates for the face new_Mesh2_face_nodes = deque() # only search neighboring faces neighbor_face_indices = Mesh2_face_links[Mesh2_face_links[:, 0] == fid, 1] for ii in range(len(feature['geometry']['coordinates'][0]) - 1): # logic flag to indicate if the point has been found found = False coords = feature['geometry']['coordinates'][0][ii] pt = Point(coords[0], coords[1]) # search the neighboring faces for matching nodes for neighbor_face_index in neighbor_face_indices.flat: # break out of loop if the point has been found if found: break # search over the neighboring face's nodes for neighbor_face_node_index in Mesh2_face_nodes[neighbor_face_index, :].compressed(): if pt.almost_equals(points_obj[neighbor_face_node_index]): new_Mesh2_face_nodes.append(neighbor_face_node_index) # point is found, no need to continue with loop found = True break # add the new node if it has not been found if not found: # add the point object to the collection points_obj.append(pt) # add the coordinates of the new point Mesh2_node_x.append(coords[0]) Mesh2_node_y.append(coords[1]) # append the index of this new point new_Mesh2_face_nodes.append(idx_point) # increment the point index idx_point += 1 # map the node indices for the face Mesh2_face_nodes[fid, 0:len(new_Mesh2_face_nodes)] = new_Mesh2_face_nodes # find and map the edges new_Mesh2_face_edges = deque() for start_node_idx, end_node_idx in iter_edge_nodes(Mesh2_face_nodes[fid, :].compressed()): # flag to indicate if edge has been found found_edge = False # search existing edge-node combinations accounting for ordering for idx_edge_nodes, edge_nodes in enumerate(Mesh2_edge_nodes): # swap the node ordering if edge_nodes == (start_node_idx, end_node_idx) or edge_nodes == (end_node_idx, start_node_idx): new_Mesh2_face_edges.append(idx_edge_nodes) found_edge = True break if not found_edge: Mesh2_edge_nodes.append((start_node_idx, end_node_idx)) new_Mesh2_face_edges.append(idx_edge) idx_edge += 1 # update the face-edge mapping Mesh2_face_edges[fid, 0:len(new_Mesh2_face_edges)] = new_Mesh2_face_edges return Mesh2_face_nodes, \ Mesh2_face_edges, \ np.array(Mesh2_edge_nodes, dtype=np.int32), \ np.array(Mesh2_node_x, dtype=np.float32), \ np.array(Mesh2_node_y, dtype=np.float32), \ np.array(Mesh2_face_links, dtype=np.int32)
fpath = args.lasfile opath = "%s/%s" % (args.outdir.rstrip('/'),args.lasfile.split('/')[-1]) # prepare statistics points_read = 0 points_kept = 0 # open in- and output LAS-file f = lasfile.File(fpath,mode='r') o = lasfile.File(opath, header=f.header, mode='w') # extract points #print "processing %s ..." % args.lasfile for point in f: points_read += 1 p = Point(point.x, point.y) if p.within(wkt_poly) or p.intersects(wkt_poly): points_kept += 1 o.write(point) # give feedback and remove empty output file o.close() f.close() if points_kept == 0: print " no points found within WKT-poly" os.remove(opath) else: print " created %s (kept %s of %s points)" % (opath,points_kept,points_read) # log times time_end = time.time()