コード例 #1
0
def filter_building(way, b, polygons):
    near_way_points = nearest_points(polygons[b['id']], way)
    b_near_way = near_way_points[0]
    buff = b_near_way.buffer(b_near_way.distance(near_way_points[1]) + 0.00001,
                             mitre_limit=1.0)
    buff = shapely.affinity.scale(buff, 1.0, 0.75)

    n_intersect = buff.boundary.intersection(way)
    n_intersect = [n_intersect] if isinstance(n_intersect,
                                              Point) else list(n_intersect)
    n_intersect = MultiPoint(n_intersect)

    filtered = True
    if n_intersect:
        nearest = nearest_points(polygons[b['id']], n_intersect)
        mp = MultiPoint(list(n_intersect) + [nearest[0]])

        try:
            mp = Polygon(mp)
            filtered = any(
                filter(
                    lambda (bid, p): bid != b['id'] and p.boundary.intersects(
                        mp.boundary), polygons.items()))
        except ValueError:
            pass

    return filtered
コード例 #2
0
ファイル: turf.py プロジェクト: nktb40/mostransport_etl
def line_slice(startPt, stopPt, line):
    coords = list(line.coords)
    multi_line = MultiPoint(line.coords)

    if line.type == 'LineString':

        startVertex = nearest_points(multi_line,
                                     startPt['geometry'])[0].coords[0]
        stopVertex = nearest_points(multi_line,
                                    stopPt['geometry'])[0].coords[0]

        start_indx = coords.index(startVertex)
        stop_indx = coords.index(stopVertex)

        ends = []
        if start_indx <= stop_indx:
            ends = [start_indx, stop_indx]
        else:
            ends = [stop_indx, start_indx]

        clipCoords = coords[ends[0]:ends[1] + 1]

        if (len(clipCoords) == 1):
            clipCoords.append(clipCoords[0])

        return LineString(clipCoords)
コード例 #3
0
ファイル: segment.py プロジェクト: espirin/route_simplifier
    def find_cut_distance(current_string: LineString, pair, frequency: int,
                          offset_distance: float, side: str):
        neighbor_string = LineString(
            [[pair.node_from.utm.north, pair.node_from.utm.east],
             [pair.node_to.utm.north, pair.node_to.utm.east]])
        offsetted_neighbor_string = neighbor_string.parallel_offset(
            frequency * offset_distance, side='left', resolution=10)

        # Project neighbor string onto current string.
        if side == 'back':
            projected_point = Point(
                nearest_points(
                    current_string,
                    Point(list(offsetted_neighbor_string.coords)[-1]))[0])
        else:
            projected_point = Point(
                nearest_points(
                    current_string,
                    Point(list(offsetted_neighbor_string.coords)[0]))[0])

        # Create a line from the side of the current string to the projected points.
        if side == 'back':
            line = LineString(
                [Point(list(current_string.coords)[0]), projected_point])
        else:
            line = LineString(
                [Point(list(current_string.coords)[-1]), projected_point])

        return line.length
コード例 #4
0
def get_h_line(
    pts0: MultiPoint,
    pts1: MultiPoint,
) -> LineString:
    if isinstance(pts1, Point):
        pts1 = MultiPoint([pts1])
    if isinstance(pts0, Point):
        pts0 = MultiPoint([pts0])

    eps = 1e-6
    hdist = pts0.hausdorff_distance(pts1)
    ls = []

    for p0 in pts0:
        d = p0.distance(pts1)
        if abs(d - hdist) < eps:
            #return LineString(nearest_points(p0,pts1))
            ls.append(LineString(nearest_points(p0, pts1)))
    for p1 in pts1:
        d = p1.distance(pts0)
        if abs(d - hdist) < eps:
            #return LineString(nearest_points(p0,pts1))
            ls.append(LineString(nearest_points(p1, pts0)))

    return MultiLineString(ls)
コード例 #5
0
ファイル: DeepRacerEnv.py プロジェクト: sd3z/deepracer_env
    def step(s, action):
        """Apply action, return new state, reward, done, empty info dict"""
        throttle, turn = action
        prev_dist = s.distance_to_centerline()
        s.move_car(throttle, turn)
        is_display_alive = s.draw()
        s.camera_view = s.display.read_screen()

        # increment measurements
        s.time += 1
        s.driving_dist += np.sqrt(s.car.dx**2+s.car.dy**2)
        cur_point = Point(s.car.x, s.car.y)
        if not hasattr(s, 'prev_track_point'):
            s.prev_track_point = nearest_points(s.track_center, Point(s.car.x, s.car.y))[0]
        cur_track_point = nearest_points(s.track_center, cur_point)[0]
        delta_track_dist = 0.0
        if s.is_on_track():
            angle = s.get_angle(cur_track_point.x, cur_track_point.y,
                                s.prev_track_point.x, s.prev_track_point.y)
            if (True):#angle > 0):
                delta_track_dist = cur_track_point.distance(s.prev_track_point)
                s.track_dist += delta_track_dist
        s.prev_track_point = cur_track_point

        # finalize other values
        #reward = delta_track_dist/s.car.max_v
        #reward = (abs(prev_dist) - abs(s.distance_to_centerline()))/70
        reward = 1.0 if s.is_on_track() else 0.0
        state = [s.camera_view.astype(np.float32)/255, np.array([s.time/100])] # true system includes camera, gyroscope,and accelerometer
        done = ((not is_display_alive) or (abs(s.distance_to_centerline()) > 80)) #implement your own logic on when to be done

        return state, reward, done, {}
コード例 #6
0
    def step(s, action):
        """Apply action, return new state, reward, done, empty info dict"""
        s.throttle, s.steering_angle = action
        prev_dist = s.get_distance_to_center()
        s.move_car(s.throttle, s.steering_angle)
        is_display_alive = s.draw()
        s.camera_view = s.display.read_screen()

        # increment measurements
        s.time += 1
        s.driving_dist += np.sqrt(s.car.dx**2+s.car.dy**2)
        cur_point = Point(s.car.x, s.car.y)
        if not hasattr(s, 'prev_track_point'):
            s.prev_track_point = nearest_points(s.track_center, Point(s.car.x, s.car.y))[0]
        cur_track_point = nearest_points(s.track_center, cur_point)[0]
        delta_track_dist = 0.0
        if s.is_on_track():
            delta_track_dist = cur_track_point.distance(s.prev_track_point)
            s.track_dist += delta_track_dist
        s.prev_track_point = cur_track_point

        params = s.get_params()
        reward = s._reward_func(params)
        state = s.get_state()
        done = ((not is_display_alive) or (abs(s.get_distance_to_center()) > 80))

        return state, reward, done, {}
コード例 #7
0
ファイル: kohonen.py プロジェクト: sureshakukkaje/grgen
    def moveBoundaryPoints(self):
        """ move boundary weights/points on the geometry boundary """

        self.timer.startTimer("moveBoundaryPoints")

        inner = Polygon(self.geometry[1])
        outer = Polygon(self.geometry[0])

        movement = np.zeros((np.shape(self.boundaryIdx)[0], 2))

        weightsBoundary = tf.Variable(tf.gather(self.weights,
                                                self.boundaryIdx),
                                      dtype=self.dataType).numpy()

        for idx in range(0, np.shape(self.boundaryIdx)[0]):

            point = Point(weightsBoundary[idx, 0], weightsBoundary[idx, 1])

            pOuter, p = nearest_points(outer.boundary, point)
            pInner, p = nearest_points(inner.boundary, point)

            if (point.distance(pInner) > point.distance(pOuter)):

                movement[idx, 0] = pOuter.x
                movement[idx, 1] = pOuter.y
            else:
                movement[idx, 0] = pInner.x
                movement[idx, 1] = pInner.y

        print(np.shape(self.boundaryIdx))
        print(np.shape(self.boundaryIdx))

        tf.compat.v1.scatter_update(self.weights, self.boundaryIdx, movement)

        self.timer.stopTimer("moveBoundaryPoints")
コード例 #8
0
def _extend_boundaries(baselines, bin_bl_map):
    # find baseline blob boundaries
    labelled = label(bin_bl_map)
    boundaries = []
    for x in regionprops(labelled):
        try:
            b = boundary_tracing(x)
            if len(b) > 3:
                boundaries.append(geom.Polygon(b).simplify(0.01).buffer(0))
        except Exception as e:
            logger.warning(f'Boundary tracing failed in baseline elongation: {e}')
            continue

    # extend lines to polygon boundary
    for bl in baselines:
        ls = geom.LineString(bl)
        try:
            boundary_pol = next(filter(lambda x: x.contains(ls), boundaries))
        except Exception:
            continue
        # 'left' side
        if boundary_pol.contains(geom.Point(bl[0])):
            l_point = boundary_pol.boundary.intersection(geom.LineString([(bl[0][0]-10*(bl[1][0]-bl[0][0]), bl[0][1]-10*(bl[1][1]-bl[0][1])), bl[0]]))
            if l_point.type != 'Point':
                bl[0] = np.array(nearest_points(geom.Point(bl[0]), boundary_pol)[1], 'int').tolist()
            else:
                bl[0] = np.array(l_point, 'int').tolist()
        # 'right' side
        if boundary_pol.contains(geom.Point(bl[-1])):
            r_point = boundary_pol.boundary.intersection(geom.LineString([(bl[-1][0]-10*(bl[-2][0]-bl[-1][0]), bl[-1][1]-10*(bl[-2][1]-bl[-1][1])), bl[-1]]))
            if r_point.type != 'Point':
                bl[-1] = np.array(nearest_points(geom.Point(bl[-1]), boundary_pol)[1], 'int').tolist()
            else:
                bl[-1] = np.array(r_point, 'int').tolist()
    return baselines
コード例 #9
0
def is_tangential(l1, l2, acceptance_rate=0.3, acc_radius=-1.0, angle=0.95):

    step_size = 0.05
    tangential_score = 0
    nb_probes = 0
    # go through l1 and compare tangents with nearest point on l2
    t = 0.0

    while t < 1.0:

        p = l1.interpolate(t, normalized=True)
        p_prim = l1.interpolate(t+step_size, normalized=True)
        p_coords = np.array(p)
        p_prim_coords = np.array(p_prim)

        t += step_size
        p, q = nearest_points(p, l2)
        p_prim, q_prim = nearest_points(p_prim, l2)

        q_coords = np.array(q)
        q_prim_coords = np.array(q_prim)

        if np.all(np.isclose(p,p_prim)) or np.all(np.isclose(q,q_prim)):
            continue
        t1 = p_prim_coords - p_coords
        t2 = q_prim_coords - q_coords
        cos_alpha = np.dot(t1, t2)/(np.linalg.norm(t1)*np.linalg.norm(t2))
        if cos_alpha > angle:
            tangential_score += 1
        nb_probes += 1

    if nb_probes > 1:
        return float(tangential_score)/float(nb_probes) >= acceptance_rate
    else:
        return False
コード例 #10
0
def metro_dist(from_pt, to_pts, **kwargs):
    """
    Finds distance from from_pt to nearest metro station or to_pts.
    
    from_pt : row of e.g. municipality with PROJECTED .geometry field
    to_pts (eg metro) : data frame of target points with PROJECTED .geometry field

    if additional key COMUNAS is included, distance will be taken from the centroid
    of comunas matching the correct municipality index.
    
    returns: distance (METERS, if both dataframes projected projected)
    and INDEX (second) of to_pt
    """

    # throw error if incorrect type, for whatever reason
    assert (type(from_pt.geometry)
            in [Point,
                Polygon]), "from_pt must contain point or polygon geometry"

    to_pts_geom = to_pts.geometry.tolist()
    # find nearest point to a given point
    if "comunas" in kwargs.keys():  # weighted center of comunas
        center = muni_center(from_pt["sort_ind"] + 1, kwargs["comunas"])
        r = nearest_points(center, MultiPoint(to_pts_geom))
    elif type(from_pt.geometry) == Polygon:
        r = nearest_points(from_pt.geometry.centroid, MultiPoint(to_pts_geom))
    elif type(from_pt.geometry) == Point:
        r = nearest_points(from_pt.geometry, MultiPoint(to_pts_geom))

    return r[0].distance(r[1]), to_pts_geom.index(r[1])
コード例 #11
0
def extend_FaultLines(GRDECL_Data,
                      line,
                      OldFaults,
                      startfrom='StartPoint or EndPoint'):
    #extend a line from its start point or end point
    #the end point must on the boundary
    debug = 0

    if (startfrom == 'StartPoint'):
        p1, p2 = line[0], line[1]
    if (startfrom == 'EndPoint'):
        p1, p2 = line[-1], line[-2]

    if (abs(p1[0] - p2[0]) < 1e-10):
        if (debug): print("Line along Y direction")
        if (p1[1] - p2[1] < 0):  #Y- direction
            NewEndPoint = (p1[0], 0)
            NextPoint = (p1[0], p1[1] - 0.00001)
        if (p1[1] - p2[1] > 0):  #Y- direction
            NewEndPoint = (p1[0], GRDECL_Data.NY)
            NextPoint = (p1[0], p1[1] + 0.00001)
    if (abs(p1[1] - p2[1]) < 1e-10):
        if (debug): print("Line along X direction")
        if (p1[0] - p2[0] < 0):  #X- direction
            NewEndPoint = (0, p1[1])
            NextPoint = (p1[0] - 0.00001, p1[1])
        if (p1[0] - p2[0] > 0):  #X+ direction
            NewEndPoint = (GRDECL_Data.NX, p1[1])
            NextPoint = (p1[0] + 0.00001, p1[1])

    #Check is hit old fault line and upadte the new endpoint
    if (debug): print('P2P1', (p2, p1), 'ExtendSeg', NextPoint, NewEndPoint)
    ExtendedSegment = LineString([NextPoint, NewEndPoint])
    OldFaults = MultiLineString(OldFaults)
    objects = ExtendedSegment.intersection(OldFaults)

    if (objects.is_empty == False):  #We have hit point
        #print('HitGeometry',objects,objects.geom_type)
        if (objects.geom_type in ['LineString', 'Point']):
            pts = nearest_points(Point(p1), objects)
            pts = Shapely2List_MultiPoint(pts)[1]
            #print('NearestPoint',pts)
            #pts=sorted(list(objects.coords))[0]
        elif (objects.geom_type
              in ['MultiLineString', 'MultiPoint', 'GeometryCollection']):
            pts = nearest_points(Point(p1), objects)
            pts = Shapely2List_MultiPoint(pts)[1]
            #print('NearestPts',pts)
            #pts=Shapely2List_MultiLineString(objects)
            #pts=sorted([j for i in pts for j in i])[0]
        else:
            print('Unkonwn shapely type', objects.geom_type, objects)
        pts = (int(pts[0]), int(pts[1]))
        if (debug): print('HitPoints', pts)
        NewEndPoint = pts

    #NewLine=sorted(line+[NewEndPoint])
    return [NewEndPoint]
コード例 #12
0
def directionality_error(nodes, polygon):
    angles = []
    for i in range(len(nodes)):
        #edge as vector
        v1 = nodes[i - 1] - nodes[i]

        #get vector of two closest boundary points to each node
        v2 = nearest_points(polygon,Point(nodes[i][0], nodes[i][1]))[0] -\
             nearest_points(polygon,Point(nodes[i-1][0], nodes[i-1][1]))[0]

        angles.append((angle(v1, v2) % (0.5 * np.pi)))

    return 1 - (np.mean(angles) / (0.5 * np.pi))
コード例 #13
0
ファイル: point_wise_map.py プロジェクト: imdonnie/GEO-HW2
def passLength(candi,data_probes,data_links):
    candi2 = [candi[0]]
    for i in range(len(candi)-1):
        if len(candi2[i][1]) == 0: 
                candi2.append(candi[i+1])                # skip the samples that already has no candidate.
                continue
        probe1 = data_probes.loc[candi2[i][0]]
        probe2 = data_probes.loc[candi[i+1][0]]
        if (probe1['sampleID'] != probe2['sampleID']):
            candi2.append(candi[i+1])
            continue
        p1_speed = probe1['speed']
        p2_speed = probe2['speed']
        avg_speed = (p1_speed+p2_speed)/2
        time = 5 * (candi[i][0]-candi[i+1][0])
        length = avg_speed * time
        p1_point = Point(probe1['easting'],probe1['northing'])
        p2_point = Point(probe2['easting'],probe2['northing'])
        candi1 = []
        for j in range (len(candi[i+1][1])):
            p1_link = data_links.loc[candi[i][1][0]]
            p1_utms = p1_link["utms"][2:-2].replace("), (", "|").replace(", ", " ").replace("|", ", ")
            p1_line = wkt.loads("LINESTRING (" + p1_utms + ")")
            p1_nearest = nearest_points(p1_line, p1_point)[0]

            p2_link = data_links.loc[candi[i+1][1][j]]
            p2_utms = p2_link["utms"][2:-2].replace("), (", "|").replace(", ", " ").replace("|", ", ")
            p2_line = wkt.loads("LINESTRING (" + p2_utms + ")")
            p2_nearest = nearest_points(p2_line, p2_point)[0]
            distance = p1_nearest.distance(p2_nearest)

            p1_lim = max(p1_link['toRefSpeedLimit'],p1_link['fromRefSpeedLimit'])
            p2_lim = max(p2_link['toRefSpeedLimit'],p2_link['fromRefSpeedLimit'])
            thrsh = (max(p1_lim,p2_lim)/3.6*time)*1.1

            if length <= (thrsh+distance):
                candi1.append(candi[i+1][1][j])

        if len(candi1) > 0:
            each = []
            each.append(candi[i+1][0])
            each.append(candi1)
            candi2.append(each)
        else:
            each = []
            each.append(candi[i+1][0])
            each.append([])
            candi2.append(each)

    return candi2
コード例 #14
0
def latlon_to_reach(lat: float, lon: float) -> tuple:
    # determine the region that the point is in
    region = latlon_to_region(lat, lon)

    # switch the point because the csv's are lat/lon, backwards from what shapely expects (lon then lat)
    point = Point(float(lat), float(lon))

    # open the region csv
    df = pd.read_pickle(
        f'/app/GSP_API/geometry/{region}-comid_lat_lon_z.pickle')
    points_df = df.loc[:, "Lat":"Lon"].apply(Point, axis=1)

    # determine which point is closest
    multi_pt = MultiPoint(points_df.tolist())
    nearest_pt = nearest_points(point, multi_pt)
    reach_id = int(points_df[points_df == nearest_pt[1]].index[0])
    distance = nearest_pt[0].distance(nearest_pt[1])

    # if the nearest stream if more than .1 degrees away, you probably didn't find the right stream
    if distance > 0.11:
        raise ValueError(
            'This lat/lon pair is too far from a delineated stream. Try again or use the web interface.'
        )
    else:
        return reach_id, region, distance
コード例 #15
0
def simple_line_cut(linestring, point1, dist_thres, tol, trace=True):
    from shapely.ops import nearest_points
    from shapely.ops import split
    from shapely.geometry import MultiPoint, LineString

    #Find nearest points on line:
    np1 = nearest_points(linestring, point1)

    # Return error message if points are too far away from line:
    dist1 = np1[0].distance(np1[1])
    if dist1 > dist_thres:
        if trace:
            print(
                'Point1 is', dist1,
                'units apart from line which is more than the specified distance threshold of',
                dist_thres)
        return None

    #Do split:
    split_1 = split(linestring, np1[0].buffer(tol))
    if len(list(split_1)) == 1:
        if trace:
            print('Splitting at mapped point 1 did not work')
        return None

    return list(split_1)
コード例 #16
0
 def nearest_land_pos(self, point: Point, extend_dist: int = 50) -> Point:
     """Returns the nearest point inside a land exclusion zone from point
     `extend_dist` determines how far inside the zone the point should be placed"""
     if self.is_on_land(point):
         return point
     point = geometry.Point(point.x, point.y)
     nearest_points = []
     if not self.landmap:
         raise RuntimeError("Landmap not initialized")
     for inclusion_zone in self.landmap[0]:
         nearest_pair = ops.nearest_points(point, inclusion_zone)
         nearest_points.append(nearest_pair[1])
     min_distance = point.distance(
         nearest_points[0])  # type: geometry.Point
     nearest_point = nearest_points[0]  # type: geometry.Point
     for pt in nearest_points[1:]:
         distance = point.distance(pt)
         if distance < min_distance:
             min_distance = distance
             nearest_point = pt
     assert isinstance(nearest_point, geometry.Point)
     point = Point(point.x, point.y)
     nearest_point = Point(nearest_point.x, nearest_point.y)
     new_point = point.point_from_heading(
         point.heading_between_point(nearest_point),
         point.distance_to_point(nearest_point) + extend_dist)
     return new_point
コード例 #17
0
def find_nearest_point_on_line(line_pts, pts):

    if type(line_pts) is sg.LineString:
        sg_line = line_pts
    else:
        sg_line = sg.asLineString(line_pts)

    if pts.ndim == 1:
        num_pts = 1
    else:
        num_pts = np.shape(pts)[0]
    if num_pts > 1:
        min_dist = 1000
        for i_pt in range(num_pts):
            test_pt = sg.asPoint(pts[i_pt, :])
            test_dist = test_pt.distance(sg_line)
            if test_dist < min_dist:
                min_dist = test_dist
                closest_pt = test_pt

        sg_point = closest_pt
    else:
        sg_point = sg.asPoint(pts)
    try:
        near_pts = so.nearest_points(sg_line, sg_point)
    except:
        pass

    nndist = near_pts[0].distance(near_pts[1])
    nn_pt = near_pts[0]

    return nndist, nn_pt
コード例 #18
0
def get_nearest_date(x, selCables):
    selCables = selCables.loc[selCables['RFS'] <= x['d2_l1_year_perf_indicators']]
    if selCables.shape[0] > 0:
        xx = selCables.loc[selCables.geometry == nearest_points(x['geometry'], selCables.unary_union)[1]]
        return(xx.sort_values(['RFS'])['RFS'].iloc[0])
    else:
        return(-1)
コード例 #19
0
def getdestloc_simple(p, w_gdf, u, distvar):  #for students, work -> eductation

    nearestpoint = nearest_points(p, u)[1]  #get nearest point
    mindist = p.distance(nearestpoint)  #find the distance to the nearest point
    #print(mindist) degree
    sim_dist = gen_lnorm(distvar, "")
    sim_distdeg = sim_dist / 110.8

    if sim_distdeg < mindist:  # if the distance is shorter than the distance to the nearest points. take the nearest point
        sim_distdeg = mindist
        des_p = nearestpoint
        num_points = 0
        print(f'use nearest point as simulated distance is too short.')
    # else calculate a buffer and select points.
    else:
        pbuf = p.buffer(
            sim_distdeg)  # distance to degree`maybe better to project.
        pbuf.crs = {'init': 'epsg:4326', 'no_defs': True}
        worklocset = w_gdf[w_gdf.within(pbuf)]
        num_points = len(worklocset)
        print(f'sample from {num_points} points')
        workloc = worklocset.sample(n=1, replace=True, random_state=1)
        des_p = workloc.iloc[0][
            "geometry"]  #get point out of the geopandas dataframe
    return (p, des_p, num_points)
コード例 #20
0
def GetCountyByCoord(lat, lon):
    point = Point(lon, lat)
    for town in towns_polygons:
        for town_polygon in towns_polygons[town]:
            if len(town_polygon) == 1:
                polygon = Polygon(town_polygon[0])
            else:
                polygon = Polygon(town_polygon)
            if polygon.contains(point):
                return town

    logger.warning(
        f'Vague point detected! Start further algorithm to check its town ')

    for town in towns_polygons:
        for town_polygon in towns_polygons[town]:
            if len(town_polygon) == 1:
                polygon = Polygon(town_polygon[0])
            else:
                polygon = Polygon(town_polygon)
            p1, _ = nearest_points(polygon, point)
            if great_circle_distance_on_earth(
                    point, p1) < 5:  # distance to shore 5km?
                logger.info(f'Success detect its town as {town}!')
                return town
    logger.warning(f'Failed to detect town!')
    return '不在台灣啦!'
コード例 #21
0
def find_separation_point(lines):

    points = []

    threshold = 0.2

    for i in range(len(lines) - 1):

        ref_line = LineString(lines[i])
        line = lines[i + 1]

        closest_points = sorted(
            [(distance(p1, (p2.x, p2.y)), p1, (p2.x, p2.y))
             for p1, p2 in [(p, nearest_points(ref_line, Point(p))[0])
                            for p in line]],
            key=lambda x: x[0])

        for j, (dist, p1, p2) in enumerate(closest_points):

            if dist > threshold or j == len(closest_points) - 1:
                points.append(((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2))
                break

    return (np.average([p[0]
                        for p in points]), np.average([p[1] for p in points]))
コード例 #22
0
ファイル: point_wise_map.py プロジェクト: imdonnie/GEO-HW2
def trvdir(p,candi,probe_point,data_links,data_probes):
    probe = data_probes.loc[p]
    candi2 = []
    for i in range(len(candi)):
        link = data_links.loc[candi[i]]
        utms = link["utms"][2:-2].replace("), (", "|").replace(", ", " ").replace("|", ", ")
        line = wkt.loads("LINESTRING (" + utms + ")")
        nearest = nearest_points(line, probe_point)[0]
        #link_distance = nearest.distance(probe_point)
        ref_node = Point(line.coords[0][0], line.coords[0][1])
        # ref_distance = ref_node.distance(probe_point)
        pro_link_dis = nearest.distance(ref_node)

        # Update dataframe attributes
        data_probes.loc[p, "linkPVID"] = link["linkPVID"]
        #data_probes.loc[p, "distFromLink"] = link_distance
        #data_probes.loc[p, "distFromRef"] = ref_distance
        data_probes.loc[p,"distBetRP"] = pro_link_dis

        # Calculate the orientation relative to the ref node
        radians = math.atan2(ref_node.y - probe_point.y, ref_node.x - probe_point.x)
        ref_node_direction = int(math.degrees(radians))
        if ref_node_direction <= 0:
            ref_node_direction = ref_node_direction + 360
        if abs(ref_node_direction - probe["heading"]) <= 90:
            data_probes.loc[p, "direction"] = 'T'
        else:
            data_probes.loc[p, "direction"] = 'F'
        s_direc = data_probes.loc[p, "direction"] 
        l_direc = link["directionOfTravel"]
        if ~((l_direc != 'B') & (s_direc != l_direc)):   # only keep the segment candidates whose directionOfTravel is conformed with the sample's current travel direction.    
                candi2.append(candi[i])
    return candi2
コード例 #23
0
def chunk_worker(left_spec, right_spec, pairs_slice):

    # recover the SharedMemory bloc
    left_shm = SharedMemory(left_spec['name'])
    right_shm = SharedMemory(right_spec['name'])
    # Create the np.recarray from the buffer of the shared memory
    left_arr = np.recarray(shape=left_spec['shape'],
                           dtype=left_spec['dtype'],
                           buf=left_shm.buf)
    right_arr = np.recarray(shape=right_spec['shape'],
                            dtype=right_spec['dtype'],
                            buf=right_shm.buf)

    #print (left_arr[0][2], right_arr[0][2])

    results = []
    for idx_pair in pairs_slice:
        geom1 = wkt.loads(left_arr[idx_pair[0]][2])
        geom2 = wkt.loads(right_arr[idx_pair[1]][2])

        pt1, pt2 = ops.nearest_points(geom1, geom3)

        dist, a1, a2 = V_inv((pt1.y, pt1.x), (pt2.y, pt2.x))

        dist = dist * 1000  #m

        results.append((idx_pair[0], idx_pair[1], dist))

    return results
コード例 #24
0
def getNearestWay(query, project, inputCoord):
    """

    @param query:
    @param project:
    @param inputCoord:
    @return:
    """
    lineStringDict = {}
    for i in query.features:
        # Transform from WGS 1984 to the projection, this avoids getting degrees in results
        shape = transform(project, LineString(i["geometry"]["coordinates"]))
        # Calculate nearest point between the input coordinate and the way geom
        nearestPt = nearest_points(inputCoord, shape)[1]
        # Get the distance to the nearest point from the input coordinate
        distToPt = nearestPt.distance(inputCoord)
        # Build dict with results, OSM IDs are the top level keys
        lineStringDict[i["id"]] = {"name": i["properties"]["name"], "shape": shape, "nearestPt": nearestPt,
                                   "distToPt": distToPt}

    lowestVal = ["", 99999]
    # Get nearest way name by looping over IDs in dict
    for i in lineStringDict.keys():
        if lineStringDict[i]["distToPt"] < lowestVal[1]:
            lowestVal[0] = lineStringDict[i]["name"]
            lowestVal[1] = lineStringDict[i]["distToPt"]
    return lowestVal
コード例 #25
0
def check_double_points(gdf, radius=0.001, id_column='id'):
    """

    :param gdf:
    :param radius:
    :param id_column:
    :return:
    """

    l_ids = []
    count = 0

    for r, c in gdf.iterrows():

        point = c['geometry']
        gdf_other = gdf.drop([r])
        other_points = cascaded_union(gdf_other['geometry'])

        # x1 = nearest_points(point, other_points)[0]
        x2 = nearest_points(point, other_points)[1]

        if point.distance(x2) <= radius:
            l_ids.append(c[id_column])
            print('Node ', c[id_column], ' has a near neighbour!', 'Distance ',
                  point.distance(x2))
            count += 1

    print('')
    print('Number of duplicated points: ', count)

    return l_ids
コード例 #26
0
def point_at_intersect(gdf_cross, gdf_line):
    gdf_cross = check_gdf(gdf_cross)
    gdf_line = check_gdf(gdf_line)

    df_points = pd.DataFrame([],
                             columns=[gdf_line.index],
                             index=gdf_cross.index,
                             dtype='object')
    for line, linerow in gdf_line.iterrows():
        geolist = []
        for index, row in gdf_cross.iterrows():
            interpoint = row.geometry.intersection(linerow.geometry)
            if interpoint.geom_type == 'Point':
                geolist.append(interpoint)
            else:
                nearest_geoms = nearest_points(Point(row['midX'], row['midY']),
                                               interpoint)
                geolist.append(nearest_geoms[1])
        # df_points[line]=gpd.GeoSeries([row[1].geometry.intersection(linerow.geometry) for row in gdf_cross.iterrows()])
        workpath = os.getenv(
            'surfdrive'
        ) + "\\Documents\\DATA\\Netherlands\\main channel\\main_channelbedlevel\\bed_level_data\\"

        gpd.GeoDataFrame(gdf_cross.rkm, geometry=geolist).to_file(
            os.path.join(workpath, 'worktmp', 'RL_' + str(line) + '.shp'))
        df_points[line] = gpd.GeoSeries(geolist, index=gdf_cross.index)

    return df_points
コード例 #27
0
def query_k_nearest_road_segments(edge_idx, point, k):
    """
    query k-nearest road segments of a given point
    :param edge_idx: the road segments r-tree index
    :param point: the given point
    :param k: the number of segments needed to query
    :return: k candidates as a pandas DataFrame
    """
    candidates = pd.DataFrame(columns=('distance', 'from', 'to', 'proj_point',
                                       'road'))
    hits = edge_idx.nearest((point.x, point.y, point.x, point.y),
                            k,
                            objects=True)
    for item in hits:
        results = nearest_points(point, item.object['geometry'])
        d = point.distance(results[1])
        s = pd.Series({
            'distance': d,
            'from': item.object['from'],
            'to': item.object['to'],
            'proj_point': results[1],
            'road': item.object
        })
        candidates = candidates.append(s, ignore_index=True)
    # candidates['observation prob'] = candidates.apply(lambda row: normal_distribution())
    candidates.sort_values(by='distance', axis=0, inplace=True)
    return candidates
コード例 #28
0
ファイル: city_growth.py プロジェクト: gauravcusp/CityGrowth
def get_distance_water(gdf, gdf_water):
    """
    Function to calculate distance to nearest water body
    
    Input:
    gdf: Geodataframe (Ideally a grid network of the city)
    gdf_water : Water mask geodataframe
    
    Returns:
    Geodataframe with column 'dist_to_water' added to it
    """
    
    print("Populating distance to water!!")
    gdf_land = gdf.copy()
    gdf_water.to_crs(epsg=out_proj, inplace=True)
    gdf_land.to_crs(epsg=out_proj, inplace=True)
    
    water_dist = []
    
    dest_water = MultiPoint([i.centroid for i in gdf_water.geometry])
    
    for i in gdf_land.index:
        if i % 1000 == 0:
            print("{0} of {1} rows processed" .format(i, len(gdf_land)))

        temp_cent = gdf_land.geometry[i].centroid
        nearest_geoms = nearest_points(temp_cent, dest_water)
        water_dist.append(nearest_geoms[0].distance(nearest_geoms[1]))
    
    gdf['dist_to_water'] = water_dist
    
    return gdf
コード例 #29
0
ファイル: gpx2csv.py プロジェクト: bidur/map_match_gps_data
def get_nearest_row_id(id_done, pt_ref, df_route):

    if (id_done < 0):
        id_done = 0

    id_until = int(round(id_done + (len(df_route) * 0.1)))
    if id_until < 1:
        id_until = 1
    id_until = len(df_route) if id_until > len(df_route) else id_until
    df_route_slice = df_route[id_done:id_until]
    '''
	print('id_done', id_done)
	print (pt_ref)
	display(df_route.head())
	display (df_route_slice.head())
	'''
    '''
	print('pts3')
	print (pts3)
	print ("pt_ref")
	print (pt_ref)
	'''
    pts3 = df_route_slice.geometry.unary_union
    nearest = df_route_slice.geometry == nearest_points(pt_ref, pts3)[1]

    list_ids = df_route_slice[nearest].id.values

    list_ids.sort()
    for i in list_ids:
        if i >= id_done:
            return i

    return -1
コード例 #30
0
ファイル: test_nearest.py プロジェクト: SIGISLV/Shapely
 def test_nearest(self):
     first, second = nearest_points(
                     Point(0, 0).buffer(1.0), Point(3, 0).buffer(1.0))
     self.assertAlmostEqual(first.x, 1.0, 7)
     self.assertAlmostEqual(second.x, 2.0, 7)
     self.assertAlmostEqual(first.y, 0.0, 7)
     self.assertAlmostEqual(second.y, 0.0, 7)
コード例 #31
0
def get_nearest_station(poi=Point(restaurants_points[0])):
    stations_mp = MultiPoint(stations_points)
    testpoint = Point(nearest_points(poi, stations_mp)[0])
    soi = restaurants.Station[(restaurants.Lat == testpoint.y)
                              & (restaurants.Long == testpoint.x)]
    soi = list(soi)[0]
    return (soi)