def project(p1, p2, p3):
"""Project a Point, p3 onto a line between Points p1 and p2.
Uses Shapely and GEOS functions, which set distance to zero for all negative distances.
Parameters:
p1 (Point) : point at zero distance on line between p1 and p2.
p2 (Point) : endpoint of line.
p3 (Point) : the point to project.
Returns:
result (dict) : the projected Point, disctance along line, offset from line, and fractional distance along line.
"""
line = LineString([(p1.x, p1.y),(p2.x, p2.y)])
u = line.project(p3, normalized=True)
d = line.project(p3, normalized=False)
pt_xy = line.interpolate(d)
pt = Point([pt_xy.x, pt_xy.y, p3.z])
# calculate the offset distance of p3 from the line
if (p1.y - p2.y) * (p3.x - p2.x) - (p1.x - p2.x) * (p3.y - p2.y) < 0:
offset = -pt.distance(p3) # the point is offset left of the line
else:
offset = pt.distance(p3) # the point is offset right of the line
result = {'pt':pt, 'd':d, 'o':offset, 'u':u}
return result
def pymol_select_memb_old(pdb: MyPDB) -> set():
"""
print a pymol selection line for all residues that are in the membrane
!!! this assumes that cntr is at 0 0 0 and norm at 15 0 0 !!!
"""
from shapely.geometry import LineString, Point
# create Points from center & thickness
cntr_pnt = Point(pdb.memb_res.cntr.x, pdb.memb_res.cntr.y, pdb.memb_res.cntr.z)
thkn_m_pnt = Point(-pdb.memb_res.thkn.x, pdb.memb_res.thkn.y, pdb.memb_res.thkn.z)
thkn_pnt = Point(pdb.memb_res.thkn.x, pdb.memb_res.thkn.y, pdb.memb_res.thkn.z)
# define the line between center and thickness
line = LineString([thkn_m_pnt, thkn_pnt])
thickness = cntr_pnt.distance(thkn_pnt)
result = set()
# iterate over all CAs in the pdb
for cid in sorted(pdb.chains.keys()):
for rid in sorted(pdb[cid].residues.keys()):
atom = pdb[cid][rid]['CA']
# the atom as a Point
p = Point(atom.xyz.x, atom.xyz.y, atom.xyz.z)
# projection of the CA atom on the center-thickness line
np = line.interpolate(line.project(p))
# if the distance on the center-thickness line is smaller than 15, than this is in the membrane
if cntr_pnt.distance(np) < thickness-0.1:
result.add(atom.res_seq_num)
return result
def GetIntersectionDistance(self, l1, l2):
# l1 should be just two coordinate positions
# get its starting coorinate
pt1 = Point(l1.coords[0])
x = l1.intersection(l2)
# intersections can return a lot of things
d = -1
if x.wkt == 'GEOMETRYCOLLECTION EMPTY':
d = -1
# print "nothing"
elif re.match('^POINT', x.wkt):
# print "point"
pt2 = Point(x.coords[0])
d = pt1.distance(pt2)
elif re.match('^MULTI', x.wkt):
# print "mpoint"
# this will return the minimum distance
pt2 = Point(x[0].coords[0])
d = pt1.distance(pt2)
for pt2 in x:
pt2 = Point(pt2)
if d < pt1.distance(pt2):
d = pt1.distance(pt2)
else:
print 'dunno what intersection passed me'
return d
def getNosePoints(line,prevPoint):
start=Point(line.coords[0])
end=Point(line.coords[-1])
if start.distance(prevPoint)<end.distance(prevPoint):
return start
else:
return end
def compute_repulsive_ws(self, control_point, obstacle):
point, _, eta = control_point
# need to unpack obstacle tuple into polygon and threshold
obstacle_poly = obstacle[0]
obstacle_thresh = obstacle[1]
d2obstacle = point.distance(obstacle_poly)
# this is straight from book
if d2obstacle > obstacle_thresh:
return Point(0, 0)
else:
# scalar is length of vector that points away from closest obstacle
# point
scalar = eta * ((obstacle_thresh ** -1) - (d2obstacle ** -1)) * (d2obstacle ** -2)
# construct gradient vector
# find closest point, you can ignore the details Yinan
pol_ext = obstacle_poly
if obstacle_poly.geom_type != "LineString":
pol_ext = LinearRing(obstacle_poly.exterior.coords)
d = pol_ext.project(point)
p = pol_ext.interpolate(d)
# closest point
c = Point(list(p.coords)[0])
dqc = c.distance(point)
# from book, formula for delta vector
delta_d_i = Point(((point.x - c.x) / dqc, (point.y - c.y) / dqc))
return Point((-1 * delta_d_i.x * scalar, -1 * delta_d_i.y * scalar))
def find_edge_nodes(fargs):
""" Find nodes are near the edge of the hull"""
cluster, cluster_hull, nodes = fargs
# There is no hull for this community, it's been deleted.
if cluster_hull is None:
log.error("Missing hull, keeping all nodes in cluster %i",
cluster)
return len(nodes), nodes
characteristic_size = math.sqrt(cluster_hull.area)
allowed_distance = characteristic_size * args.within
boundary = cluster_hull.boundary
output = []
for node in nodes:
# check if it is an interior node
point = Point((node.lon, node.lat))
keep = False
if random.random() < args.keep:
keep = True
elif point.distance(boundary) < allowed_distance:
keep = True
if keep:
output.append(node)
return len(nodes), output
def fuse_point_to_polygon(point, polygon):
"""
:param point:
:param polygon:
"""
p = Point(point)
min_distance = float("inf")
min_index = -1
polygon = polygon[::-1] ##FIXME the received polygon is wrong. This is POG
# Identify the nearest line segment.
for i in range(len(polygon)):
seg = polygon[i:i + 2]
if len(seg) < 2:
# close the polygon
seg = [polygon[-1]] + [polygon[0]]
line_segment = LineString(seg)
dist = p.distance(line_segment)
# print seg, dist
if dist < min_distance:
min_distance = dist
min_index = i
# print min_distance, min_index
fused_polygon = polygon[min_index + 1:] + polygon[:min_index + 1] + [point]
# fused_polygon = polygon[min_index + 1:] + [point]
# aa = identify_first_point_in_polygon(fused_polygon)
# print "FUSING", aa
# print point, polygon, fused_polygon
return fused_polygon
def project_tracks_to_road(tracks,
road_segments):
"""
Compute tracks that fall into each road segment.
Args:
- tracks
- road_segments
Return:
- track_on_road: a dictionary, each key is the index of a road segment. Each
value is a set of indices of the tracks fall onto this road.
"""
track_on_road = {}
for seg_idx in np.arange(len(road_segments)):
track_on_road[seg_idx] = set([])
simplified_tracks = []
for track in tracks:
line = LineString([(pt[0], pt[1]) for pt in track.utm])
simplified_track = line.simplify(10.0)
simplified_tracks.append(simplified_track)
# Compute road segment linestrings
road_segment_linestrings = []
for r_seg in road_segments:
r_start = r_seg.center - r_seg.half_length*r_seg.direction
r_end = r_seg.center + r_seg.half_length*r_seg.direction
r_linestring = LineString([r_start, r_end])
road_segment_linestrings.append(r_linestring)
for seg_idx in np.arange(len(road_segments)):
print seg_idx
for track_idx in np.arange(len(tracks)):
if road_segment_linestrings[seg_idx].distance(simplified_tracks[track_idx]) > 1.2*road_segments[seg_idx].half_width:
continue
track = tracks[track_idx]
if len(track.utm) <= 1:
continue
for utm_idx in np.arange(len(track.utm)):
utm = track.utm[utm_idx]
if utm_idx == 0:
direction = np.array([track.utm[utm_idx+1][0], track.utm[utm_idx+1][1]]) - \
np.array([track.utm[utm_idx][0], track.utm[utm_idx][1]])
elif utm_idx == len(track.utm) - 1:
direction = np.array([track.utm[utm_idx][0], track.utm[utm_idx][1]]) - \
np.array([track.utm[utm_idx-1][0], track.utm[utm_idx-1][1]])
else:
direction = np.array([track.utm[utm_idx+1][0], track.utm[utm_idx+1][1]]) - \
np.array([track.utm[utm_idx-1][0], track.utm[utm_idx-1][1]])
direction /= np.linalg.norm(direction)
if np.dot(direction, road_segments[seg_idx].direction) < np.cos(np.pi/4.0):
continue
pt = Point(utm[0], utm[1])
if pt.distance(road_segment_linestrings[seg_idx]) < 1.2*road_segments[seg_idx].half_width:
track_on_road[seg_idx].add(track_idx)
break
return track_on_road
def test_operations(self):
point = Point(0.0, 0.0)
# General geometry
self.assertEqual(point.area, 0.0)
self.assertEqual(point.length, 0.0)
self.assertAlmostEqual(point.distance(Point(-1.0, -1.0)),
1.4142135623730951)
# Topology operations
# Envelope
self.assertIsInstance(point.envelope, Point)
# Intersection
self.assertIsInstance(point.intersection(Point(-1, -1)),
GeometryCollection)
# Buffer
self.assertIsInstance(point.buffer(10.0), Polygon)
self.assertIsInstance(point.buffer(10.0, 32), Polygon)
# Simplify
p = loads('POLYGON ((120 120, 121 121, 122 122, 220 120, 180 199, '
'160 200, 140 199, 120 120))')
expected = loads('POLYGON ((120 120, 140 199, 160 200, 180 199, '
'220 120, 120 120))')
s = p.simplify(10.0, preserve_topology=False)
self.assertTrue(s.equals_exact(expected, 0.001))
p = loads('POLYGON ((80 200, 240 200, 240 60, 80 60, 80 200),'
'(120 120, 220 120, 180 199, 160 200, 140 199, 120 120))')
expected = loads(
'POLYGON ((80 200, 240 200, 240 60, 80 60, 80 200),'
'(120 120, 220 120, 180 199, 160 200, 140 199, 120 120))')
s = p.simplify(10.0, preserve_topology=True)
self.assertTrue(s.equals_exact(expected, 0.001))
# Convex Hull
self.assertIsInstance(point.convex_hull, Point)
# Differences
self.assertIsInstance(point.difference(Point(-1, 1)), Point)
self.assertIsInstance(point.symmetric_difference(Point(-1, 1)),
MultiPoint)
# Boundary
self.assertIsInstance(point.boundary, GeometryCollection)
# Union
self.assertIsInstance(point.union(Point(-1, 1)), MultiPoint)
self.assertIsInstance(point.representative_point(), Point)
self.assertIsInstance(point.centroid, Point)
# Relate
self.assertEqual(point.relate(Point(-1, -1)), 'FF0FFF0F2')
def getclosestcity(lon,lat):
qp = Point(lon,lat)
cities = meta.Session.query(City).filter(cities_table.c.lon!=None).filter(cities_table.c.lat!=None).all()
if not len(cities): return None
distances = sorted([(qp.distance(Point(ct.lon,ct.lat)),ct.name) for ct in cities])
#distances_num = sorted([(qp.distance(Point(ct.lon,ct.lat)),ct.id) for ct in cities]) ; raise Exception('distance from (%s,%s) - %s'%(lon,lat,distances_num))
rt = distances[0][1]
return rt
def test_point_point():
p1 = Point(0,0)
p2 = Point(1,1)
ok_(p1.geom_type=='Point', p1.geom_type)
assert_ae(p1.coords[:][0], (0,0))
d = p1.distance(p2)
assert_eq(d, sqrt(2))
def cartesiandistance(origin, destination):
lon1, lat1 = origin
lon2, lat2 = destination
proj = Proj(init="epsg:3785") # spherical mercator, should work anywhere
point1 = proj(lon1, lat1)
point2 = proj(lon2, lat2)
point1_cart = Point(point1)
point2_cart = Point(point2)
return point1_cart.distance(point2_cart) #meters
def project2(p1, p2, p3):
"""Project a Point, p3 onto a line intersecting Points p1 and p2.
Adapted from tutorial by Paul Bourke: http://paulbourke.net/geometry/pointline/
This projection function allows for points at negative distances.
Parameters:
p1 (Point) : point at zero distance on line between p1 and p2.
p2 (Point) : endpoint on line.
p3 (Point) : the point to project.
Returns:
result (dict) : the projected Point, distance along line, offset from line, and fractional distance along line.
"""
x_delta = p2.x - p1.x
y_delta = p2.y - p1.y
if x_delta == 0 and y_delta == 0:
logger.warning("p1 and p2 cannot be the same point")
return
u = ((p3.x - p1.x) * x_delta + (p3.y - p1.y) * y_delta) / (x_delta * x_delta + y_delta * y_delta)
pt = Point(p1.x + u * x_delta, p1.y + u * y_delta, p3.z)
# calculate distance along the line from p1
if u < 0:
d = -pt.distance(p1)
else:
d = pt.distance(p1)
# calculate the offset distance of p3 from the line
if (p1.y - p2.y) * (p3.x - p2.x) - (p1.x - p2.x) * (p3.y - p2.y) < 0:
offset = -pt.distance(p3) # the point is offset left of the line
else:
offset = pt.distance(p3) # the point is offset right of the line
result = {'pt':pt, 'd':d, 'o':offset, 'u':u}
return result
def distance_point_to_polygon(point, poly):
"""
Compute the minimum distance from a point to a polygon
:param point:
:param poly:
:return: the distance
"""
p = Point(point)
pol = Polygon(poly)
if not pol.is_valid:
pol = MultiPoint(poly).convex_hull
return p.distance(pol)
def score(ob):
g = geom(ob)
r = region
if r is None:
if len(coords) == 2:
r = Point(coords)
else:
r = asShape(box2poly(coords))
# local scaling might be better, degree units are implicit
# in this value
k = 0.2
d = r.distance(g)
return int(math.exp(-d/k) * 1000)
def process_exterior_segment(startInd, endInd, airportInd):
print("Processing exterior segment...")
airport = airports[airportInd]
startPt = Point(lineX[startInd], lineY[startInd])
# The probability the the crash happens in this segment
segCrashProb = abs(endInd - startInd) / float(nLinePts)
# The line that is just this segment
segLine = LineString([(lineX[startInd], lineY[startInd]), \
(lineX[endInd-1] , lineY[endInd-1] )])
# Reflected point, used for clipping end
dX = lineX[endInd-1] - lineX[startInd]
dY = lineY[endInd-1] - lineY[startInd]
refPt = Point(lineX[endInd-1] + dX, lineY[endInd-1] + dY)
for i in range(dim.x_res):
for j in range(dim.y_res):
# Coordinates of this point
pX = p_y[i]
pY = p_x[j]
pt = Point(pX, pY)
# Skip points which are off the end of this line
if(pt.distance(refPt) < pt.distance(startPt)):
continue
dist = pt.distance(segLine)
prob = segCrashProb * (dAlongLine / segLine.length) * \
(distribSmall.cdf(dist + 0.5 * dPerpLine) - distribSmall.cdf(dist - 0.5 * dPerpLine))
probs[i,j] += prob
def is_on_surface(self, moveable_obj, edge_index):
edge = self.vertices_of_edges[edge_index]
center_x, center_y = moveable_obj.position
gravity_vec = Line([moveable_obj.position, (center_x, 0)])
edge_line = Line(edge).buffer(1)
radius = moveable_obj.fixtures[0].shape.radius
center = Point(center_x, center_y)
circle = center.buffer(radius)
if circle.intersects(edge_line):
if self.is_edge_surface[edge_index] == 1 and gravity_vec.intersects(edge_line):
return True, 0
return False, center.distance(edge_line)
def find_nearest(obs_lat,obs_lon, lats,lons):
point1 = Point(obs_lon,obs_lat)
dist = 999999999
index_i = -1
index_j = -1
for i in range(0,len(lats)):
for j in range(0,len(lons)):
point2 = Point(lons[j], lats[i])
val = point1.distance(point2)
if val < dist:
index_i = i
index_j = j
dist = val
return [index_i,index_j,dist]
def getJSONs(route,direction):
trip_ids = amtrak.trips[(amtrak.trips['route_id'].astype(str) == str(route).replace('%20', ' ')) & (amtrak.trips['direction_id'] == int(direction))]['trip_id']
stops = pandas.merge(pandas.DataFrame(trip_ids),amtrak.stop_times)
# trip_ids = amtrak.trips.loc[str(route).replace('%20', ' ')]['trip_id']
# stops = pandas.merge(pandas.DataFrame(trip_ids),amtrak.stop_times.loc[str(direction).replace('%20',' ')])
trains = stops.groupby('trip_id')
stop_ids = []
for index, train in trains:
train = train.sort('stop_sequence')
stop_ids = combine(stop_ids,list(train['stop_id']))
previousStop = False
distances = []
stopLocations = []
lineStrings = []
for stop in stop_ids:
if previousStop:
currentStop = Point(float(amtrak.stops.loc[stop]['stop_lon']),float(amtrak.stops.loc[stop]['stop_lat']))
distanceToPreviousStop = 65.93*currentStop.distance(previousStop)
distances.append(distanceToPreviousStop)
lineStrings.append(LineString([list(currentStop.coords)[0],list(previousStop.coords)[0]]))
previousStop = Point(float(amtrak.stops.loc[stop]['stop_lon']),float(amtrak.stops.loc[stop]['stop_lat']))
stopLocations.append(previousStop)
times = []
for index, train in trains:
time = []
departureTime = False
for stop in stop_ids:
if stop in list(train['stop_id']):
if departureTime:
h, m, s = map(int,list(train[train['stop_id'] == stop]['arrival_time'])[0].split(':'))
arrivalTime = timedelta(hours=h, minutes=m, seconds=s)
delta = arrivalTime - departureTime
time.append(delta.total_seconds()/60/60)
h, m, s = map(int,list(train[train['stop_id'] == stop]['departure_time'])[0].split(':'))
departureTime = timedelta(hours=h, minutes=m, seconds=s)
else:
time.append(0)
times.append(time)
stopsGDF = geopandas.GeoDataFrame(stopLocations,stop_ids)
stopsGDF.columns = ['geometry']
distancesS = pandas.Series(distances)
timesDF = pandas.DataFrame(times)
timesDF = timesDF.replace(0.0, numpy.nan)
# speedS = distancesS / timesDF.max()
# speedS = distancesS / timesDF.min()
speedS = distancesS / timesDF.mean()
speedS = speedS.round(2)
speedGDF = geopandas.GeoDataFrame(lineStrings,speedS)
speedGDF.columns = ['geometry']
return [stopsGDF.to_json(), speedGDF.to_json()]
def graph_from_voronoi(vor, geometry):
"""
Creates a networkx graph out of all Voronoi ridge vertices which are inside
the original geometry.
"""
graph = nx.Graph()
for i in vor.ridge_vertices:
if i[0]>-1 and i[1]>-1:
point1 = Point(vor.vertices[i][0])
point2 = Point(vor.vertices[i][1])
# Eliminate all points outside our geometry.
if point1.within(geometry) and point2.within(geometry):
dist = point1.distance(point2)
graph.add_nodes_from([i[0], i[1]])
graph.add_edge(i[0], i[1], weight=dist)
return graph
def findSFOIndexs(lats,lons,lat_lon_list):
index_list = []
dist_list = []
for val in lat_lon_list:
point1 = Point(val[1],val[0])
dist = 999999999
index = -1
for i in range(0,len(lats)):
point2 = Point(lons[i], lats[i])
val = point1.distance(point2)
if val < dist:
index = i
dist = val
index_list.append(index)
dist_list.append(dist)
return index_list,dist_list
def closestCellFromPt(lon, lat, lonArray, latArray, obsArray, obsFillValue, landMaskArray):
latlon = Point(lon,lat)
lastDistance = None
n,m = np.shape(lonArray)
cellPoint = None
for i in range(0,n):
for j in range(0,m):
#We have to be in the water, and the cell has to have a valid observation values.
if(landMaskArray[i,j] == 1 and obsArray[i,j] != obsFillValue):
gridPt = Point(lonArray[i,j],latArray[i,j])
curDist = latlon.distance(gridPt)
if(lastDistance == None or curDist < lastDistance):
lastDistance = curDist
cellPoint = Point(i,j)
return(cellPoint)
def nodes_for_point(self, point, all_nodes):
point = Point(point.x, point.y)
nodes = {}
if self.nodes:
for node in self.nodes:
node = all_nodes[node]
line = LineString([(node.x, node.y), (point.x, point.y)])
if line.length < 10 and not self.clear_geometry_prep.intersects(line):
nodes[node.i] = (None, None)
if not nodes:
nearest_node = min(tuple(all_nodes[node] for node in self.nodes),
key=lambda node: point.distance(node.point))
nodes[nearest_node.i] = (None, None)
else:
nodes = self.fallback_nodes
return nodes
def match(societies, regions):
for society in societies:
point = Point(float(society['Long']), float(society['Lat']))
mindist, nearestregion = None, None
for region in regions:
polygon = shape(region['geometry'])
if polygon.contains(point):
yield society, region
break
dist = point.distance(polygon)
if mindist is None or mindist > dist:
mindist, nearestregion = dist, region
else:
assert mindist is not None
print society['soc_id'], nearestregion['properties']['REGION_NAM'], mindist
yield society, nearestregion
def _enumerate_close(lon, lat, shapes, th=None):
"""
Enumerate close streets from a starting point.
@param lon longitude
@param lat latitude
@param shapes list of streets
@param th threshold or None for all
@return iterator on *tuple(distance, i)*
"""
from shapely.geometry import Point, LineString
p = Point(lon, lat)
for i, shape in enumerate(shapes):
obj = LineString(shape.points)
d = p.distance(obj)
if th is None or d <= th:
yield d, i
def findSFOIndexs(lats, lons, lat_lon_list):
index_list, dist_list = [], []
for val in lat_lon_list:
point1 = Point(val[1], val[0])
dist = 999999999
index = -1
for k in range(0, len(lats)):
point2 = Point(lons[k], lats[k])
val = point1.distance(point2)
if val < dist:
index = k
dist = val
index_list.append(index)
dist_list.append(dist)
sorted_list = sorted(zip(index_list, dist_list))
index_list = [x[0] for x in sorted_list]
dist_list = [x[1] for x in sorted_list]
return index_list, dist_list
def find_nearest(obs_lat, obs_lon, lats, lons):
"""
Find the closest point, distance in degrees
(coordinates of the points in degrees).
"""
point1 = Point(obs_lon, obs_lat)
dist = 999999999
index_i, index_j = -1, -1
for i in range(0, len(lats)):
for j in range(0, len(lons)):
point2 = Point(lons[j], lats[i])
val = point1.distance(point2)
if val < dist:
index_i = i
index_j = j
dist = val
return [index_i, index_j, dist]
def populate_school_geo():
# wow, this is a hard find: Baidu's geocode is not correct on Google map!
# So we use Baidu's as a reference, and iterate through all available Google's geocode
# results by distance match, and find the closest one to use!
for idx, s in enumerate(MySchool.objects.all()):
if not (s.google_geocode and s.lat and s.lng): continue
print idx, s.name
ref = Point(s.lat,s.lng)
min_dist = 1000000
min_pair = None
for g in filter(lambda x: x.has_key('geometry'), s.google_geocode):
lat,lng = Decimal(g[u'geometry'][u'location'][u'lat']), Decimal(g[u'geometry'][u'location'][u'lng'])
dist = ref.distance(Point(lat,lng))
if dist < min_dist:
min_dist = dist
min_pair = (lat,lng)
if min_pair:
s.lat, s.lng = min_pair
s.save()
print idx, 'updated...... next >'
def dist_to_layer(elon, elat, geom):
"""
Return the distance from a point to the polygon(s) in a layer; zero if
the point is inside the polygon. If the nearest edge of the polygon is
greater than 5000 km from the point, the point cannot be inside the
polygon and the distance reported will be the distance to the nearest
edge. So don't make polygons too big.
Args:
elon (float): The longitude of the reference point.
elat (float): The latitude of the reference point.
geom (Polygon or MultiPolygon): An instance of a shapely Polygon
or MultiPolygon.
Returns:
float: The distance (in km) from the reference point to the
nearest polygon in the layer. The distance will be zero if the
point lies inside the polygon.
"""
if isinstance(geom, Polygon):
plist = [geom]
elif isinstance(geom, MultiPolygon):
plist = list(geom.geoms)
else:
raise TypeError('Invalid geometry type in layer: %s' % type(geom))
project = partial(
pyproj.transform,
pyproj.Proj(proj='latlong'),
pyproj.Proj(proj='aeqd +lat_0=%f +lon_0=%f +R=6371' % (elat, elon)))
ep = Point(0.0, 0.0)
min_dist = 99999.
for poly in plist:
nearest = nearest_edge(elon, elat, poly)
if nearest < 5000:
nearest = ep.distance(transform(project, poly))
if nearest < min_dist:
min_dist = nearest
if min_dist == 0:
break
return min_dist
def removebadfacets(self, base, doverh=.1):
"""
remove the facets that cannot support stable placements
:param: doverh: d is the distance of mproj to supportfacet boundary, h is the height of com
when fh>dmg, the object tends to fall over. setting doverh to 0.033 means
when f>0.1mg, the object is judged to be unstable
:return:
author: weiwei
date: 20161213
"""
self.tpsmat4s = []
for i in range(len(self.ocfacets)):
geom = pg.packpandageom(self.objtrimeshconv.vertices,
self.objtrimeshconv.face_normals[self.ocfacets[i]],
self.objtrimeshconv.faces[self.ocfacets[i]])
geombullnode = cd.genCollisionMeshGeom(geom)
self.bulletworldray.attachRigidBody(geombullnode)
pFrom = Point3(self.objcom[0], self.objcom[1], self.objcom[2])
pTo = self.objcom+self.ocfacetnormals[i]*99999
pTo = Point3(pTo[0], pTo[1], pTo[2])
result = self.bulletworldray.rayTestClosest(pFrom, pTo)
self.bulletworldray.removeRigidBody(geombullnode)
if result.hasHit():
hitpos = result.getHitPos()
facetinterpnt = np.array([hitpos[0],hitpos[1],hitpos[2]])
facetnormal = np.array(self.ocfacetnormals[i])
bdverts3d, bdverts2d, facetmat4 = pg.facetboundary(self.objtrimeshconv, self.ocfacets[i],
facetinterpnt, facetnormal)
facetp = Polygon(bdverts2d)
facetinterpnt2d = rm.transformmat4(facetmat4, facetinterpnt)[:2]
apntpnt = Point(facetinterpnt2d[0], facetinterpnt2d[1])
dist2p = apntpnt.distance(facetp.exterior)
dist2c = np.linalg.norm(np.array([hitpos[0],hitpos[1],hitpos[2]])-np.array([pFrom[0],pFrom[1],pFrom[2]]))
if dist2p/dist2c >= doverh:
# hit and stable
self.tpsmat4s.append(pg.cvtMat4np4(facetmat4))
def infer_reward_state(self, steering_angle, speed):
try:
self.set_next_state()
except Exception as ex:
utils.json_format_logger(
"Unable to retrieve image from queue: {}".format(ex),
**utils.build_system_error_dict(
utils.SIMAPP_ENVIRONMENT_EXCEPTION,
utils.SIMAPP_EVENT_ERROR_CODE_500))
# Read model state from Gazebo
model_state = utils.gazebo_service_call(self.get_model_state,
'racecar', '')
model_orientation = Rotation.from_quat([
model_state.pose.orientation.x, model_state.pose.orientation.y,
model_state.pose.orientation.z, model_state.pose.orientation.w
])
model_location = np.array([
model_state.pose.position.x,
model_state.pose.position.y,
model_state.pose.position.z]) + \
model_orientation.apply(RELATIVE_POSITION_OF_FRONT_OF_CAR)
model_point = Point(model_location[0], model_location[1])
model_heading = model_orientation.as_euler('zyx')[0]
# Read the wheel locations from Gazebo
left_rear_wheel_state = utils.gazebo_service_call(
self.get_link_state, 'racecar::left_rear_wheel', '')
left_front_wheel_state = utils.gazebo_service_call(
self.get_link_state, 'racecar::left_front_wheel', '')
right_rear_wheel_state = utils.gazebo_service_call(
self.get_link_state, 'racecar::right_rear_wheel', '')
right_front_wheel_state = utils.gazebo_service_call(
self.get_link_state, 'racecar::right_front_wheel', '')
wheel_points = [
Point(left_rear_wheel_state.link_state.pose.position.x,
left_rear_wheel_state.link_state.pose.position.y),
Point(left_front_wheel_state.link_state.pose.position.x,
left_front_wheel_state.link_state.pose.position.y),
Point(right_rear_wheel_state.link_state.pose.position.x,
right_rear_wheel_state.link_state.pose.position.y),
Point(right_front_wheel_state.link_state.pose.position.x,
right_front_wheel_state.link_state.pose.position.y)
]
# Project the current location onto the center line and find nearest points
current_ndist = self.center_line.project(model_point, normalized=True)
prev_index, next_index = self.find_prev_next_waypoints(current_ndist)
distance_from_prev = model_point.distance(
Point(self.center_line.coords[prev_index]))
distance_from_next = model_point.distance(
Point(self.center_line.coords[next_index]))
closest_waypoint_index = (
prev_index, next_index)[distance_from_next < distance_from_prev]
# Compute distance from center and road width
nearest_point_center = self.center_line.interpolate(current_ndist,
normalized=True)
nearest_point_inner = self.inner_border.interpolate(
self.inner_border.project(nearest_point_center))
nearest_point_outer = self.outer_border.interpolate(
self.outer_border.project(nearest_point_center))
distance_from_center = nearest_point_center.distance(model_point)
distance_from_inner = nearest_point_inner.distance(model_point)
distance_from_outer = nearest_point_outer.distance(model_point)
track_width = nearest_point_inner.distance(nearest_point_outer)
is_left_of_center = (distance_from_outer < distance_from_inner) if self.reverse_dir \
else (distance_from_inner < distance_from_outer)
# Convert current progress to be [0,100] starting at the initial waypoint
if self.reverse_dir:
current_progress = self.start_ndist - current_ndist
else:
current_progress = current_ndist - self.start_ndist
if current_progress < 0.0: current_progress = current_progress + 1.0
current_progress = 100 * current_progress
if current_progress < self.prev_progress:
# Either: (1) we wrapped around and have finished the track,
delta1 = current_progress + 100 - self.prev_progress
# or (2) for some reason the car went backwards (this should be rare)
delta2 = self.prev_progress - current_progress
current_progress = (self.prev_progress, 100)[delta1 < delta2]
# Car is off track if all wheels are outside the borders
wheel_on_track = [self.road_poly.contains(p) for p in wheel_points]
all_wheels_on_track = all(wheel_on_track)
any_wheels_on_track = any(wheel_on_track)
# Simulation elapsed time, which may be faster or slower than wall time
simulation_time = rospy.get_rostime()
# Compute the reward
reward = 0.0
if any_wheels_on_track:
done = False
params = {
'all_wheels_on_track': all_wheels_on_track,
'x': model_point.x,
'y': model_point.y,
'heading': model_heading * 180.0 / math.pi,
'distance_from_center': distance_from_center,
'progress': current_progress,
'steps': self.steps,
'speed': speed,
'steering_angle': steering_angle * 180.0 / math.pi,
'track_width': track_width,
'waypoints': list(self.center_line.coords),
'closest_waypoints': [prev_index, next_index],
'is_left_of_center': is_left_of_center,
'is_reversed': self.reverse_dir,
'action': self.action_taken
}
try:
reward = float(self.reward_function(params))
except Exception as e:
utils.json_format_logger(
"Error in the reward function: {}".format(e),
**utils.build_user_error_dict(
utils.SIMAPP_SIMULATION_WORKER_EXCEPTION,
utils.SIMAPP_EVENT_ERROR_CODE_400))
traceback.print_exc()
utils.simapp_exit_gracefully()
else:
done = True
reward = CRASHED
# Reset if the car position hasn't changed in the last 2 steps
prev_pnt_dist = min(model_point.distance(self.prev_point),
model_point.distance(self.prev_point_2))
if prev_pnt_dist <= 0.0001 and self.steps % NUM_STEPS_TO_CHECK_STUCK == 0:
done = True
reward = CRASHED # stuck
# Simulation jobs are done when progress reaches 100
if current_progress >= 100:
done = True
# Keep data from the previous step around
self.prev_point_2 = self.prev_point
self.prev_point = model_point
self.prev_progress = current_progress
# Set the reward and done flag
self.reward = reward
self.reward_in_episode += reward
self.done = done
# Trace logs to help us debug and visualize the training runs
# btown TODO: This should be written to S3, not to CWL.
logger.info(
'SIM_TRACE_LOG:%d,%d,%.4f,%.4f,%.4f,%.2f,%.2f,%d,%.4f,%s,%s,%.4f,%d,%.2f,%s,%.4f\n'
%
(self.episodes, self.steps, model_location[0], model_location[1],
model_heading, self.steering_angle, self.speed, self.action_taken,
self.reward, self.done, all_wheels_on_track, current_progress,
closest_waypoint_index, self.track_length, time.time(),
float(simulation_time.secs) + float(simulation_time.nsecs) / 1e9))
#build json record of the reward metrics
reward_metrics = OrderedDict()
reward_metrics['episode'] = self.episodes
reward_metrics['steps'] = self.steps
reward_metrics['X'] = model_location[0]
reward_metrics['Y'] = model_location[1]
reward_metrics['yaw'] = model_heading
reward_metrics['steer'] = self.steering_angle
reward_metrics['throttle'] = self.speed
reward_metrics['action'] = self.action_taken
reward_metrics['reward'] = self.reward
reward_metrics['done'] = self.done
reward_metrics['all_wheels_on_track'] = all_wheels_on_track
reward_metrics['progress'] = current_progress
reward_metrics['closest_waypoint'] = closest_waypoint_index
reward_metrics['track_len'] = self.track_length
reward_metrics['tstamp'] = time.time()
self.simtrace_data.write_simtrace_data(reward_metrics)
# Terminate this episode when ready
if done and node_type == SIMULATION_WORKER:
self.finish_episode(current_progress)
flat = list(sum(intersection_index, ()))
conn_per_wire = Counter(flat)
# checking for isolated wires
complete_list = range(nwires_plus_leads)
isolated_wires = [x for x in complete_list if not x in flat]
# list containing the length segments of each wire (if it has a junction)
each_wire_length_storage = [[] for _ in range(nwires_plus_leads)]
# Routine that obtains the segment lengths on each wire
for i in each_wire_inter_point_storage:
point_ini = Point(mlines[i].coords[0]) # Initial point of the wire
point_fin = Point(mlines[i].coords[1]) # Final point of the wire
wlength = point_ini.distance(point_fin) # Whole length
wire_points = each_wire_inter_point_storage[i]
dist = [0.0] * (len(wire_points) + 1)
for j in range(len(wire_points)):
point = Point(wire_points[j])
dist[j] = point_ini.distance(point)
dist[
-1] = wlength # Whole length stored on the last component of dist vector.
dist.sort() # Sorting in crescent order
dist_sep = [0.0] * len(dist)
dist_sep[0] = dist[0]
dist_sep[1:len(dist)] = [
dist[k] - dist[k - 1] for k in range(1, len(dist))
#print math.sqrt((x0-x1)**2+(y0-y1)**2)
return x1, y1
def project((x, y), (x0, y0, x1, y1)):
line = LineString([(x0, y0), (x1, y1)])
p = Point(x, y)
return list(line.interpolate(line.project(p)).coords)[0]
def dist((x, y), (x0, y0, x1, y1)):
line = LineString([(x0, y0), (x1, y1)])
p = Point(x, y)
#_x, _y = list(line.interpolate(line.project(p)).coords)[0]
#return distance(x, y, _x, _y, utm=True)
return p.distance(line)
def scale_map_by_axis(map_df, axis):
x0, x1, y0, y1 = axis
rids = set(map_df[(map_df.x > x0) & (map_df.x < x1)\
& (map_df.y > y0) & (map_df.y < y1)].rid)
map_df.index = map_df.rid
map_df = map_df.ix[rids]
return map_df
'''
build a r-tree index for map
'''
def transportation_Analysis(self, lineAnalysis=False, extern_Graph=None):
if extern_Graph != None:
self.graph = extern_Graph
fichierCSV = open('data1.csv', 'w')
csvData = open('data2.csv', 'w')
isDiGraph = nx.DiGraph()
noDiGraph = nx.Graph()
default_counter = 1
fichier = open('notes.txt', 'w')
nb_relations, relations_count = len(self.relations), 1
means = ['bus', 'subway', 'tram', 'light_rail']
list_of_diGraphs = []
for keyOsmid, relValues in self.relations.items():
if relations_count < 0:
print("RELATION NUMBER ", relations_count, "SKIPPED")
relations_count += 1
continue
tags, members = relValues['tags'], relValues['membs']
print("PROGRESS : ", relations_count, "/", nb_relations)
# STEP 1 : Determine if the relation is linked to a transportation system and draw the line
if (('route' in tags) and (tags['route'] in means)) or (
('route_master' in tags) and
(tags['route_master'] in means)) or (
('type' in tags) and ('public_transport' in tags)):
try:
mean = tags['route']
except:
try:
mean = tags['route_master']
except:
mean = 'stop_area'
G = tla.elements_du_graphe(self.graph,
isDiGraph,
noDiGraph,
keyOsmid,
tags,
members,
self.nodes,
self.ways,
self.coords,
default_counter,
fichierCSV,
csvData,
self.stations,
self.nodes_residue,
type_tr=mean)
else:
if 'route' in tags:
print("The algorithm doesn't process this route : ",
tags['route'])
else:
print("The algorithm doesn't process this relation : ",
tags)
print('\n')
relations_count += 1
continue
if type(G) is int:
relations_count += 1
continue
else:
if len(G) == 1: # CASE OF STOP AREA
self.graph = G[0]
relations_count += 1
print('\n')
continue
else:
self.graph, isDiGraph, noDiGraph, ways_in_relation, relation_station, relation_platforms, info_name, default_counter, self.stations, self.nodes_residue = G[
0], G[1], G[2], G[3], G[4], G[5], G[6], G[7], G[8], G[
9]
print("STEP 1 COMPLETE , FINAL GRAPH STATE : ",
len(list(self.graph.edges)), " EDGES ; ",
len(list(self.graph.nodes)), " NODES ")
# STEP 2 : ORIENTING THE GRAPH
# On essaye dans un premier temps de déterminer les terminus grâce au nom de ligne
R = tla.analyse_lexicale(self.graph,
noDiGraph,
isDiGraph,
info_name,
relation_station,
fichier,
tags,
type_mobility=mean)
self.graph, noDiGraph, isDiGraph, res, departure, arrival = R[
0], R[1], R[2], R[3], R[4], R[5]
if res == 0:
R = tla.analyse_lexicogeographique(self.graph,
noDiGraph,
isDiGraph,
info_name,
relation_station,
fichier,
ways_in_relation,
departure,
arrival,
type_mobility=mean)
self.graph, noDiGraph, isDiGraph, res = R[0], R[1], R[2], R[3]
if res == 0:
R = tla.redirection_par_defaut(self.graph,
noDiGraph,
isDiGraph,
info_name,
relation_station,
fichier,
ways_in_relation,
type_mobility=mean)
if type(R) == int:
self.to_eulerian[info_name] = relation_station
relations_count += 1
continue
else:
self.graph, noDiGraph, isDiGraph = R[0], R[1], R[2]
#fichierCSV.write(info_name.encode('utf-8') + ";" + str("Default") + "\n")
else:
#fichierCSV.write(info_name.encode('utf-8') + ";" + str("Level 2") + "\n")
pass
else:
#fichierCSV.write(info_name.encode('utf-8') + ";" + str("Level 1") + "\n")
pass
# Tracé des cycles
R = tla.trace_cycle(self.graph,
noDiGraph,
isDiGraph,
info_name,
relation_station,
fichier,
type_mobility=mean)
self.graph, noDiGraph, isDiGraph = R[0], R[1], R[2]
print("STEP 2 COMPLETE , FINAL GRAPH STATE : ",
len(list(self.graph.edges)), " EDGES ; ",
len(list(self.graph.nodes)), " NODES ")
# ETAPE 3a : On rajoute les plateformes : simplifiés en noeud centroïde [exclusif bus pour l'instant]
#Rq : mise à la fin pour éviter les conflits de degré de noeuds
if mean in ['bus', 'light_rail', 'tram']:
utiliZation = "Bus Station" if mean == 'bus' else "Tramway Station" if mean == 'tram' else "Light Rail Station" if mean == 'light_rail' else "Undfined Station"
for key, value in relation_platforms.items():
list_of_nodes = value[0]
longs, latts = [], []
for nodei in range(len(list_of_nodes)):
longs.append(
self.nodes[list_of_nodes[nodei]]['coords'][0])
latts.append(
self.nodes[list_of_nodes[nodei]]['coords'][1])
moy_longs = float(sum(longs) / len(longs))
moy_latts = float(sum(latts) / len(longs))
s_point = Point(moy_longs, moy_latts)
adde = -int(hashlib.md5(s_point.wkt).hexdigest(), 16)
isDiGraph.add_node(adde,
longitude=moy_longs,
latitude=moy_latts,
nom=value[1],
utilisation=utiliZation,
ligne=info_name)
self.graph.add_node(adde,
longitude=moy_longs,
latitude=moy_latts,
nom=value[1],
utilisation=utiliZation,
ligne=info_name)
nearestCouple = {}
edges = list(isDiGraph.edges)
for p in range(len(edges)):
linestring = geojson.LineString([
(isDiGraph.nodes[edges[p][0]]['longitude'],
isDiGraph.nodes[edges[p][0]]['latitude']),
(isDiGraph.nodes[edges[p][1]]['longitude'],
isDiGraph.nodes[edges[p][1]]['latitude'])
])
feature = geojson.Feature(geometry=linestring,
properties={
"node1": edges[p][0],
"node2": edges[p][1]
})
candidate = geojson.dumps(feature)
line = json.loads(candidate)
nearestCouple[s_point.distance(
LineString(line['geometry']['coordinates']))] = (
line['properties'].values())
if nearestCouple != {}:
proche_Edge = min(nearestCouple.keys())
#print proche_Edge
#print "A", nearestCouple[proche_Edge]
if proche_Edge < 0.0001:
R = linkNode_OSM(isDiGraph,
adde,
nearestCouple[proche_Edge],
diriged=True,
bus=True)
isDiGraph, new_node, u, v = R[0], R[1], R[2], R[3]
self.graph.add_node(
new_node,
utilisation='Link Platform_BusLine',
ligne=info_name)
new_node_attributes = {
new_node: isDiGraph.nodes[new_node]
}
#print new_node_attributes
nx.set_node_attributes(self.graph,
new_node_attributes)
use = 'Platform_to_' + str(mean.capitalize())
waiting_time = tla.waiting_bus_time if mean == 'bus' else tla.waiting_trm_time if (
mean == 'tram' or mean == 'light_rail'
) else tla.waiting_bus_time
isDiGraph.add_edge(
adde,
new_node,
type_mobility=use,
ligne=info_name,
time_travel=waiting_time) # Entry
isDiGraph.add_edge(new_node,
adde,
type_mobility=use,
ligne=info_name,
time_travel=0) # Exit
else:
continue
else:
continue
print("STEP 3 COMPLETE , FINAL GRAPH STATE : ",
len(list(self.graph.edges)), " EDGES ; ",
len(list(self.graph.nodes)), " NODES ")
# STEP 4 : On raccorde les stations intermdiaires représentées que par des points
#Rq : mise à la fin pour éviter les conflits de degré de noeuds
for key, value in relation_station.items():
if isDiGraph.degree[key] == 0:
node_to_link = key
s_point = Point([value['coords'][0], value['coords'][1]])
nearestCouple = {}
edges = list(isDiGraph.edges)
for p in range(len(edges)):
#print edges[p][0], isDiGraph.nodes[edges[p][0]], edges[p][1], isDiGraph.nodes[edges[p][1]]
linestring = geojson.LineString([
(isDiGraph.nodes[edges[p][0]]['longitude'],
isDiGraph.nodes[edges[p][0]]['latitude']),
(isDiGraph.nodes[edges[p][1]]['longitude'],
isDiGraph.nodes[edges[p][1]]['latitude'])
])
feature = geojson.Feature(geometry=linestring,
properties={
"node1": edges[p][0],
"node2": edges[p][1]
})
candidate = geojson.dumps(feature)
line = json.loads(candidate)
nearestCouple[s_point.distance(
LineString(line['geometry']['coordinates']))] = (
line['properties'].values())
if nearestCouple != {}:
proche_Edge = min(nearestCouple.keys())
#print proche_Edge
#print "A", nearestCouple[proche_Edge]
if proche_Edge < 0.0001:
R = linkNode_OSM(isDiGraph,
node_to_link,
nearestCouple[proche_Edge],
diriged=True,
bus=True)
isDiGraph, new_node, u, v = R[0], R[1], R[2], R[3]
self.graph.add_node(
new_node,
utilisation='Link Station_BusLine',
ligne=info_name)
new_node_attributes = {
new_node: isDiGraph.nodes[new_node]
}
#print new_node_attributes
nx.set_node_attributes(self.graph,
new_node_attributes)
if mean in ['bus', 'light_rail', 'tram']:
use = 'Station_to_' + str(mean.capitalize())
waiting_time = tla.waiting_bus_time if mean == 'bus' else tla.waiting_trm_time if (
mean == 'tram' or mean == 'light_rail'
) else tla.waiting_bus_time
isDiGraph.add_edge(
node_to_link,
new_node,
type_mobility=use,
ligne=info_name,
time_travel=waiting_time) # Entry
isDiGraph.add_edge(new_node,
node_to_link,
type_mobility=use,
ligne=info_name,
time_travel=0) # Exit
elif mean == 'subway':
isDiGraph.add_edge(
node_to_link,
new_node,
type_mobility='Subway_Linked',
ligne=info_name,
time_travel=tla.waiting_sub_time)
isDiGraph.add_edge(
new_node,
node_to_link,
type_mobility='Subway_Linked',
ligne=info_name,
time_travel=0)
else:
continue
else:
continue
else:
continue
print("STEP 4 COMPLETE , FINAL GRAPH STATE : ",
len(list(self.graph.edges)), " EDGES ; ",
len(list(self.graph.nodes)), " NODES ")
nx.set_node_attributes(isDiGraph, self.stations)
self.stations = {}
# STEP 4 : ADD INTO THE FINAL GRAPH
if mean == 'bus':
self.graph = tla.replacer_A(isDiGraph, self.graph, info_name)
else:
self.graph = tla.replacer_B(isDiGraph, self.graph, info_name)
print("STEP 5 COMPLETE , FINAL GRAPH STATE : ",
len(list(self.graph.edges)), " EDGES ; ",
len(list(self.graph.nodes)), " NODES ")
print('\n')
isDiGraph.clear()
noDiGraph.clear()
relations_count += 1
fichier.close()
fichierCSV.close()
class LIDAR(object):
def __init__(self, posX, posY, resolution=1., mapRadius=100):
self.x = posX
self.y = posY
self.origin = Point(self.x, self.y)
self.resolution = pi * resolution / 180.0
self.nRays = int(np.floor(2. * pi / self.resolution))
self.measure = np.zeros(self.nRays)
self.pointMap = [None] * self.nRays
self.rays = [None] * self.nRays
self.angles = np.arange(0, 2. * pi, self.resolution)
self.mapRadius = mapRadius
def updatePose(self, delta_x, delta_y, delta_theta):
self.x += delta_x
self.y += delta_y
self.origin = Point(self.x, self.y)
# self.angles += delta_theta
def setPose(self, pos, theta):
self.x = pos[0]
self.y = pos[1]
self.origin = Point(self.x, self.y)
self.angles = np.arange(theta, 2. * pi + theta, self.resolution)
def updateRays(self):
for idx in range(self.nRays):
angle = self.angles[idx]
endPoint = Point(self.x + cos(angle) * self.mapRadius,
self.y + sin(angle) * self.mapRadius)
self.rays[idx] = LineString([self.origin, endPoint])
def rayTracing(self, bodies):
closeBodies = []
for body in bodies:
if self.origin.distance(
body.getOrigin()) <= self.mapRadius + body.radius:
closeBodies.append(body)
self.measure = np.repeat(self.mapRadius, self.nRays)
self.pointMap = [r.boundary[1] for r in self.rays]
for body in closeBodies:
d = self.origin.distance(body.getOrigin())
if (d > body.radius):
alpha = asin(body.radius / d)
midAngle = atan2(body.y - self.y, body.x - self.x)
if (midAngle < 0):
midAngle += 2 * pi
iAngle = midAngle - alpha
fAngle = midAngle + alpha
if (fAngle > 2 * pi):
fAngle -= 2 * pi
if (iAngle < 0):
iAngle += 2 * pi
infeasibleAngles = np.where(self.angles > fAngle)[0]
if (len(infeasibleAngles) > 0):
lastRayIdx = infeasibleAngles[0]
else:
lastRayIdx = 0
infeasibleAngles = np.where(self.angles < iAngle)[0]
if (len(infeasibleAngles) > 0):
idx = infeasibleAngles[-1]
else:
idx = self.nRays
if (idx > lastRayIdx):
idx = idx - self.nRays
else:
idx = 0
lastRayIdx = self.nRays
poly = body.getPolygon()
while idx < lastRayIdx:
ray = self.rays[idx]
distance = self.mapRadius
inter = poly.intersection(ray)
if inter.is_empty:
# radial line doesn't intersect, so skip
idx += 1
continue
if len(inter.coords) > 1:
# ray intersects at multiple points
inter_dict = {}
for p in inter.boundary:
inter_dict[self.origin.distance(p)] = p
distance = min(inter_dict.keys())
intersect = inter_dict[distance]
else:
# ray intersects at one point only
distance = self.origin.distance(inter)
intersect = inter
if (self.measure[idx] > distance):
self.measure[idx] = distance
self.pointMap[idx] = intersect
idx += 1
#
# closeBodies = []
# for body in bodies:
# if self.origin.distance(body.getOrigin()) <= self.mapRadius + body.radius:
# closeBodies.append(body)
#
# self.measure = np.repeat(self.mapRadius,self.nRays)
# self.pointMap = [r.boundary[1] for r in self.rays]
#
# for body in closeBodies:
# lastRayIdx = self.nRays
# idx = 0
# bodyNotFound = True
# poly = body.getPolygon()
# while idx < lastRayIdx:
# ray = self.rays[idx]
# distance = self.mapRadius
# inter = poly.intersection(ray)
#
# if inter.is_empty:
# # radial line doesn't intersect, so skip
# idx += 1
# continue
#
# if len(inter.coords) > 1:
# # ray intersects at multiple points
# inter_dict = {}
# for p in inter.boundary:
# inter_dict[self.origin.distance(p)] = p
# distance = min(inter_dict.keys())
# intersect = inter_dict[distance]
# else:
# # ray intersects at one point only
# distance = self.origin.distance(inter)
# intersect = inter
#
# if(distance < self.mapRadius and bodyNotFound == True):
# # it's the first sign of this body. Let's limit the scan
# if(distance > body.radius):
# alpha = atan((2.*body.radius)/distance) #angle left for scanning
# lastRayIdx = min(lastRayIdx, idx + int(alpha/self.resolution))
# bodyNotFound = False
#
# if(self.measure[idx] > distance):
# self.measure[idx] = distance
# self.pointMap[idx] = intersect
# idx += 1
#
#
#
# polys = [b.getPolygon() for b in bodies]
# radial_sweep = cascaded_union(self.rays)
# all_input_lines = cascaded_union(polys)
# self.measure = np.repeat(self.mapRadius,self.nRays)
# self.pointMap = [None]*self.nRays
# for idx in range(len(radial_sweep)):
# radial_line = radial_sweep[idx]
# inter = radial_line.intersection(all_input_lines)
# if inter.is_empty:
# continue
#
# if len(inter.coords) > 1:
# # ray intersects at multiple points
# inter_dict = {}
# for inter_pt in inter.coords:
# p = Point(inter_pt)
# inter_dict[self.origin.distance(p)] = p
# distance = min(inter_dict.keys())
# intersect = inter_dict[distance]
# else:
# # ray intersects at one point only
# distance = self.origin.distance(inter)
# intersect = inter
#
## if(distance < self.mapRadius):
## if(bodyNotFound == True):
## # it's the first sign of this body. Let's limit the scan
## if(distance > body.radius):
## alpha = asin(body.radius/distance) #angle left for scanning
## lastRayIdx = min(lastRayIdx, idx + int(alpha/self.resolution))
## bodyNotFound = False
#
# if(self.measure[idx] > distance):
# self.measure[idx] = distance
# self.pointMap[idx] = intersect
def sourcedistance(lats, lons, deps, ss, ds, latsta, lonsta, site_length,
nvert, props):
p = float(props.getpvalue())
[x, y] = GMCOMP_coord_tools.ll2utm(lons, lats, numpy.median(lons),
numpy.median(lats))
z = deps
rake = 180 / math.pi * numpy.arctan2(ds, ss)
fault_slip = numpy.sqrt(numpy.power(ss, 2) + numpy.power(ds, 2))
totslip = numpy.sum(fault_slip)
xravel = numpy.ravel(x)
yravel = numpy.ravel(y)
zravel = numpy.ravel(z)
if (nvert == 4):
Z1 = z[:, 0]
Z2 = z[:, 1]
Z3 = z[:, 2]
Z4 = z[:, 3]
X1 = x[:, 0]
X2 = x[:, 1]
X3 = x[:, 2]
X4 = x[:, 3]
Y1 = y[:, 0]
Y2 = y[:, 1]
Y3 = y[:, 2]
Y4 = y[:, 3]
fseg = len(x)
## for i in range (0, fseg):
## XS = [X1[i], X2[i], X3[i]]
## YS = [Y1[i], Y2[i], Y3[i]]
## ZS = [Z1[i], Z2[i], Z3[i]]
##
## [strike, dip] = strikedip(XS, YS, ZS)
Ztor = numpy.amin(numpy.vstack((Z1, Z2, Z3, Z4))) / 1000
atop = numpy.where(numpy.amin(zravel) == zravel)[0]
abot = numpy.where(numpy.amax(zravel) == zravel)[0]
yravelt = numpy.ravel(yravel[atop])
xravelt = numpy.ravel(xravel[atop])
zravelt = numpy.ravel(zravel[atop])
atops = numpy.where((numpy.amin(yravelt) == yravelt))[0]
atopn = numpy.where((numpy.amax(yravelt) == yravelt))[0]
yravelb = numpy.ravel(yravel[abot])
xravelb = numpy.ravel(xravel[abot])
zravelb = numpy.ravel(zravel[abot])
abots = numpy.where((numpy.amin(yravelb) == yravelb))[0]
abotn = numpy.where((numpy.amax(yravelb) == yravelb))[0]
ytopn = yravelt[atopn]
ytops = yravelt[atops]
ybotn = yravelb[abotn]
ybots = yravelb[abots]
xtopn = xravelt[atopn]
xtops = xravelt[atops]
xbotn = xravelb[abotn]
xbots = xravelb[abots]
ztopn = zravelt[atopn]
ztops = zravelt[atops]
zbotn = zravelb[abotn]
zbots = zravelb[abots]
FLen = math.sqrt(
math.pow(xtops[0] - xtopn[0], 2) +
math.pow(ytops[0] - ytopn[0], 2)) / 1000
FWid = math.sqrt(
math.pow(xtops[0] - xbots[0], 2) +
math.pow(ytops[0] - ybots[0], 2) +
math.pow((ztops[0] - zbots[0]) * 1000, 2)) / 1000
XS = [xtops[0], xtopn[0], xbotn[0]]
YS = [ytops[0], ytopn[0], ybotn[0]]
ZS = [ztops[0], ztopn[0], zbotn[0]]
[strike, dip] = strikedip(XS, YS, ZS)
Rp = numpy.zeros([site_length, 1])
Rrup = numpy.zeros([site_length, 1])
Rjb = numpy.zeros([site_length, 1])
Rx = numpy.zeros([site_length, 1])
Hw = numpy.zeros([site_length, 1])
for i in range(0, site_length):
[xs, ys] = GMCOMP_coord_tools.ll2utm(lonsta[i, 0], latsta[i, 0],
numpy.median(lons),
numpy.median(lats))
R1 = numpy.sqrt(
numpy.power(xs - X1, 2) + numpy.power(ys - Y1, 2) +
numpy.power(Z1, 2))
R2 = numpy.sqrt(
numpy.power(xs - X2, 2) + numpy.power(ys - Y2, 2) +
numpy.power(Z2, 2))
R3 = numpy.sqrt(
numpy.power(xs - X3, 2) + numpy.power(ys - Y3, 2) +
numpy.power(Z3, 2))
R4 = numpy.sqrt(
numpy.power(xs - X4, 2) + numpy.power(ys - Y4, 2) +
numpy.power(Z4, 2))
R = numpy.vstack((R1, R2, R3, R4))
dist = numpy.mean(R, axis=0) / 1000
Rrup[i, 0] = numpy.amin(dist)
Rp[i, 0] = numpy.power(
numpy.sum(fault_slip * numpy.power(dist, -1.4)),
-1 / 1.4) / numpy.power(numpy.sum(fault_slip), -1 / 1.4)
xl1 = xtops[0]
xl2 = xtopn[0]
yl1 = ytops[0]
yl2 = ytopn[0]
Rx[i, 0] = perp_dist(xl1, yl1, xl2, yl2, xs, ys) / 1000
if (dip < 90):
point = Point(xs, ys)
polygon = Polygon([(xl1, yl1), (xl1, yl2), (xl2, yl2),
(xl2, yl1)])
Rjb[i, 0] = point.distance(polygon) / 1000.0
else:
Rjb[i, 0] = Rx[i, 0]
Hw[i, 0] = numpy.sign((yl2 - yl1) * xs - (xl2 - xl1) * ys +
xl2 * yl1 - yl2 * xl1)
## a1 = numpy.where(numpy.amin(z) == z)[0]
## #Southern and northern extent of top of fault
## atops = numpy.where((numpy.amin(yravel) == yravel) & (numpy.amin(zravel) == zravel))[0]
## atopn = numpy.where((numpy.amax(yravel) == yravel) & (numpy.amin(zravel) == zravel))[0]
## abots = numpy.where((numpy.amin(yravel) == yravel) & (numpy.amax(zravel) == zravel))[0]
## abotn = numpy.where((numpy.amax(yravel) == yravel) & (numpy.amax(zravel) == zravel))[0]
## print (atops,atopn,abots,abotn)
##
## #If fault is true E-W, ends defined by east west extent
## if (strike == 90 or strike == 270):
## atops = numpy.where((numpy.amax(xravel) == xravel) & (numpy.amin(zravel) == zravel))[0]
## atopn = numpy.where((numpy.amin(xravel) == xravel) & (numpy.amin(zravel) == zravel))[0]
## abots = numpy.where((numpy.amin(xravel) == xravel) & (numpy.amax(zravel) == zravel))[0]
## abotn = numpy.where((numpy.amax(xravel) == xravel) & (numpy.amax(zravel) == zravel))[0]
##
## FLen = math.sqrt(math.pow(xravel[atops[0]]-xravel[atopn[0]],2)+math.pow(yravel[atops[0]]-yravel[atopn[0]],2))/1000
## FWid = math.sqrt(math.pow(xravel[atops[0]]-xravel[abots[0]],2)+math.pow(yravel[atops[0]]-yravel[abots[0]],2)+math.pow(zravel[atops[0]]-zravel[abots[0]],2))/1000
##
## Rrup = numpy.zeros([site_length,1])
## Rjb = numpy.zeros([site_length,1])
## Rx = numpy.zeros([site_length,1])
## Rp = numpy.zeros([site_length,1])
## Hw = numpy.zeros([site_length,1])
## for i in range (0, site_length):
## [xs,ys] = GMCOMP_coord_tools.ll2utm(lonsta[i,0],latsta[i,0],numpy.median(lons),numpy.median(lats))
##
## R1 = numpy.sqrt(numpy.power(xs-X1,2)+numpy.power(ys-Y1,2)+numpy.power(Z1,2))
## R2 = numpy.sqrt(numpy.power(xs-X2,2)+numpy.power(ys-Y2,2)+numpy.power(Z2,2))
## R3 = numpy.sqrt(numpy.power(xs-X3,2)+numpy.power(ys-Y3,2)+numpy.power(Z3,2))
## R4 = numpy.sqrt(numpy.power(xs-X4,2)+numpy.power(ys-Y4,2)+numpy.power(Z4,2))
## R = numpy.vstack((R1,R2,R3,R4))
## dist = numpy.mean(R, axis=0)/1000
##
## Rrup[i,0] = numpy.amin(dist)
##
## Rp[i,0] = numpy.power(numpy.sum(fault_slip/totslip*numpy.power(dist,p)),1/p)
## xmin = numpy.min(x)
## xmax = numpy.max(x)
## ymin = numpy.min(y)
## ymax = numpy.max(y)
##
##
## xsoff = 1000*math.sin(strike*math.pi/180)
## ysoff = 1000*math.cos(strike*math.pi/180)
##
## xl1 = xravel[atops[0]]
## xl2 = xravel[atopn[0]]
## yl1 = yravel[atops[0]]
## yl2 = yravel[atopn[0]]
##
## Rx[i,0] = perp_dist(xl1, yl1, xl2, yl2, xs, ys)/1000
##
## if (dip < 90):
## point = Point(xs,ys)
## polygon = Polygon([(xmin,ymin), (xmin,ymax), (xmax,ymax), (xmax,ymin)])
## Rjb[i,0] = point.distance(polygon)/1000.0
## else:
## Rjb[i,0] = Rx[i,0]
##
##
## Hw[i,0] = numpy.sign((yl2-yl1)*xs-(xl2-xl1)*ys+xl2*yl1-yl2*xl1)
return (Rrup, Rjb, Rx, Rp, Ztor, Hw, rake, strike, dip, FLen, FWid)
print("Adding edges to H between ward center and nearest road node")
l = range(len(shape_roads)) #Did this programatically
count = 0
for node in ALL_coord_pair_wc[:5]:
count += 1
point = Point(node)
cutting_list = []
longest_distance = 10000000000000000000000000 # ~ = infinity
c = 0 #c will be the index of road segment selected
#Parse list of road segments and update until closest one selected (c = index)
for a in l:
road_seg_a = LIST_ROAD_SEG[a]
line_a = LineString(road_seg_a)
dist_to_road = point.distance(
line_a) #how far is the road from this wc?
if dist_to_road < longest_distance:
longest_distance = dist_to_road
c = a #this gives us index number of the road to access for adding point
#Get linestring for the closest road segment
road_seg_c = LIST_ROAD_SEG[c]
line_t = LineString(road_seg_c)
#Get nearest point on line to point
break_node_temp = line_t.interpolate(line_t.project(point))
coords = list(break_node_temp.coords)
#Turn point into list to match graph data format
break_node = []
break_node.append(coords[0][0])
return elevation_matrix[row, col]
g = nx.Graph()
road_links = solent_itn['roadlinks']
for link in road_links:
Time = []
pt_start = Point(road_links[link]['coords'][0])
elevation_start = get_elevation(pt_start.x, pt_start.y)
for i in road_links[link]['coords'][1:]:
pt = Point(i)
elevation_difference = get_elevation(pt.x, pt.y) - elevation_start
pt_start = pt
if elevation_difference > 0:
Time.append(
pt.distance(pt_start) / 5000 + elevation_difference / 600)
else:
Time.append(pt.distance(pt_start) / 5000)
g.add_edge(road_links[link]['start'],
road_links[link]['end'],
fid=link,
weight=Time)
#nx.draw(g, node_size=1)
path = nx.dijkstra_path(g,
source=(450000, 85000),
target=(460000, 92500),
weight="weight")
def infer_reward_state(self, steering_angle, speed):
try:
self.set_next_state()
except Exception as ex:
utils.json_format_logger(
"Unable to retrieve image from queue: {}".format(ex),
**utils.build_system_error_dict(
utils.SIMAPP_ENVIRONMENT_EXCEPTION,
utils.SIMAPP_EVENT_ERROR_CODE_500))
# Read model state from Gazebo
model_state = self.get_model_state('racecar', '')
model_orientation = Rotation.from_quat([
model_state.pose.orientation.x, model_state.pose.orientation.y,
model_state.pose.orientation.z, model_state.pose.orientation.w
])
model_location = np.array([
model_state.pose.position.x,
model_state.pose.position.y,
model_state.pose.position.z]) + \
model_orientation.apply(RELATIVE_POSITION_OF_FRONT_OF_CAR)
model_point = Point(model_location[0], model_location[1])
model_heading = model_orientation.as_euler('zyx')[0]
# Read the wheel locations from Gazebo
left_rear_wheel_state = self.get_link_state('racecar::left_rear_wheel',
'')
left_front_wheel_state = self.get_link_state(
'racecar::left_front_wheel', '')
right_rear_wheel_state = self.get_link_state(
'racecar::right_rear_wheel', '')
right_front_wheel_state = self.get_link_state(
'racecar::right_front_wheel', '')
wheel_points = [
Point(left_rear_wheel_state.link_state.pose.position.x,
left_rear_wheel_state.link_state.pose.position.y),
Point(left_front_wheel_state.link_state.pose.position.x,
left_front_wheel_state.link_state.pose.position.y),
Point(right_rear_wheel_state.link_state.pose.position.x,
right_rear_wheel_state.link_state.pose.position.y),
Point(right_front_wheel_state.link_state.pose.position.x,
right_front_wheel_state.link_state.pose.position.y)
]
# Project the current location onto the center line and find nearest points
current_ndist = self.center_line.project(model_point, normalized=True)
prev_index, next_index = self.find_prev_next_waypoints(current_ndist)
distance_from_prev = model_point.distance(
Point(self.center_line.coords[prev_index]))
distance_from_next = model_point.distance(
Point(self.center_line.coords[next_index]))
closest_waypoint_index = (
prev_index, next_index)[distance_from_next < distance_from_prev]
# Compute distance from center and road width
nearest_point_center = self.center_line.interpolate(current_ndist,
normalized=True)
nearest_point_inner = self.inner_border.interpolate(
self.inner_border.project(nearest_point_center))
nearest_point_outer = self.outer_border.interpolate(
self.outer_border.project(nearest_point_center))
distance_from_center = nearest_point_center.distance(model_point)
distance_from_inner = nearest_point_inner.distance(model_point)
distance_from_outer = nearest_point_outer.distance(model_point)
track_width = nearest_point_inner.distance(nearest_point_outer)
is_left_of_center = (distance_from_outer < distance_from_inner) if self.reverse_dir \
else (distance_from_inner < distance_from_outer)
print('model_state.pose.position.x=%.2f, model_point.x=%.2f' %
(model_state.pose.position.x, model_point.x))
# Compute the distance to the closest bot car
is_crashed = False
dist_closest_bot_car = 1e3 # large number
closest_bot = -1 # index of closest bot car
for kk in range(len(self.bot_cars)):
dist_to_bot_car = np.sqrt(
(model_state.pose.position.x -
self.bot_cars[kk].car_model_state.pose.position.x)**2 +
(model_state.pose.position.y -
self.bot_cars[kk].car_model_state.pose.position.y)**2)
if dist_to_bot_car < dist_closest_bot_car:
dist_closest_bot_car = dist_to_bot_car
closest_bot = kk
# new @suntao
botcar = self.bot_cars[closest_bot].car_model_state
botcar_orientation = Rotation.from_quat([
botcar.pose.orientation.x, botcar.pose.orientation.y,
botcar.pose.orientation.z, botcar.pose.orientation.w
])
botcar_heading = botcar_orientation.as_euler('zyx')[0]
botcar_location = np.array([
botcar.pose.position.x,
botcar.pose.position.y,
botcar.pose.position.z]) + \
botcar_orientation.apply(RELATIVE_POSITION_OF_FRONT_OF_CAR)
botcar_point = Point(botcar_location[0], botcar_location[1])
botcar_current_ndist = self.center_line.project(botcar_point,
normalized=True)
botcar_prev_index, botcar_next_index = self.find_prev_next_waypoints(
botcar_current_ndist)
if dist_closest_bot_car < 0.30:
is_crashed = True
# Convert current progress to be [0,100] starting at the initial waypoint
if self.reverse_dir:
current_progress = self.start_ndist - current_ndist
else:
current_progress = current_ndist - self.start_ndist
if current_progress < 0.0: current_progress = current_progress + 1.0
current_progress = 100 * current_progress
if current_progress < self.prev_progress:
# Either: (1) we wrapped around and have finished the track,
delta1 = current_progress + 100 - self.prev_progress
# or (2) for some reason the car went backwards (this should be rare)
delta2 = self.prev_progress - current_progress
current_progress = (self.prev_progress, 100)[delta1 < delta2]
# Car is off track if all wheels are outside the borders
wheel_on_track = [self.road_poly.contains(p) for p in wheel_points]
all_wheels_on_track = all(wheel_on_track)
any_wheels_on_track = any(wheel_on_track)
# if current_progress > 30:
# done = True
# reward = 1e2
# Compute the reward
if (not is_crashed) and any_wheels_on_track:
done = False
params = {
'all_wheels_on_track': all_wheels_on_track,
'x': model_point.x,
'y': model_point.y,
'heading': model_heading * 180.0 / math.pi,
'distance_from_center': distance_from_center,
'progress': current_progress,
'steps': self.steps,
'speed': speed,
'steering_angle': steering_angle * 180.0 / math.pi,
'track_width': track_width,
'waypoints': list(self.center_line.coords),
'closest_waypoints': [prev_index, next_index],
'is_left_of_center': is_left_of_center,
'is_reversed': self.reverse_dir,
'is_crashed': is_crashed,
'dist_closest_bot': dist_closest_bot_car,
'bot_x': botcar_point.x,
'bot_y': botcar_point.y,
'bot_heading': botcar_heading * 180.0 / math.pi,
'bot_closest_waypoints':
[botcar_prev_index, botcar_next_index],
}
try:
reward = float(self.reward_function(params))
except Exception as e:
utils.json_format_logger(
"Exception {} in customer reward function. Job failed!".
format(e),
**utils.build_user_error_dict(
utils.SIMAPP_SIMULATION_WORKER_EXCEPTION,
utils.SIMAPP_EVENT_ERROR_CODE_400))
traceback.print_exc()
os._exit(1)
else:
done = True
reward = CRASHED
# Reset if the car position hasn't changed in the last 2 steps
prev_pnt_dist = min(model_point.distance(self.prev_point),
model_point.distance(self.prev_point_2))
if prev_pnt_dist <= 0.0001 and self.steps % NUM_STEPS_TO_CHECK_STUCK == 0:
done = True
reward = CRASHED # stuck
# Simulation jobs are done when progress reaches 100
if current_progress >= 100:
done = True
reward = 1e3
# Keep data from the previous step around
self.prev_point_2 = self.prev_point
self.prev_point = model_point
self.prev_progress = current_progress
# Set the reward and done flag
self.reward = reward
self.reward_in_episode += reward
self.done = done
# Trace logs to help us debug and visualize the training runs
# btown TODO: This should be written to S3, not to CWL.
logger.info(
'SIM_TRACE_LOG:%d,%d,%.4f,%.4f,%.4f,%.2f,%.2f,%d,%.4f,%s,%s,%.4f,%d,%.2f,%s,%s,%.2f\n'
% (self.episodes, self.steps, model_location[0], model_location[1],
model_heading, self.steering_angle, self.speed,
self.action_taken, self.reward, self.done, all_wheels_on_track,
current_progress, closest_waypoint_index, self.track_length,
time.time(), is_crashed, dist_closest_bot_car))
# Terminate this episode when ready
if done and node_type == SIMULATION_WORKER:
self.finish_episode(current_progress)
def evaluate_collision(ego_vehicle_state, dynamic_vehicle_state, dy_obsList,
static_vehicle_state, st_obsList, config):
dis_list = []
dis_satisfaction = []
## in case that the size are not same
num_dynamic_obs = len(dy_obsList)
num_static_obs = len(st_obsList)
if num_dynamic_obs:
range_list_dy = len(dynamic_vehicle_state[0])
else:
range_list_dy = 0
for obs in range(1, num_dynamic_obs):
range_list_dy = min(range_list_dy, len(dynamic_vehicle_state[obs]))
if num_static_obs:
range_list_st = len(static_vehicle_state[0])
else:
range_list_st = 0
for obs in range(1, num_static_obs):
range_list_st = min(range_list_st, len(static_vehicle_state[obs]))
if num_dynamic_obs and num_static_obs:
if range_list_dy < range_list_st:
range_list = min(len(ego_vehicle_state), range_list_dy)
else:
range_list = min(len(ego_vehicle_state), range_list_st)
elif num_dynamic_obs:
range_list = min(len(ego_vehicle_state), range_list_dy)
elif num_static_obs:
range_list = min(len(ego_vehicle_state), range_list_st)
for i in range(range_list):
min_dist = 1000
flag = 0
ego_direction = ego_vehicle_state[i][3]
x = ego_vehicle_state[i][0]
y = ego_vehicle_state[i][1]
ego_vehicle_center = Point(x, y)
point1 = Point(x - config.ego_length / 2, y - config.ego_width / 2)
point2 = Point(x + config.ego_length / 2, y - config.ego_width / 2)
point3 = Point(x + config.ego_length / 2, y + config.ego_width / 2)
point4 = Point(x - config.ego_length / 2, y + config.ego_width / 2)
ego_rect = Polygon([point1, point2, point3, point4])
angle = ego_direction * (180.0 / math.pi)
rect_ego = affinity.rotate(ego_rect, angle)
for num in range(len(dynamic_vehicle_state)):
vehicle_width = float(dy_obsList[num]["width"])
vehicle_length = float(dy_obsList[num]["length"])
veh_x = dynamic_vehicle_state[num][i][4]
veh_y = dynamic_vehicle_state[num][i][5]
other_vehicle_center = Point(veh_x, veh_y)
point1 = Point(veh_x - vehicle_length / 2,
veh_y - vehicle_width / 2)
point2 = Point(veh_x + vehicle_length / 2,
veh_y - vehicle_width / 2)
point3 = Point(veh_x + vehicle_length / 2,
veh_y + vehicle_width / 2)
point4 = Point(veh_x - vehicle_length / 2,
veh_y + vehicle_width / 2)
other_rect = Polygon([point1, point2, point3, point4])
angle = dynamic_vehicle_state[num][i][2] * (180.0 / math.pi)
rect_other = affinity.rotate(other_rect, angle)
intersection = rect_ego.intersection(rect_other)
if not intersection.is_empty:
# print("rect_ego", rect_ego)
# print("ego_state", ego_vehicle_state[i][0], ego_vehicle_state[i][1])
# print("other rect:", other_rect)
# print("other vehicle state:", dynamic_vehicle_state[num][i][4], dynamic_vehicle_state[num][i][5])
flag = -1
min_dist = -1
break
else:
dist = ego_vehicle_center.distance(other_vehicle_center)
if dist < min_dist:
# print("rect_ego", rect_ego)
# print("ego_state", ego_vehicle_state[i][0], ego_vehicle_state[i][1])
# print("other rect:", rect_other)
# print("other vehicle state:", dynamic_vehicle_state[num][i][4], dynamic_vehicle_state[num][i][5])
min_dist = dist
for num in range(len(static_vehicle_state)):
vehicle_width = float(st_obsList[num]["width"])
vehicle_length = float(st_obsList[num]["length"])
veh_x = dynamic_vehicle_state[num][i][4]
veh_y = dynamic_vehicle_state[num][i][5]
other_vehicle_center = Point(veh_x, veh_y)
point1 = Point(veh_x - vehicle_width / 2,
veh_y - vehicle_length / 2)
point2 = Point(veh_x + vehicle_width / 2,
veh_y - vehicle_length / 2)
point3 = Point(veh_x + vehicle_width / 2,
veh_y + vehicle_length / 2)
point4 = Point(veh_x - vehicle_width / 2,
veh_y + vehicle_length / 2)
other_rect = Polygon([point1, point2, point3, point4])
intersection = rect_ego.intersection(other_rect)
if not intersection.is_empty:
flag = -1
min_dist = -1
break
else:
dist = ego_vehicle_center.distance(other_vehicle_center)
if dist < min_dist:
min_dist = dist
dis_list.append(min_dist)
# print(min_dist)
if min_dist >= config.minimumseperation:
satisfaction = 1
elif min_dist < config.assured_clear_distance_ahead:
satisfaction = 0
else:
satisfaction = (min_dist - config.assured_clear_distance_ahead) / (
config.minimumseperation - config.assured_clear_distance_ahead)
dis_satisfaction.append(satisfaction)
# print(dis_list, dis_satisfaction, dis_satisfaction)
if len(dis_list) and len(dis_satisfaction):
min_dis = min(dis_list)
min_satisfaction = min(dis_satisfaction)
avg_satisfaction = np.mean(dis_satisfaction)
else:
min_dis = -1
min_satisfaction = -1
avg_satisfaction = -1
return min_dis
def update_charts(clickData, selected_data, clicks, task4_type, anomaly_type,
data):
# read the data from the store
empty_task2 = empty_task2_df.to_json(date_format='iso', orient='split')
empty_task4 = empty_task4_df.to_json(date_format='iso', orient='split')
data = data or {
'last_clicks': 0,
'origin_x': 0,
'origin_y': 0,
'distance': 0,
'task2_df': empty_task2,
'task4_df': empty_task4,
'task4_box_df': empty_task4,
'last_click_data': None,
'last_selected_data': None,
}
last_clicks = data['last_clicks']
origin = Point(data['origin_x'], data['origin_y'])
distance = data['distance']
df_task2 = pd.read_json(data['task2_df'], orient='split')
df_task4 = pd.read_json(data['task4_df'], orient='split')
df_task4_box = pd.read_json(data['task4_box_df'], orient='split')
stored_click_data = data['last_click_data']
stored_selected_data = data['last_selected_data']
anomaly_name = 'Isostatic Anomaly'
anomaly_column_name = 'isostatic_anom'
if anomaly_type == 'bouguer':
anomaly_name = 'Bouguer Anomaly'
anomaly_column_name = 'Bouguer_anom_267'
elif anomaly_type == 'freeair':
anomaly_name = 'Free Air Anomaly'
anomaly_column_name = 'Free_air_anom'
elif anomaly_type == 'observed':
anomaly_name = 'Observed Gravity Anomaly'
anomaly_column_name = 'obs_grav'
layout = dict(autosize=True,
title=dict(x=0.5),
margin=dict(l=0, r=0, b=0, t=40),
xaxis_title=" Distance (m)",
height=300)
bar_layout = dict(
height=300,
bargap=0.1,
xaxis_type="category",
xaxis_title="Station ID",
yaxis_title=anomaly_name + " (mGal)",
title=dict(text="Distribution and Ranking", x=0.5),
showlegend=False,
)
transect_fig = make_subplots(specs=[[{"secondary_y": True}]])
task4_fig = px.bar()
if clicks != last_clicks:
last_clicks = clicks
df_task2 = empty_task2_df
df_task4 = empty_task4_df
df_task4_box = empty_task4_df
origin = Point(0, 0)
distance = 0
data['last_clicks'] = clicks
elif clickData:
lon = clickData['points'][0]['lon']
lat = clickData['points'][0]['lat']
x, y = degrees2meters(lon, lat)
if origin == Point(0, 0):
origin = Point(x, y)
if task4_type == 'click':
# update task2
distance += origin.distance(Point(x, y))
custom_data = clickData['points'][0]['customdata']
if stored_click_data != clickData:
df_task2 = df_task2.append(
{
'distance': distance,
'elevation': custom_data[2],
'station_id': custom_data[1],
'isostatic_anom': custom_data[0],
'Free_air_anom': custom_data[3],
'Bouguer_anom_267': custom_data[4],
'obs_grav': custom_data[5]
},
ignore_index=True)
df_task2 = df_task2.sort_values('distance').reset_index(drop=True)
origin = Point(x, y)
# update task4
station_id = str(clickData['points'][0]['customdata'][1])
if station_id not in df_task4['station_id'].tolist(
) and stored_click_data != clickData:
df_task4 = df_task4.append(
{
'isostatic_anom': custom_data[0],
'station_id': station_id,
'Free_air_anom': custom_data[3],
'Bouguer_anom_267': custom_data[4],
'obs_grav': custom_data[5]
},
ignore_index=True)
df_task4 = df_task4.sort_values(anomaly_column_name,
ascending=False)
df_task4 = df_task4.reset_index(drop=True)
colors = [
px.colors.qualitative.Plotly[0],
] * len(df_task4['station_id'])
if df_task4.shape[0] > 0:
to_be_change_color = df_task4[df_task4['station_id'] ==
station_id].index.item()
colors[to_be_change_color] = px.colors.qualitative.Plotly[1]
task4_fig = px.bar(df_task4,
x='station_id',
y=anomaly_column_name,
color="station_id",
color_discrete_sequence=colors,
labels={
'station_id': 'Station ID',
anomaly_column_name: anomaly_name
})
anomaly_data = df_task2.isostatic_anom
if anomaly_type == 'bouguer':
anomaly_data = df_task2.Bouguer_anom_267
elif anomaly_type == 'freeair':
anomaly_data = df_task2.Free_air_anom
elif anomaly_type == 'observed':
anomaly_data = df_task2.obs_grav
# Add traces
transect_fig.add_trace(
go.Scatter(
x=df_task2.distance,
y=anomaly_data,
name=anomaly_name,
customdata=list(zip(df_task2.station_id)),
hovertemplate=
'Station ID: %{customdata[0]}<br>Anomaly: %{y} mGal<br>Distance: %{x} m<extra></extra>'
),
secondary_y=False,
)
transect_fig.add_trace(
go.Scatter(
x=df_task2.distance,
y=df_task2.elevation,
name="Elevation",
customdata=list(zip(df_task2.station_id)),
hovertemplate=
'Station ID: %{customdata[0]}<br>Elevation: %{y} ft<br>Distance: %{x} m<extra></extra>'
),
secondary_y=True,
)
transect_fig.update(layout=layout)
transect_fig.update(layout=dict(
title=dict(text="Transect", x=0.5),
legend=dict(yanchor="bottom", y=1.02, xanchor="right", x=1.05)))
# Set x-axis title
transect_fig.update_xaxes(title_text="Distance (m)")
# Set y-axes titles
transect_fig.update_yaxes(title_text=anomaly_name + " (mGal)",
secondary_y=False)
transect_fig.update_yaxes(title_text="Elevation (ft)", secondary_y=True)
if task4_type == 'box':
if not selected_data:
task4_fig = px.bar()
if selected_data and selected_data['points']:
if selected_data != stored_selected_data:
for point in selected_data['points']:
df_task4_box = df_task4_box.append(
{
'isostatic_anom': point['customdata'][0],
'station_id': point['customdata'][1],
'Free_air_anom': point['customdata'][3],
'Bouguer_anom_267': point['customdata'][4],
'obs_grav': point['customdata'][5]
},
ignore_index=True)
# Update bar chart
df_task4_box = df_task4_box.drop_duplicates()
df_task4_box = df_task4_box.sort_values(anomaly_column_name,
ascending=False)
df_task4_box = df_task4_box.reset_index(drop=True)
task4_fig = px.bar(df_task4_box,
x='station_id',
y=anomaly_column_name,
labels={
'station_id': 'Station ID',
anomaly_column_name: anomaly_name
})
task4_fig.update_layout(bargap=0)
if clickData:
colors = [
px.colors.qualitative.Plotly[0],
] * len(df_task4_box['station_id'])
station_id = clickData['points'][0]['customdata'][1]
if station_id in df_task4_box['station_id'].tolist():
to_be_change_color = df_task4_box[
df_task4_box['station_id'] == station_id].index.item()
colors[to_be_change_color] = px.colors.qualitative.Plotly[
1]
task4_fig = px.bar(df_task4_box,
x='station_id',
y=anomaly_column_name,
color="station_id",
color_discrete_sequence=colors,
labels={
'station_id': 'Station ID',
anomaly_column_name: anomaly_name
})
task4_fig.update(layout=layout)
task4_fig.update(layout=bar_layout)
# update the stored data
data['origin_x'] = origin.x
data['origin_y'] = origin.y
data['distance'] = distance
data['task2_df'] = df_task2.to_json(date_format='iso', orient='split')
data['task4_df'] = df_task4.to_json(date_format='iso', orient='split')
data['task4_box_df'] = df_task4_box.to_json(date_format='iso',
orient='split')
data['last_click_data'] = clickData
data['last_selected_data'] = selected_data
return transect_fig, task4_fig, data
def srcmod_fspreader(fspfile, sta_lat, sta_lon):
fault_lat = []
fault_lon = []
fault_dep = []
fault_slip = []
fault_rake = []
for line in open(fspfile):
li = line.strip()
if not li.startswith("%"):
fs = line.split()
if not fs:
pass
else:
fault_lat = numpy.append(fault_lat, [float(fs[0])], axis=0)
fault_lon = numpy.append(fault_lon, [float(fs[1])], axis=0)
fault_dep = numpy.append(fault_dep, [float(fs[4])], axis=0)
fault_slip = numpy.append(fault_slip, [float(fs[5])], axis=0)
fault_rake = numpy.append(fault_rake, [float(fs[7])], axis=0)
lat0 = numpy.mean(fault_lat)
lon0 = numpy.mean(fault_lon)
totslip = numpy.sum(fault_slip)
rake = numpy.mean(fault_rake)
[x0, y0] = GMCOMP_coord_tools.ll2utm(fault_lon, fault_lat, lon0,
lat0) #convert fault locations to UTM
[xs,
ys] = GMCOMP_coord_tools.ll2utm(sta_lon, sta_lat, lon0,
lat0) #convert station locations to UTM
Ztor = numpy.amin(fault_dep)
atop = numpy.where(Ztor == fault_dep)[0]
abot = numpy.where(numpy.amax(fault_dep) == fault_dep)[0]
yravelt = numpy.ravel(y0[atop])
xravelt = numpy.ravel(x0[atop])
zravelt = numpy.ravel(fault_dep[atop])
atops = numpy.where((numpy.amin(yravelt) == yravelt))[0]
atopn = numpy.where((numpy.amax(yravelt) == yravelt))[0]
yravelb = numpy.ravel(y0[abot])
xravelb = numpy.ravel(x0[abot])
zravelb = numpy.ravel(fault_dep[abot])
abots = numpy.where((numpy.amin(yravelb) == yravelb))[0]
abotn = numpy.where((numpy.amax(yravelb) == yravelb))[0]
ytopn = yravelt[atopn]
ytops = yravelt[atops]
ybotn = yravelb[abotn]
ybots = yravelb[abots]
xtopn = xravelt[atopn]
xtops = xravelt[atops]
xbotn = xravelb[abotn]
xbots = xravelb[abots]
ztopn = zravelt[atopn]
ztops = zravelt[atops]
zbotn = zravelb[abotn]
zbots = zravelb[abots]
FLen = math.sqrt(
math.pow(xtops[0] - xtopn[0], 2) +
math.pow(ytops[0] - ytopn[0], 2)) / 1000
FWid = math.sqrt(
math.pow(xtops[0] - xbots[0], 2) + math.pow(ytops[0] - ybots[0], 2) +
math.pow((ztops[0] - zbots[0]) * 1000, 2)) / 1000
XS = [float(xtops[0]), float(xtopn[0]), float(xbotn[0])]
YS = [float(ytops[0]), float(ytopn[0]), float(ybotn[0])]
ZS = [
1000 * float(ztops[0]), 1000 * float(ztopn[0]), 1000 * float(zbotn[0])
]
[strike, dip] = strikedip(XS, YS, ZS)
fault_strike = strike * numpy.ones([len(fault_lat), 1])
fault_dip = dip * numpy.ones([len(fault_lat), 1])
numsta = len(xs) #number of stations
Rp = numpy.zeros([numsta, 1])
Rrup = numpy.zeros([numsta, 1])
Rjb = numpy.zeros([numsta, 1])
Rx = numpy.zeros([numsta, 1])
Hw = numpy.zeros([numsta, 1])
for i in range(0, numsta):
dist = numpy.sqrt(
numpy.power(x0 - xs[i], 2) + numpy.power(y0 - ys[i], 2) +
numpy.power(fault_dep * 1000, 2)) / 1000
Rrup[i, 0] = numpy.amin(dist)
Rp[i, 0] = numpy.power(numpy.sum(
fault_slip * numpy.power(dist, -1.4)), -1 / 1.4) / numpy.power(
numpy.sum(fault_slip), -1 / 1.4)
xl1 = xtops[0]
xl2 = xtopn[0]
yl1 = ytops[0]
yl2 = ytopn[0]
Rx[i, 0] = perp_dist(xl1, yl1, xl2, yl2, xs[i], ys[i]) / 1000
if (dip < 90):
point = Point(xs[i], ys[i])
polygon = Polygon([(xl1, yl1), (xl1, yl2), (xl2, yl2), (xl2, yl1)])
Rjb[i, 0] = point.distance(polygon) / 1000.0
else:
Rjb[i, 0] = Rx[i, 0]
Hw[i, 0] = numpy.sign((yl2 - yl1) * xs[i] - (xl2 - xl1) * ys[i] +
xl2 * yl1 - yl2 * xl1)
return (Rrup, Rjb, Rx, Rp, Ztor, Hw, rake, strike, dip, FLen, FWid,
fault_lat, fault_lon, fault_dep, fault_slip, fault_rake,
fault_strike, fault_dip)
def lookup(self, loc, peril_id, coverage_type):
"""
Area peril lookup for an individual lon/lat location item, which can be
provided as a dict or a Pandas series. The data structure should contain
the keys `lon` or `longitude` for longitude and `lat` or `latitude` for
latitude.
"""
idx = self.peril_areas_index
boundary = self.peril_areas_boundary
loc_to_areas_min_dist = self.loc_to_global_areas_boundary_min_distance
loc_id_col = self.loc_id_col
loc_id = loc.get(loc_id_col) or int(uuid.UUID(bytes=os.urandom(16)).hex[:16], 16)
loc_x_col = self.loc_coords_x_col
loc_y_col = self.loc_coords_y_col
loc_x_bounds = self.loc_coords_x_bounds
loc_y_bounds = self.loc_coords_y_bounds
x = loc.get(loc_x_col)
y = loc.get(loc_y_col)
_lookup = lambda loc_id, x, y, st, perid, covtype, paid, pabnds, pacoords, msg: {
loc_id_col: loc_id,
loc_x_col: x,
loc_y_col: y,
'peril_id': perid,
'coverage_type': covtype,
'status': st,
'peril_area_id': paid,
'area_peril_id': paid,
'area_bounds': pabnds,
'area_coordinates': pacoords,
'message': msg
}
try:
x = float(x)
y = float(y)
if not ((loc_x_bounds[0] <= x <= loc_x_bounds[1]) and (loc_y_bounds[0] <= y <= loc_y_bounds[1])):
raise ValueError('{}/{} out of bounds'.format(loc_x_col, loc_y_col))
except (ValueError, TypeError) as e:
msg = (
'Peril area lookup: invalid {}/{} ({}, {}) - {}'
.format(loc_x_col, loc_y_col, x, y, str(e))
)
return _lookup(loc_id, x, y, OASIS_KEYS_STATUS['fail']['id'], peril_id, coverage_type, None, None, None, msg)
st = OASIS_KEYS_STATUS['nomatch']['id']
msg = 'No peril area match'
paid = None
pabnds = None
pacoords = None
point = x, y
try:
results = list(idx.intersection(point, objects='raw'))
if not results:
raise IndexError
for _perid, _covtype, _paid, _pabnds, _pacoords in results:
if (peril_id, coverage_type) == (_perid, _covtype):
paid, pabnds, pacoords = _paid, _pabnds, _pacoords
break
if paid == None:
raise IndexError
except IndexError:
try:
results = list(idx.nearest(point, objects='raw'))
if not results:
raise IndexError
for _perid, _covtype, _paid, _pabnds, _pacoords in results:
if (peril_id, coverage_type) == (_perid, _covtype):
paid, pabnds, pacoords = _paid, _pabnds, _pacoords
break
if paid == None:
msg = 'No intersecting or nearest peril area found for peril ID {} and coverage type {}'.format(peril_id, coverage_type)
return _lookup(loc_id, x, y, OASIS_KEYS_STATUS['nomatch']['id'], peril_id, coverage_type, None, None, None, msg)
except IndexError:
pass
else:
p = Point(x, y)
min_dist = p.distance(boundary)
if min_dist > loc_to_areas_min_dist:
msg = (
'Peril area lookup: location is {} units from the '
'peril areas global boundary - the required minimum '
'distance is {} units'
.format(min_dist, loc_to_areas_min_dist)
)
return _lookup(loc_id, x, y, OASIS_KEYS_STATUS['fail']['id'], peril_id, coverage_type, None, None, None, msg)
st = OASIS_KEYS_STATUS['success']['id']
msg = (
'Successful peril area lookup: {}'.format(paid)
)
except RTreeError as e:
return _lookup(loc_id, x, y, OASIS_KEYS_STATUS['fail']['id'], peril_id, coverage_type, None, None, None, str(e))
else:
st = OASIS_KEYS_STATUS['success']['id']
msg = 'Successful peril area lookup: {}'.format(paid)
return _lookup(loc_id, x, y, st, peril_id, coverage_type, paid, pabnds, pacoords, msg)
def add_linking_edges_for_new_node(graph,
new_node,
split_point,
edge,
nts,
db_costs,
logging=False):
edge_geom = edge['geometry']
# split edge at new node to two line geometries
split_lines = geom_utils.split_line_at_point(edge_geom, split_point)
node_from = edge['uvkey'][0]
node_to = edge['uvkey'][1]
node_from_p = get_node_geom(graph, node_from)
node_to_p = get_node_geom(graph, node_to)
edge_first_p = Point(edge_geom.coords[0])
if (edge_first_p.distance(node_from_p) < edge_first_p.distance(node_to_p)):
link1 = split_lines[0]
link2 = split_lines[1]
else:
link1 = split_lines[1]
link2 = split_lines[0]
if (logging == True):
print('add linking edges between:', node_from, new_node, node_to)
# interpolate noise cost attributes for new linking edges so that they work in quiet path routing
link1_noise_costs = get_edge_noise_cost_attrs(nts, db_costs, edge, link1)
link2_noise_costs = get_edge_noise_cost_attrs(nts, db_costs, edge, link2)
# combine link attributes to prepare adding them as new edges
link1_attrs = {
'geometry': link1,
'length': round(link1.length, 3),
**link1_noise_costs
}
link2_attrs = {
'geometry': link2,
'length': round(link2.length, 3),
**link2_noise_costs
}
# add linking edges with noice cost attributes to graph
graph.add_edges_from([(node_from, new_node, {
'uvkey': (node_from, new_node),
**link1_attrs
})])
graph.add_edges_from([(new_node, node_from, {
'uvkey': (new_node, node_from),
**link1_attrs
})])
graph.add_edges_from([(node_to, new_node, {
'uvkey': (node_to, new_node),
**link2_attrs
})])
graph.add_edges_from([(new_node, node_to, {
'uvkey': (new_node, node_to),
**link2_attrs
})])
link1_d = {'uvkey': (new_node, node_from), **link1_attrs}
link2_d = {'uvkey': (node_to, new_node), **link2_attrs}
return {
'node_from': node_from,
'new_node': new_node,
'node_to': node_to,
'link1': link1_d,
'link2': link2_d
}
def main(argv):
try:
directory = argv[0] + '/'
model = argv[1]
offset = float(argv[2])
noit = int(argv[3])
except:
print '''
*******************************************
Usage: atan_bestfit_creep.py directory model offset
directory: directory to transect.mat file
model: 'interseismic' or 'creep' or 'both'
offset: if there is an offset of creep from the fault (in meters)
*******************************************
'''
sys.exit(1)
fileList = glob.glob(directory + '/*.mat')
# print(fileList[0])
transectmat = scipy.io.loadmat(str(fileList[0]))
# transect = transectmat['dataset'][0][0][1]
transect = transectmat['dataset'][0][0][1]
avgInSAR = np.nanmean(transect, axis=1)
stdInSAR = np.nanstd(transect, axis=1)
transect_dist = transectmat['dataset'][0][0][2]
transect_lat_first = transectmat['dataset'][0][0][0][0][25]
transect_lon_first = transectmat['dataset'][0][0][3][0][25]
transect_first = Point(transect_lon_first, transect_lat_first)
transect_lat_end = transectmat['dataset'][0][0][0][-1][25]
transect_lon_end = transectmat['dataset'][0][0][3][-1][25]
transect_end = Point(transect_lon_end, transect_lat_end)
transect_middle_line = LineString([(transect_first), (transect_end)])
fault_line = LineString([(26.835038363171353, 40.600641025641025),
(26.849744245524295, 40.605769230769226),
(26.86253196930946, 40.610256410256405),
(26.875319693094628, 40.61474358974359),
(26.884271099744243, 40.61730769230769),
(26.896419437340153, 40.621153846153845),
(26.90920716112532, 40.625),
(26.929028132992325, 40.631410256410255),
(26.93542199488491, 40.63525641025641),
(26.95012787723785, 40.64038461538461),
(26.96547314578005, 40.64487179487179),
(26.975703324808183, 40.648717948717945),
(26.982097186700766, 40.651282051282045),
(26.992966751918157, 40.65448717948718),
(27.005754475703323, 40.65961538461538),
(27.01918158567775, 40.66474358974359),
(27.028772378516624, 40.66858974358974),
(27.033887468030688, 40.67115384615384),
(27.04092071611253, 40.674358974358974),
(27.04923273657289, 40.67820512820513),
(27.058823529411764, 40.68141025641025),
(27.062020460358056, 40.682051282051276),
(27.072250639386187, 40.68589743589743),
(27.083759590792837, 40.68846153846154),
(27.09846547314578, 40.69102564102564),
(27.108056265984654, 40.69358974358974),
(27.121483375959077, 40.69615384615384),
(27.13107416879795, 40.69807692307692),
(27.141943734015346, 40.70128205128205),
(27.160485933503836, 40.70641025641025),
(27.186700767263424, 40.71282051282051),
(27.19757033248082, 40.715384615384615),
(27.20843989769821, 40.71730769230769),
(27.224424552429667, 40.72115384615385),
(27.239769820971865, 40.725641025641025),
(27.251918158567772, 40.72948717948718),
(27.26790281329923, 40.73461538461538),
(27.280690537084396, 40.73782051282051)])
intersect = transect_middle_line.intersection(fault_line)
#intersect = intersection(transect_middle_line,fault_line)
dist = (transect_first.distance(intersect)) * 100000.0
dist2 = (intersect.distance(transect_end)) * 100000.0
################################################################################
###GPS LOCATIONS
BGNT = Point(26.570, 40.932)
BGNTvel = [2.11, -2.28, 0]
BGNTvelLOS = enu2los(*BGNTvel) / -1000.
BGNTdist = BGNT.distance(fault_line) * -100000.0
DOKU = Point(26.706, 40.739)
DOKUvel = [-2.73, -0.96, 0]
DOKUvelLOS = enu2los(*DOKUvel) / -1000.
DOKUdist = DOKU.distance(fault_line) * -100000.0 #in meters
KVAM = Point(26.871, 40.601)
KVAMvel = [-9.05, -3.26, 0]
KVAMvelLOS = enu2los(*KVAMvel) / -1000.
KVAMdist = KVAM.distance(fault_line) * -100000.0
KVM2 = Point(26.871, 40.601)
KVM2vel = [-10.33, -4, 0]
KVM2velLOS = enu2los(*KVM2vel) / -1000.
KVM2dist = KVM2.distance(fault_line) * -100000.0
SEV2 = Point(26.880, 40.396)
SEV2vel = [-15.39, -6.01, 0]
SEV2velLOS = enu2los(*SEV2vel) / -1000.
SEV2dist = SEV2.distance(fault_line) * 100000.0
BKCT = Point(27.091, 40.932)
BKCTvel = [-17.04, -6.81, 0]
BKCTvelLOS = enu2los(*BKCTvel) / -1000.
BKCTdist = BKCT.distance(fault_line) * 100000.0
# GPSdist = [int(BGNTdist),int(DOKUdist),int(KVAMdist),int(KVM2dist),int(SEV2dist),int(BKCTdist)]
GPSdist = [int(DOKUdist), int(SEV2dist), int(BKCTdist)]
# GPSvel = [BGNTvelLOS,DOKUvelLOS,KVAMvelLOS,KVM2velLOS,SEV2velLOS,BKCTvelLOS]
GPSvel = [DOKUvelLOS, SEV2velLOS, BKCTvelLOS]
GPSvelRef = np.array(GPSvel) - GPSvel[0]
GPSvelPlot = [i * 1000.0 for i in GPSvel]
# print('BGNT VEL: '+str(BGNTvelLOS))
# print('BGNT DIST: '+str(BGNTdist))
#
# print(DOKUvelLOS)
# print(KVAMvelLOS)
# print(KVM2velLOS)
# print(SEV2velLOS)
# print(BKCTvelLOS)
# print(len(avgInSAR))
# sys.exit()
################################################################################
depth = []
slip = []
varModel = []
##1-D space##
insarSpace = np.linspace(-dist, dist2, num=len(avgInSAR), endpoint=True)
# numB = abs(GPSdist[0])+abs(GPSdist[-1])
# insarGPSSpace = np.linspace(GPSdist[0],GPSdist[-1],num=numB, dtype = int,endpoint=True)
insarGPSSpace = np.linspace(GPSdist[0],
GPSdist[-1],
num=len(avgInSAR) + len(GPSdist),
dtype=int,
endpoint=True)
sortedSpace = (sorted(insarGPSSpace))
# sortedSpace = (sorted(insarSpace))
################################################################################
n = -1
def find_nearest(array, value):
idx = np.searchsorted(array, value, side="left")
if idx > 0 and (idx == len(array) or math.fabs(value - array[idx - 1])
< math.fabs(value - array[idx])):
return array[idx - 1]
else:
return array[idx]
Vel = list(avgInSAR[:] - avgInSAR[0])
for i in GPSdist:
n = n + 1
GPSindex = find_nearest(sortedSpace, i)
# GPSindex = sortedSpace.index(i)
Vel.insert(GPSindex, GPSvelRef[n])
Vel = np.array(Vel)
# print(Vel[0])
x = np.array(sortedSpace)
sortedSpaceKm = (x / 1000.0)
# sys.exit()
################################################################################
# G = np.ones([len(transect),2])
G = np.ones([len(Vel), 2])
G[:, 0] = sortedSpaceKm
G_inv = np.dot(np.linalg.inv(np.dot(G.T, G)), G.T)
G_inv = np.array(G_inv, np.float32)
sol = np.dot(G_inv, Vel)
k = np.dot(G, sol)
D = np.arange(100., 20000., 100.)
V = np.arange(-0.001, -0.10, -0.001)
rmse_inv = []
for d in D:
for s in V:
v2 = sol[0] + ((s / np.pi) * np.arctan(x / d)) + sol[1]
residual = v2 - Vel
# rms = np.sqrt((sum((residual)**2,0))/len(transect))
rms = np.sqrt((sum((residual)**2, 0)) / len(Vel))
rmse_inv.append([d, s, rms])
rmse_inv = np.array(rmse_inv, np.float32)
idx = np.argmin(rmse_inv[:, 2])
rmse_inv_min = rmse_inv[idx]
print 'Inversion: ' + str(rmse_inv_min)
v2_rms_min_inv = ((rmse_inv_min[1] / np.pi) *
np.arctan(x / rmse_inv_min[0])) + sol[0] + sol[1]
################################################################################
if model == 'interseismic':
for q in xrange(noit):
avgVel = []
for i in xrange(len(avgInSAR)):
avgVel.append(np.random.normal(avgInSAR[i], stdInSAR[i]))
avgVel = np.array(avgVel)
G = np.ones([len(Vel), 2])
G[:, 0] = sortedSpaceKm
G_inv = np.dot(np.linalg.inv(np.dot(G.T, G)), G.T)
G_inv = np.array(G_inv, np.float32)
sol = np.dot(G_inv, Vel)
k = np.dot(G, sol)
D = np.arange(1000., 10000., 100.)
V = np.arange(-0.001, -0.030, -0.0005)
rmse = []
for d in D:
for s in V:
v2 = sol[0] + ((s / np.pi) * np.arctan(x / d)) + sol[1]
residual = v2 - avgVel
rms = np.sqrt((sum((residual)**2, 0)) / len(transect))
rmse.append([d, s, rms])
rmse = np.array(rmse, np.float32)
idx = np.argmin(rmse[:, 2])
rmse_min = rmse[idx]
print str(q) + ' ' + str(rmse_min)
depth.append(rmse_min[0])
slip.append(rmse_min[1])
# r.append(rmse_min[2])
varModel.append(rmse_min[2]**2)
stdModel = np.sqrt(sum(varModel))
slip[:] = [x * 1000.0 for x in slip]
################################################################################
##PLOT average and standard deviation##
fig = plt.figure()
plt.rcParams.update({'font.size': 22})
fig.set_size_inches(10, 10)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
cov = np.cov(slip, depth)
vals, vecs = eigsorted(cov)
theta = np.degrees(np.arctan2(*vecs[:, 0][::-1]))
for nstd in xrange(1, 4): ####nstd is 1sigma, 2sigma, 3sigma
w, h = 2 * nstd * np.sqrt(vals)
ell = Ellipse(xy=(np.mean(slip), np.mean(depth)),
width=w,
height=h,
angle=theta,
color='black')
ell.set_facecolor('none')
ax.add_artist(ell)
plt.scatter(slip, depth)
plt.scatter(rmse_inv_min[1] * 1000.,
rmse_inv_min[0],
s=60,
c='red',
marker='*')
plt.ylabel('Depth (m)')
plt.xlabel('Slip (mm/yr)')
# plt.xlim(1,30)
# plt.ylim(1000,10000)
fig.savefig('depth_vs_slip.png')
plt.close()
depth.append(rmse_inv_min[0])
slip.append(rmse_inv_min[1])
stdDepth = roundup(np.std(depth))
stdSlip = math.ceil(np.std(slip))
# fig = plt.figure()
# plt.rcParams.update({'font.size': 22})
# fig.set_size_inches(20,8)
# ax = plt.Axes(fig, [0., 0., 1., 1.], )
# ax=fig.add_subplot(111)
# ax.plot(xp,transect*1000.0,'o',ms=1,mfc='Black', linewidth='0')
# label = 'Best Fit: '+str(int(rmse_inv_min[0]))+'$\pm$'+str(int(stdDepth))+'m; '+str(int(abs(round(rmse_inv_min[1]*1000.,2))))+'$\pm$'+str(int(stdSlip))+'mm/yr'
# ax.plot(xp,(v2_rms_min_inv*1000.),'b--',label=label)
# ax.legend(loc='upper right')
# plt.ylabel('Velocity (mm/yr)')
# plt.xlabel('Distance (km)')
# fig.savefig('atan_best_'+str(rmse_inv_min[0])+'_'+str(rmse_inv_min[1])+'.png')
# plt.close()
fig = plt.figure()
plt.rcParams.update({'font.size': 22})
fig.set_size_inches(20, 8)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
ax.plot(xp, transect * 1000.0, 'o', ms=1, mfc='Black', linewidth='0')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR - i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #,color='#DCDCDC')#'LightGrey')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR + i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #'LightGrey')
ax.plot(xp, avgInSAR * 1000.0, 'r-', label='Average velocity')
# label1 = 'Interseismic only: Locking depth: '+str(int(rmse_min[0]))+' meters - Slip rate: '+str(int(abs(round(rmse_min[1]*1000.,2))))+' mm/yr'
label1 = 'Best Fit: ' + str(int(rmse_inv_min[0])) + '$\pm$' + str(
int(stdDepth)) + 'm; ' + str(
int(abs(round(rmse_inv_min[1] * 1000., 2)))) + '$\pm$' + str(
int(stdSlip)) + 'mm/yr'
ax.plot(xp, ((sol[0] + v2_rms_min_inv + sol[1]) * 1000.),
'b--',
label=label1)
ax.legend(loc='lower left')
plt.ylabel('Velocity (mm/yr)')
plt.xlabel('Distance (km)')
fig.savefig(directory + 'atan_best_' + str(rmse_inv_min[0]) + '.png')
plt.close()
################################################################################
elif model == 'creep':
##Atan plus creep##
x = x + offset
rmse_c_inv = []
# Q = np.arange(0.00001,rmse_inv[0],100)
d1 = 0.01
for d2 in D:
for s in V:
v1 = v2_rms_min_inv + (
(s / np.pi) *
(np.arctan(x / d1) - np.arctan(x / d2))) + sol[0] + sol[1]
# residual = v1 - avgInSAR
residual = v1 - Vel
# rms = np.sqrt((sum((residual)**2,0))/len(transect))
rms = np.sqrt((sum((residual)**2, 0)) / len(Vel))
rmse_c_inv.append([d1, d2, s, rms])
rmse_c_inv = np.array(rmse_c_inv, np.float32)
idx = np.argmin(rmse_c_inv[:, 3])
rmse_c_inv_min = rmse_c_inv[idx]
print 'Creep Inversion: ' + str(rmse_c_inv_min)
v1_rms_min = (rmse_c_inv_min[2] / np.pi) * (np.arctan(
x / rmse_c_inv_min[0]) - np.arctan(x / rmse_c_inv_min[1]))
# v1_rms_min = (-0.006/np.pi)*(np.arctan(x/rmse_c_inv_min[0])-np.arctan(x/rmse_c_inv_min[1]))
m_c_inv = v1_rms_min + v2_rms_min_inv + sol[0] + sol[1]
################################################################################
# for q in xrange(noit):
# avgVel = []
# rmse_c=[]
# for i in xrange(len(avgInSAR)):
# avgVel.append(np.random.normal(avgInSAR[i], stdInSAR[i]))
# avgVel = np.array(avgVel)
#
# for d2 in D:
# for s in V:
# v1 = sol[0]+sol[1]+v2_rms_min_inv+((s/np.pi)*(np.arctan(x/d1)-np.arctan(x/d2)))
# residual = v1 - avgVel
# # rms = np.sqrt((sum((residual)**2,0))/len(transect))
# rms = np.sqrt((sum((residual)**2,0))/len(Vel))
#
# rmse_c.append([d1,d2, s, rms])
#
# rmse_c = np.array(rmse_c,np.float32)
# idx = np.argmin(rmse_c[:,3])
# rmse_c_min = rmse_c[idx]
# print str(q)+' '+ str(rmse_c_min)
# # v1_rms_c_min = (rmse_c_min[2]/np.pi)*(np.arctan(x/rmse_c_min[0])-np.arctan(x/rmse_c_min[1]))
# # m_c =v1_rms_c_min+v2_rms_min_inv+sol[0]+sol[1]
#
# depth.append(rmse_c_min[1])
# slip.append(rmse_c_min[2])
# varModel.append(rmse_c_min[3]**2)
################################################################################
stdModel = np.sqrt(sum(varModel))
slip[:] = [x * 1000.0 for x in slip]
# fig = plt.figure()
# plt.rcParams.update({'font.size': 22})
# fig.set_size_inches(10,10)
# ax = plt.Axes(fig, [0., 0., 1., 1.], )
# ax=fig.add_subplot(111)
#
# cov = np.cov(slip, depth)
# vals, vecs = eigsorted(cov)
# theta = np.degrees(np.arctan2(*vecs[:,0][::-1]))
# for nstd in xrange(1,4): ####nstd is 1sigma, 2sigma, 3sigma
# w, h = 2 * nstd * np.sqrt(vals)
# ell = Ellipse(xy=(np.mean(slip), np.mean(depth)),
# width=w, height=h,
# angle=theta, color='black')
# ell.set_facecolor('none')
# ax.add_artist(ell)
#
# plt.scatter(slip,depth)
# plt.scatter(rmse_c_min[2]*1000.,rmse_c_min[1], s=60, c='red', marker='*')
# plt.ylabel('Depth (m)')
# plt.xlabel('Slip (mm/yr)')
# # plt.xlim(1,30)
# # plt.ylim(1000,10000)
# fig.savefig('depth_vs_slip.png')
# plt.close()
depth.append(rmse_inv_min[0])
slip.append(rmse_inv_min[1])
stdDepth = roundup(np.std(depth))
stdSlip = math.ceil(np.std(slip))
################################################################################
fig = plt.figure()
plt.rcParams.update({'font.size': 22})
fig.set_size_inches(20, 8)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
##PLOT average and standard deviation##
ax.plot(insarSpace, (transect - transect[0]) * 1000.0,
'o',
ms=1,
mfc='Black',
linewidth='0')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(insarSpace,
((avgInSAR - avgInSAR[0]) - i * stdInSAR) * 1000.,
'-',
color='#DCDCDC',
alpha=0.2) #,color='#DCDCDC')#'LightGrey')
# ax.plot(xp, (avgInSAR-i*stdInSAR)*1000, '-',color='#DCDCDC',alpha=0.5)#,color='#DCDCDC')#'LightGrey')
for i in np.arange(0.0, 1.01, 0.01):
# ax.plot(xp, (avgInSAR+i*stdInSAR)*1000, '-',color='#DCDCDC',alpha=0.5)#'LightGrey')
ax.plot(insarSpace,
((avgInSAR - avgInSAR[0]) + i * stdInSAR) * 1000.,
'-',
color='#DCDCDC',
alpha=0.2) #'LightGrey')
# ax.plot(xp,avgInSAR*1000.0,'r-',label = 'Average velocity')
ax.plot(insarSpace, (avgInSAR - avgInSAR[0]) * 1000.0,
'r-',
label='Average velocity')
ax.plot(GPSdist,
GPSvelPlot - GPSvelPlot[0],
'b^',
label='GPS velocity')
##PLOT average and standard deviation##
label2 = 'Creep depth: 0 - ' + str(
int(rmse_c_inv_min[1])
) + ' $\pm$' + str(stdDepth) + ' m - Creep rate: ' + str(
int(abs(round(rmse_c_inv_min[2] * 1000., 2)))) + ' $\pm$' + str(
int(stdSlip)) + ' mm/yr'
# ax.plot(xp,(m_c_inv*1000.),'k-',label=label2)
# ax.plot(insarGPSSpace,(m_c_inv*1000.),'k-',label=label2)
ax.plot(insarGPSSpace, (m_c_inv * 1000.), 'k-', label=label2)
#
ax.legend(loc='lower left')
plt.ylabel('Velocity (mm/yr)')
plt.xlabel('Distance (km)')
fig.savefig(directory + 'GPS_atan_best_' + str(rmse_c_inv_min[0]) +
'_' + str(rmse_c_inv_min[1]) + '.png')
plt.close()
################################################################################
elif model == 'both':
for d in D:
for s in V:
v2 = sol[0] + ((s / pi) * arctan(x / d)) + sol[1]
residual = v2 - avgInSAR
rms = sqrt((sum((residual)**2, 0)) / len(transect))
rmse.append([d, s, rms])
# print 'RMSE of '+ str(d)+' meters ' + str(s)+' m/yr: '+str(rms)
rmse = array(rmse, float32)
idx = argmin(rmse[:, 2])
rmse_min = rmse[idx]
print rmse_min
v2_rms_min = ((rmse_min[1] / pi) * arctan(x / rmse_min[0]))
##Atan plus creep##
x = x + offset
rmse_c = []
Q = arange(0.00001, rmse_min[0], 100)
d1 = 0.01
for d2 in D:
for s in V:
v1 = sol[0] + sol[1] + v2_rms_min + (
(s / pi) * (arctan(x / d1) - arctan(x / d2)))
residual = v1 - avgInSAR
rms = sqrt((sum((residual)**2, 0)) / len(transect))
rmse_c.append([d1, d2, s, rms])
rmse_c = array(rmse_c, float32)
idx = argmin(rmse_c[:, 3])
rmse_c_min = rmse_c[idx]
print rmse_c_min
v1_rms_min = (rmse_c_min[2] / pi) * (arctan(x / rmse_c_min[0]) -
arctan(x / rmse_c_min[1]))
m_c = v1_rms_min + v2_rms_min + sol[0] + sol[1]
####################
fig = plt.figure()
plt.rcParams.update({'font.size': 22})
fig.set_size_inches(20, 8)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
##PLOT average and standard deviation##
ax.plot(xp, transect * 1000.0, 'o', ms=1, mfc='Black', linewidth='0')
for i in arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR - i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #,color='#DCDCDC')#'LightGrey')
for i in arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR + i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #'LightGrey')
ax.plot(xp, avgInSAR * 1000.0, 'r-', label='Average velocity')
label1 = 'Interseismic only: Locking depth: ' + str(int(
rmse_min[0])) + ' meters - Slip rate: ' + str(
int(abs(round(rmse_min[1] * 1000., 2)))) + ' mm/yr'
ax.plot(xp, ((sol[0] + v2_rms_min + sol[1]) * 1000.),
'b--',
label=label1)
label2 = 'Interseismic with creep: Creep depth: 0 - ' + str(
int(rmse_c_min[1])) + ' meters - Creep rate: ' + str(
int(abs(round(rmse_c_min[2] * 1000., 2)))) + ' mm/yr'
ax.plot(xp, (m_c * 1000.), 'k-', label=label2)
ax.legend(loc='lower left')
plt.ylabel('Velocity (mm/yr)')
plt.xlabel('Distance (km)')
fig.savefig(directory + 'atan_best_' + str(rmse_c_min[0]) + '_' +
str(rmse_c_min[1]) + '.png')
plt.close()
else:
print '''
*******************************************
Usage: atan_bestfit_creep.py directory model offset
directory: directory to transect.mat file
model: 'interseismic' or 'creep'
offset: if there is an offset of creep from the fault
*******************************************
'''
sys.exit(1)
def removeBadSamples(self, mindist=7, maxdist=9999):
'''
Do the following refinement:
(1) remove the samples who's minimum distance to facet boundary is smaller than mindist
(2) remove the samples who's maximum distance to facet boundary is larger than mindist
## input
mindist, maxdist
as explained in the begining
author: weiwei
date: 20160623 flight to tokyo
'''
# ref = refine
self.objsamplepnts_ref = np.ndarray(shape=(self.facets.shape[0], ),
dtype=np.object)
self.objsamplenrmls_ref = np.ndarray(shape=(self.facets.shape[0], ),
dtype=np.object)
self.facet2dbdries = []
for i, faces in enumerate(self.facets):
# print("removebadsample")
# print(i,len(self.facets))
facetp = None
face0verts = self.objtrimesh.vertices[self.objtrimesh.faces[
faces[0]]]
facetmat = robotmath.rotmatfacet(self.facetnormals[i],
face0verts[0], face0verts[1])
# face samples
samplepntsp = []
for j, apnt in enumerate(self.objsamplepnts[i]):
apntp = np.dot(facetmat, apnt)[:2]
samplepntsp.append(apntp)
# face boundaries
for j, faceidx in enumerate(faces):
vert0 = self.objtrimesh.vertices[self.objtrimesh.faces[faceidx]
[0]]
vert1 = self.objtrimesh.vertices[self.objtrimesh.faces[faceidx]
[1]]
vert2 = self.objtrimesh.vertices[self.objtrimesh.faces[faceidx]
[2]]
vert0p = np.dot(facetmat, vert0)[:2]
vert1p = np.dot(facetmat, vert1)[:2]
vert2p = np.dot(facetmat, vert2)[:2]
facep = Polygon([vert0p, vert1p, vert2p])
if facetp is None:
facetp = facep
else:
try:
facetp = facetp.union(facep)
except:
continue
self.facet2dbdries.append(facetp)
selectedele = []
for j, apntp in enumerate(samplepntsp):
try:
apntpnt = Point(apntp[0], apntp[1])
dbnds = []
dbnds.append(apntpnt.distance(facetp.exterior))
for fpinter in facetp.interiors:
dbnds.append(apntpnt.distance(fpinter))
dbnd = min(dbnds)
if dbnd < mindist or dbnd > maxdist:
pass
else:
selectedele.append(j)
except:
pass
self.objsamplepnts_ref[i] = np.asarray(
[self.objsamplepnts[i][j] for j in selectedele])
self.objsamplenrmls_ref[i] = np.asarray(
[self.objsamplenrmls[i][j] for j in selectedele])
self.facet2dbdries = np.array(self.facet2dbdries)
def main(argv):
try:
directory = argv[0] + '/'
model = argv[1]
offset = float(argv[2])
noit = int(argv[3])
except:
print '''
*******************************************
Usage: atan_bestfit_creep.py [directory] [model] [offset] [number of MC iterations]
directory: directory to transect.mat file
model: 'interseismic' or 'creep' or 'both'
offset: if there is an offset of creep from the fault (in meters)
*******************************************
'''
sys.exit(1)
fileList = glob.glob(directory + '/*.mat')
transectmat = scipy.io.loadmat(str(fileList[0]))
# transect = transectmat['dataset'][0][0][1]
transect = transectmat['dataset'][0][0][1]
avgInSAR = np.nanmean(transect, axis=1)
stdInSAR = np.nanstd(transect, axis=1)
transect_dist = transectmat['dataset'][0][0][2]
transect_lat_first = transectmat['dataset'][0][0][0][0][25]
transect_lon_first = transectmat['dataset'][0][0][3][0][25]
transect_first = Point(transect_lon_first, transect_lat_first)
transect_lat_end = transectmat['dataset'][0][0][0][-1][25]
transect_lon_end = transectmat['dataset'][0][0][3][-1][25]
transect_end = Point(transect_lon_end, transect_lat_end)
transect_middle_line = LineString([(transect_first), (transect_end)])
fault_line = LineString([(26.835038363171353, 40.600641025641025),
(26.849744245524295, 40.605769230769226),
(26.86253196930946, 40.610256410256405),
(26.875319693094628, 40.61474358974359),
(26.884271099744243, 40.61730769230769),
(26.896419437340153, 40.621153846153845),
(26.90920716112532, 40.625),
(26.929028132992325, 40.631410256410255),
(26.93542199488491, 40.63525641025641),
(26.95012787723785, 40.64038461538461),
(26.96547314578005, 40.64487179487179),
(26.975703324808183, 40.648717948717945),
(26.982097186700766, 40.651282051282045),
(26.992966751918157, 40.65448717948718),
(27.005754475703323, 40.65961538461538),
(27.01918158567775, 40.66474358974359),
(27.028772378516624, 40.66858974358974),
(27.033887468030688, 40.67115384615384),
(27.04092071611253, 40.674358974358974),
(27.04923273657289, 40.67820512820513),
(27.058823529411764, 40.68141025641025),
(27.062020460358056, 40.682051282051276),
(27.072250639386187, 40.68589743589743),
(27.083759590792837, 40.68846153846154),
(27.09846547314578, 40.69102564102564),
(27.108056265984654, 40.69358974358974),
(27.121483375959077, 40.69615384615384),
(27.13107416879795, 40.69807692307692),
(27.141943734015346, 40.70128205128205),
(27.160485933503836, 40.70641025641025),
(27.186700767263424, 40.71282051282051),
(27.19757033248082, 40.715384615384615),
(27.20843989769821, 40.71730769230769),
(27.224424552429667, 40.72115384615385),
(27.239769820971865, 40.725641025641025),
(27.251918158567772, 40.72948717948718),
(27.26790281329923, 40.73461538461538),
(27.280690537084396, 40.73782051282051)])
intersect = transect_middle_line.intersection(fault_line)
#intersect = intersection(transect_middle_line,fault_line)
dist = (transect_first.distance(intersect)) * 100000.0
dist2 = (intersect.distance(transect_end)) * 100000.0
################################################################################
###GPS LOCATIONS
# bgnt = [26.570, 40.932]
# doku = [26.706, 40.739]
# kvam = [26.871, 40.601]
# kvam2 = [26.871, 40.601]
# sev2 = [26.880, 40.396]
# transect_lat = transectmat['dataset'][0][0][0][0]
# transect_lon = transectmat['dataset'][0][0][3][0]
# print(transect_lat[-1])
# print(transect_lon[0])
# transect_lat_end = transectmat['dataset'][0][0][0][-1]
# transect_lon_end = transectmat['dataset'][0][0][3][-1]
# print(transect_lat_end[0])
# print(transect_lon_end[-1])
# sys.exit()
################################################################################
depth = []
slip = []
McMinRms = []
varModel = []
##1-D space##
x = np.linspace(-dist, dist2, num=len(avgInSAR), endpoint=True)
xp = (x / 1000.)
################################################################################
avgInSAR = avgInSAR - avgInSAR[0]
transect = transect - transect[0]
G = np.ones([len(transect), 2])
G[:, 0] = xp
G_inv = np.dot(np.linalg.inv(np.dot(G.T, G)), G.T)
G_inv = np.array(G_inv, np.float32)
sol = np.dot(G_inv, avgInSAR)
k = np.dot(G, sol)
V = np.arange(-0.000, -0.03, -0.0005)
D = np.arange(0.0001, 6000., 100.)
rmse_inv = []
for d in D:
for s in V:
v2 = sol[0] + ((s / np.pi) * np.arctan(x / d)) + sol[1]
residual = v2 - avgInSAR
rms = np.sqrt((sum((residual)**2, 0)) / len(transect))
rmse_inv.append([d, s, rms])
rmse_inv = [[9000, -0.020, 0]]
rmse_inv = np.array(rmse_inv, np.float32)
idx = np.argmin(rmse_inv[:, 2])
rmse_inv_min = rmse_inv[idx]
print 'Inversion: ' + str(rmse_inv_min)
v2_rms_min_inv = sol[0] + sol[1] + (
(rmse_inv_min[1] / np.pi) * np.arctan(x / rmse_inv_min[0]))
################################################################################
if model == 'interseismic':
#######Monte-Carlo Error Bounds#################################################
for q in xrange(noit):
avgVel = []
for i in xrange(len(avgInSAR)):
avgVel.append(np.random.normal(avgInSAR[i], stdInSAR[i]))
avgVel = np.array(avgVel)
G = np.ones([len(avgVel), 2])
G[:, 0] = xp
G_inv = np.dot(np.linalg.inv(np.dot(G.T, G)), G.T)
G_inv = np.array(G_inv, np.float32)
sol = np.dot(G_inv, avgVel)
k = np.dot(G, sol)
# D = np.arange(1000.,10000.,100.)
# V = np.arange(-0.001,-0.030,-0.0005)
rmse_Mc = []
for d in D:
for s in V:
v2 = sol[0] + ((s / np.pi) * np.arctan(x / d)) + sol[1]
residual = v2 - avgVel
rms = np.sqrt((sum((residual)**2, 0)) / len(transect))
rmse_Mc.append([d, s, rms])
#######Monte-Carlo Error Bounds#################################################
rmse_Mc_inv = np.array(rmse_Mc, np.float32)
idx = np.argmin(rmse_Mc_inv[:, 2])
rmse_Mc_inv_min = rmse_Mc_inv[idx]
print str(q) + ' ' + str(rmse_Mc_inv_min)
depth.append(rmse_Mc_inv_min[0])
slip.append(rmse_Mc_inv_min[1])
# r.append(rmse_min[2])
varModel.append(rmse_Mc_inv_min[2]**2)
McMinRms.append(rmse_Mc_inv_min[2])
stdModel = np.sqrt(sum(varModel))
slip[:] = [x * -1000.0 for x in slip]
stdDepth = roundup(np.std(depth))
stdSlip = math.ceil(np.std(slip))
################################################################################
##PLOT average and standard deviation##
fig = plt.figure()
plt.rcParams.update({'font.size': 24})
fig.set_size_inches(12, 12)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
plt.scatter(slip, depth, c='blue', marker='.')
plt.scatter(rmse_inv_min[1] * -1000.,
rmse_inv_min[0],
s=200,
c='red',
marker='*')
depth.append(rmse_inv_min[0])
slip.append(rmse_inv_min[1])
McMinRms.append(rmse_inv_min[2] * 1000.)
Xi, Yi = np.meshgrid(-V * 1000., D)
z = np.array(np.reshape(rmse_Mc_inv[:, 2], (len(V), len(D))) * 1000.)
# z = np.array(McMinRms)*1000
# contours = plt.contour(Xi, Yi, z*1000.,int(np.amax(z*1000.)-np.amin(z*1000.)))
# contours = plt.contour(Xi, Yi, z,500,colors='black')
# contours = plt.contour(Xi, Yi, z,levels=(2.50,2.75,3,3.25,3.50,3.75,4,4.25,4.50,4.75,5),colors='black',linewidths=0.5)
contours = plt.contour(Xi, Yi, z, 20, colors='black', linewidths=0.5)
plt.clabel(contours, inline=True, fontsize=18, fmt='%.2f')
cov = np.cov(slip, depth)
vals, vecs = eigsorted(cov)
theta = np.degrees(np.arctan2(*vecs[:, 0][::-1]))
for nstd in xrange(1, 2): ####nstd is 1sigma, 2sigma, 3sigma
w, h = 2 * nstd * np.sqrt(vals)
ell = Ellipse(xy=(np.mean(slip), np.mean(depth)),
width=w,
height=h,
angle=theta,
color='black')
ell.set_facecolor('none')
ell.set_linestyle('--')
ell.set_linewidth('2')
ax.add_artist(ell)
ax.annotate('68%',
xy=((np.mean(slip)), (np.mean(depth) - (w / 2))),
xycoords='data')
print 'Mean Slip ' + str(np.mean(slip))
print 'Mean Depth ' + str(np.mean(depth))
print 'W: ' + str(w)
print 'H: ' + str(h)
plt.ylabel('Locking Depth (m)')
plt.xlabel('Slip (mm/yr)')
# plt.xlim(0,20)
# plt.ylim(1000,6000)
fig.savefig('depth_vs_slip.png')
plt.close()
################################################################################
fig = plt.figure()
plt.rcParams.update({'font.size': 20})
fig.set_size_inches(20, 8)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
ax.plot(xp, transect * 1000.0, 'o', ms=1, mfc='Black', linewidth='0')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR - i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #,color='#DCDCDC')#'LightGrey')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR + i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #'LightGrey')
ax.plot(xp, avgInSAR * 1000.0, 'r-', label='Average velocity')
label1 = 'Interseismic only: Locking depth: ' + str(
int(rmse_inv_min[0])) + '$\pm$' + str(
int(stdDepth)) + 'm - Slip rate: ' + str(
int(abs(round(
rmse_inv_min[1] * 1000., 2)))) + '$\pm$' + str(
int(stdSlip)) + ' mm/yr'
# label1 = 'D: '+str(int(rmse_inv_min[0]))+'$\pm$'+str(int(stdDepth))+'m - V: '+str(int(abs(round(rmse_inv_min[1]*1000.,2))))+'$\pm$'+str(int(stdSlip))+'mm/yr'
ax.plot(xp, ((v2_rms_min_inv) * 1000.), 'b--', label=label1)
ax.legend(loc='lower left')
plt.ylabel('Velocity (mm/yr)')
plt.xlabel('Distance (km)')
fig.savefig(directory + 'atan_best_' + str(rmse_inv_min[0]) + '.png')
plt.close()
################################################################################
elif model == 'creep':
x = x + offset
rmse_c_inv = []
# Q = np.arange(0.00001,rmse_inv[0],100)
d1 = 0.01
for d2 in D:
for s in V:
v1 = v2_rms_min_inv + ((s / np.pi) *
(np.arctan(x / d1) - np.arctan(x / d2)))
residual = v1 - avgInSAR
rms = np.sqrt((sum((residual)**2, 0)) / len(transect))
rmse_c_inv.append([d1, d2, s, rms])
rmse_c_inv = np.array(rmse_c_inv, np.float32)
idx = np.argmin(rmse_c_inv[:, 3])
rmse_c_inv_min = rmse_c_inv[idx]
print 'Creep Inversion: ' + str(rmse_c_inv_min)
v1_rms_min = (rmse_c_inv_min[2] / np.pi) * (np.arctan(
x / rmse_c_inv_min[0]) - np.arctan(x / rmse_c_inv_min[1]))
m_c_inv = v1_rms_min + v2_rms_min_inv
#######Monte-Carlo Error Bounds#################################################
for q in xrange(noit):
avgVel = []
rmse_c = []
for i in xrange(len(avgInSAR)):
avgVel.append(np.random.normal(avgInSAR[i], stdInSAR[i]))
avgVel = np.array(avgVel)
for d2 in D:
for s in V:
v1 = v2_rms_min_inv + (
(s / np.pi) * (np.arctan(x / d1) - np.arctan(x / d2)))
residual = v1 - avgVel
rms = np.sqrt((sum((residual)**2, 0)) / len(transect))
rmse_c.append([d1, d2, s, rms])
rmse_c = np.array(rmse_c, np.float32)
idx = np.argmin(rmse_c[:, 3])
rmse_c_min = rmse_c[idx]
print str(q) + ' ' + str(rmse_c_min)
# v1_rms_c_min = (rmse_c_min[2]/np.pi)*(np.arctan(x/rmse_c_min[0])-np.arctan(x/rmse_c_min[1]))
# m_c =v1_rms_c_min+v2_rms_min_inv+sol[0]+sol[1]
depth.append(rmse_c_min[1])
slip.append(rmse_c_min[2])
varModel.append(rmse_c_min[3]**2)
McMinRms.append(rmse_c_min[3])
stdModel = np.sqrt(sum(varModel))
slip[:] = [x * -1000.0 for x in slip]
#######Monte-Carlo Error Bounds Plot STD Ellipses###############################
fig = plt.figure()
plt.rcParams.update({'font.size': 24})
fig.set_size_inches(12, 12)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
plt.scatter(slip, depth, c='blue', marker='.')
plt.scatter(rmse_c_inv_min[2] * -1000.,
rmse_c_inv_min[1],
s=200,
c='red',
marker='*')
depth.append(rmse_c_inv_min[1])
slip.append(rmse_c_inv_min[2] * -1000.)
McMinRms.append(rmse_c_inv_min[3] * 1000.)
Xi, Yi = np.meshgrid(-V * 1000., D)
z = np.array(np.reshape(rmse_c[:, 3], (len(V), len(D))) * 1000.)
# z = np.array(McMinRms)*1000
# contours = plt.contour(Xi, Yi, z*1000.,int(np.amax(z*1000.)-np.amin(z*1000.)))
# contours = plt.contour(Xi, Yi, z,500,colors='black')
# contours = plt.contour(Xi, Yi, z,levels=(2.50,2.75,3,3.25,3.50,3.75,4,4.25,4.50,4.75,5),colors='black',linewidths=0.5)
# contours = plt.contour(Xi, Yi, z,700,colors='black',linewidths=0.5)
#
# plt.clabel(contours, inline=True, fontsize=18,fmt='%.2f')
cov = np.cov(slip, depth)
vals, vecs = eigsorted(cov)
theta = np.degrees(np.arctan2(*vecs[:, 0][::-1]))
for nstd in xrange(1, 2): ####nstd is 1sigma, 2sigma, 3sigma
w, h = 2 * nstd * np.sqrt(vals)
ell = Ellipse(xy=(np.mean(slip), np.mean(depth)),
width=w,
height=h,
angle=theta,
color='black')
ell.set_facecolor('none')
ell.set_linestyle('--')
ell.set_linewidth('2')
ax.add_artist(ell)
ax.annotate('68%',
xy=((np.mean(slip)), (np.mean(depth) + (w / 2))),
xycoords='data')
print 'Mean Slip ' + str(np.mean(slip))
print 'Mean Depth ' + str(np.mean(depth))
print 'W: ' + str(w)
print 'H: ' + str(h)
plt.ylabel('Depth (m)')
plt.xlabel('Slip (mm/yr)')
# plt.xlim(0,10)
# plt.ylim(200,1200)
fig.savefig('depth_vs_slip.png')
plt.close()
# fig = plt.figure()
# plt.rcParams.update({'font.size': 22})
# fig.set_size_inches(10,10)
# ax = plt.Axes(fig, [0., 0., 1., 1.], )
# ax=fig.add_subplot(111)
#
# plt.scatter(slip,depth)
# plt.scatter(rmse_c_min[2]*1000.,rmse_c_min[1], s=200, c='red', marker='*')
# plt.ylabel('Depth (m)')
# plt.xlabel('Slip (mm/yr)')
# # plt.xlim(1,30)
# # plt.ylim(1000,10000)
# fig.savefig('depth_vs_slip.png')
# plt.close()
#
# depth.append(rmse_inv_min[0])
# slip.append(rmse_inv_min[1])
# stdDepth = roundup(np.std(depth))
# stdSlip = math.ceil(np.std(slip))
#
# fig = plt.figure()
# plt.rcParams.update({'font.size': 22})
# fig.set_size_inches(15,15)
# ax = plt.Axes(fig, [0., 0., 1., 1.], )
# ax=fig.add_subplot(111)
# InvRms = rmse_c[:,3]
# z = np.array(np.reshape(InvRms,(len(V),len(D))))
# Xi, Yi = np.meshgrid(-V*1000.,D)
# # plt.scatter(-rmse_inv[:,1]*1000.,rmse_inv[:,0],c='blue')
# plt.scatter(rmse_c_min[2]*1000.,rmse_c_min[1], s=500, c='red', marker='*')
# contours = plt.contour(Xi, Yi, z*1000,int(np.amax(z*1000.)-np.amin(z*1000.)), colors='black')
# # contours = plt.contour(Xi, Yi, z*1000.,int(np.amax(z*1000.)-np.amin(z*1000.)), cmap='RdGy')
# plt.clabel(contours, inline=True, fontsize=10)
# # CS = plt.contourf(Xi, Yi, z*1000.,50, cmap='RdGy')
# # plt.colorbar();
# plt.ylabel('Depth (m)')
# plt.xlabel('Slip (mm/yr)')
# # plt.xlim(-1,20)
# # plt.ylim(-100,20000)
# fig.savefig('Contour_depth_vs_slip.png')
# plt.close()
####################################Error Ellipses##############################
# fig = plt.figure()
# plt.rcParams.update({'font.size': 22})
# fig.set_size_inches(10,10)
# ax = plt.Axes(fig, [0., 0., 1., 1.], )
# ax=fig.add_subplot(111)
#
# cov = np.cov(slip, depth)
# vals, vecs = eigsorted(cov)
# theta = np.degrees(np.arctan2(*vecs[:,0][::-1]))
# for nstd in xrange(1,4): ####nstd is 1sigma, 2sigma, 3sigma
# w, h = 2 * nstd * np.sqrt(vals)
# ell = Ellipse(xy=(np.mean(slip), np.mean(depth)),
# width=w, height=h,
# angle=theta, color='black')
# ell.set_facecolor('none')
# ax.add_artist(ell)
# plt.scatter(slip,depth)
# plt.scatter(rmse_c_min[2]*1000.,rmse_c_min[1], s=60, c='red', marker='*')
# plt.ylabel('Depth (m)')
# plt.xlabel('Slip (mm/yr)')
# # plt.xlim(1,30)
# # plt.ylim(1000,10000)
# fig.savefig('depth_vs_slip.png')
# plt.close()
####################################Error Ellipses##############################
##Monte-Carlo Error Bounds Plot STD Ellipses####################################
# depth.append(rmse_c_inv_min[0])
# slip.append(rmse_c_inv_min[1])
stdDepth = roundup(np.std(depth))
stdSlip = math.ceil(np.std(slip))
################################################################################
fig = plt.figure()
plt.rcParams.update({'font.size': 22})
fig.set_size_inches(20, 8)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
ax.plot(xp, transect * 1000.0, 'o', ms=1, mfc='Black', linewidth='0')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR - i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #,color='#DCDCDC')#'LightGrey')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR + i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #'LightGrey')
ax.plot(xp, avgInSAR * 1000.0, 'r-', label='Average velocity')
label2 = 'Creep depth: 0 - ' + str(
int(rmse_c_inv_min[1])
) + '$\pm$' + str(stdDepth) + ' m - Creep rate: ' + str(
int(abs(round(rmse_c_inv_min[2] * 1000., 2)))) + '$\pm$' + str(
int(stdSlip)) + ' mm/yr'
ax.plot(xp, (m_c_inv * 1000.), 'k-', label=label2)
ax.legend(loc='lower left')
plt.ylabel('Velocity (mm/yr)')
plt.xlabel('Distance (km)')
fig.savefig(directory + 'atan_best_' + str(rmse_c_inv_min[0]) + '_' +
str(rmse_c_inv_min[1]) + '.png')
plt.close()
################################################################################
elif model == 'both':
transect = transect - transect[0]
avgInSAR = avgInSAR - avgInSAR[0]
rmse = []
for d in D:
for s in V:
v2 = sol[0] + ((s / np.pi) * np.arctan(x / d)) + sol[1]
residual = v2 - avgInSAR
rms = np.sqrt((sum((residual)**2, 0)) / len(transect))
rmse.append([d, s, rms])
# print 'RMSE of '+ str(d)+' meters ' + str(s)+' m/yr: '+str(rms)
rmse = np.array(rmse, np.float32)
idx = np.argmin(rmse[:, 2])
rmse_min = rmse[idx]
print rmse_min
v2_rms_min = ((rmse_min[1] / np.pi) * np.arctan(x / rmse_min[0]))
##Atan plus creep##
x = x + offset
rmse_c = []
# Q = arange(0.00001,rmse_min[0],100)
d1 = 0.01
rmse_c = []
for d2 in D:
for s in V:
v1 = sol[0] + sol[1] + v2_rms_min + (
(s / np.pi) * (np.arctan(x / d1) - np.arctan(x / d2)))
residual = v1 - avgInSAR
rms = np.sqrt((sum((residual)**2, 0)) / len(transect))
rmse_c.append([d1, d2, s, rms])
rmse_c = np.array(rmse_c, np.float32)
idx = np.argmin(rmse_c[:, 3])
rmse_c_min = rmse_c[idx]
print rmse_c_min
v1_rms_min = (rmse_c_min[2] / np.pi) * (np.arctan(x / rmse_c_min[0]) -
np.arctan(x / rmse_c_min[1]))
m_c = v1_rms_min + v2_rms_min + sol[0] + sol[1]
####################
fig = plt.figure()
plt.rcParams.update({'font.size': 22})
fig.set_size_inches(20, 8)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
##PLOT average and standard deviation##
ax.plot(xp, transect * 1000.0, 'o', ms=1, mfc='Black', linewidth='0')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR - i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #,color='#DCDCDC')#'LightGrey')
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(xp, (avgInSAR + i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) #'LightGrey')
ax.plot(xp, avgInSAR * 1000.0, 'r-', label='Average velocity')
label1 = 'Interseismic only: Locking depth: ' + str(int(
rmse_min[0])) + ' meters - Slip rate: ' + str(
int(abs(round(rmse_min[1] * 1000., 2)))) + ' mm/yr'
ax.plot(xp, ((sol[0] + v2_rms_min + sol[1]) * 1000.),
'b--',
label=label1)
label2 = 'Interseismic with creep: Creep depth: 0 - ' + str(
int(rmse_c_min[1])) + ' meters - Creep rate: ' + str(
int(abs(round(rmse_c_min[2] * 1000., 2)))) + ' mm/yr'
ax.plot(xp, (m_c * 1000.), 'k-', label=label2)
ax.legend(loc='lower left')
plt.ylabel('Velocity (mm/yr)')
plt.xlabel('Distance (km)')
fig.savefig(directory + 'atan_best_' + str(rmse_c_min[0]) + '_' +
str(rmse_c_min[1]) + '.png')
plt.close()
else:
print '''
*******************************************
Usage: atan_bestfit_creep.py directory model offset
directory: directory to transect.mat file
model: 'interseismic' or 'creep'
offset: if there is an offset of creep from the fault
*******************************************
'''
sys.exit(1)
for point in predictionPoints["features"]:
road = linkki.loc[linkki["TIENUMERO"] ==
point["properties"]["roadAddress"]["roadNumber"], :]
road = road.loc[road["AJOSUUNTA"] < 4, :]
road = road.reset_index()
p = Point(point["geometry"]["coordinates"][0],
point["geometry"]["coordinates"][1])
pred2[point["id"]] = {}
i = 0
nearest_linkki = -1
d = float('Inf')
for r in road.geometry:
if p.distance(r) < d:
d = p.distance(r)
nearest_linkki = i
i += 1
segment_id = road.loc[nearest_linkki, "SEGM_ID"]
tmp = width.loc[width['SEGM_ID'] == segment_id, "ARVO"]
if len(tmp) > 0:
pred2[point["id"]]["road_width"] = tmp.values[0]
else:
pred2[point["id"]]["road_width"] = "N/A"
tmp = speed.loc[speed['SEGM_ID'] == segment_id, "ARVO"]
if len(tmp) > 0:
pred2[point["id"]]["speed_limit"] = tmp.values[0]
class VisibilityManager(object):
def __init__(self):
self.method = 0
self.points = []
self.segments = []
self.rays = []
self.lines = []
self.polygon = []
self.eyePosition = Point(950, 500)
def addSegment(self, x1, y1, x2, y2):
self.points.append(Point(x1, y1))
self.points.append(Point(x2, y2))
self.segments.append(LineString([(x1, y1), (x2, y2)]))
def addWorldBoundaries(self, width, height):
self.addSegment(1, 1, width, 1)
self.addSegment(width, 1, width, height)
self.addSegment(width, height, 1, height)
self.addSegment(1, height, 1, 1)
def castRays(self):
self.rays.clear()
if self.method == 0:
for point in self.points:
line = LineString([(self.eyePosition.x, self.eyePosition.y),
(point.x, point.y)])
self.rays.append(line)
if self.method == 1:
for degree in range(0, 360):
rads = radians(degree)
magnitude = 10000
x = cos(rads) * magnitude
y = sin(rads) * magnitude
self.rays.append(
LineString([(self.eyePosition.x, self.eyePosition.y),
(x, y)]))
#self.polygon = DrawPolygon(vertexList)
def calculatePolygon(self):
self.polygon.clear()
for ray in self.rays:
intersections = []
for segment in self.segments:
if ray.intersects(segment):
intersections.append(
(self.eyePosition.distance(ray.intersection(segment)),
ray.intersection(segment)))
self.polygon.append(sorted(intersections)[0][1])
def addLines(self):
self.lines.clear()
if False: #TODO debug
for ray in self.rays:
self.lines.append(
DrawLine(
ray.coords[0][0],
ray.coords[0][1],
ray.coords[1][0],
ray.coords[1][1],
))
for segment in self.segments:
self.lines.append(
DrawLine(
segment.coords[0][0],
segment.coords[0][1],
segment.coords[1][0],
segment.coords[1][1],
))
if True: #TODO debug
for point in self.polygon:
line = DrawLine(point.x - 5, point.y - 5, point.x + 5,
point.y + 5)
line.changeColor(255, 0, 0)
self.lines.append(line)
def update(self):
self.castRays()
self.calculatePolygon()
self.addLines()
def draw(self):
for line in self.lines:
line.draw()
def on_mouse_motion(self, x, y):
self.eyePosition = Point(x, y)
print(point1)
print(point3D)
print(type(point1))
point_coords = point1.coords
type(point_coords)
xy = point_coords.xy
x = point1.x
y = point1.y
print(xy)
print(x)
print(y)
points_dist = point1.distance(point2)
print('Distance between the points is {0:.2f} decimal degrees'.format(
points_dist))
line = LineString([point1, point2, point3])
line2 = LineString([(2.2, 4.2), (7.2, -25.1), (9.26, -2.456)])
print(line)
lxy = line.xy
print(lxy)
line_x = lxy[0]
line_y = line.xy[1]
print(line_x)
print(line_y)
def extendAllMergedLines(dirPathLines, vectorMask, epsgValue):
"""
extendAllMergedLines.
:param dirPathLines: (text) path
:param vectorMask: (text) path
:param epsgValue: (text) epsg value
:returns: OpenCV version.
"""
crsEpsgId = {'init': 'epsg:' + str(epsgValue)}
crutils.printLogMsg(crglobals.OK_MSG + 'Path Lines: %s' % (dirPathLines))
crutils.printLogMsg(crglobals.OK_MSG + 'Mask: %s' % (vectorMask))
crutils.printLogMsg(crglobals.OK_MSG + 'EPSG: %s' % (epsgValue))
#input merged line file
fileNameMergedLines = 'merged_lines.shp'
mergedLinesGeoDataFrame = gpd.GeoDataFrame.from_file(
os.path.join(
dirPathLines,
fileNameMergedLines)) #dirPathLines+'/'+fileNameMergedLines)
#input mask polygon file
boundsMaskGeoDataFrame = gpd.GeoDataFrame.from_file(vectorMask)
longLinesArray = []
idLongLinesArray = []
for x in range(0, len(mergedLinesGeoDataFrame.geometry)):
linea_bx = (list(mergedLinesGeoDataFrame.geometry[x].coords))
extrapoledLine = getExtrapoledLine(*linea_bx[-2:])
idLongLinesArray.append(x)
longLinesArray.append(extrapoledLine)
dataFrameLongLines = pd.DataFrame({'id': idLongLinesArray})
longLinesGeoDataFrame = gpd.GeoDataFrame(dataFrameLongLines,
crs=crsEpsgId,
geometry=longLinesArray)
longLinesFileName = os.path.join(
dirPathLines,
'merged_lines_long.shp') #dirPathLines+'/'+'merged_lines_long.shp'
longLinesGeoDataFrame.to_file(driver='ESRI Shapefile',
filename=longLinesFileName)
crutils.printLogMsg(crglobals.DONE_MSG + 'Generated long lines !')
#######################################################################################
#Get the convex hull lines
convexHullFromBoundsMask = boundsMaskGeoDataFrame.convex_hull.iloc[0]
x, y = convexHullFromBoundsMask.exterior.xy
pointsConvexHullFromBoundsMaskArray = np.array(list(zip(x, y)))
minBBoxRect = imboundrect.minimum_bounding_rectangle(
pointsConvexHullFromBoundsMaskArray)
polygonOMBB = Polygon(
[minBBoxRect[0], minBBoxRect[1], minBBoxRect[2], minBBoxRect[3]])
#######################################################################################
#cut lines by ombb
#update applying buffer. it fix some strange bug at some corner lines
geoDataFrameLineCuttedByBoxBuffer = (longLinesGeoDataFrame.intersection(
polygonOMBB.buffer(20)))
dataFrameLineCuttedByBoxDf = pd.DataFrame({
'id':
idLongLinesArray,
'len':
geoDataFrameLineCuttedByBoxBuffer.length
})
geoDataFrameLinesCuttedByBox = gpd.GeoDataFrame(
dataFrameLineCuttedByBoxDf,
crs=crsEpsgId,
geometry=geoDataFrameLineCuttedByBoxBuffer)
mergedLinesCuttedByOMBBPolygonFile = os.path.join(
dirPathLines, 'merged_lines_long_cut_ombb.shp'
) #dirPathLines+'/'+'merged_lines_long_cut_ombb.shp'
geoDataFrameLinesCuttedByBox.to_file(
driver='ESRI Shapefile', filename=mergedLinesCuttedByOMBBPolygonFile)
crutils.printLogMsg(crglobals.DONE_MSG + 'Cut long lines by OMBB bounds !')
#######################################################################################
projectDistance = 1
#enumerate lines in spatial order
angle = crutils.getAzimuth(
(geoDataFrameLinesCuttedByBox.geometry[0].coords[0][0]),
(geoDataFrameLinesCuttedByBox.geometry[0].coords[0][1]),
(geoDataFrameLinesCuttedByBox.geometry[0].coords[1][0]),
(geoDataFrameLinesCuttedByBox.geometry[0].coords[1][1]))
anglep = (angle + 270)
#search for the closest geometry line to temporal point
temporalXpoint = (geoDataFrameLinesCuttedByBox.geometry[0].centroid.x
) + np.sin(np.deg2rad(anglep)) * 5000
temporalYpoint = (geoDataFrameLinesCuttedByBox.geometry[0].centroid.y
) + np.cos(np.deg2rad(anglep)) * 5000
temporalExternalPoint = Point((temporalXpoint, temporalYpoint))
crutils.printLogMsg(crglobals.DONE_MSG + 'Generate a Temporal Point')
#print(temporalExternalPoint)
tmpLineDistance = []
for i in range(len(geoDataFrameLinesCuttedByBox)):
distanceCalculated = (temporalExternalPoint.distance(
geoDataFrameLinesCuttedByBox.geometry[i].centroid))
tmpLineDistance.append(distanceCalculated)
#print("i: %s -> distanceCalculated: %s -> %s" % (str(i), str(distanceCalculated) , str(geoDataFrameLinesCuttedByBox.geometry[i]) ))
minelem = np.argmin(tmpLineDistance)
crutils.printLogMsg(crglobals.DONE_MSG + "Found a closest line id: %s" %
(str(minelem)))
#######################################################################################
#Calc Distances using the closest line found
xp = (geoDataFrameLinesCuttedByBox.geometry[minelem].centroid.x) + np.sin(
np.deg2rad(anglep)) * projectDistance
yp = (geoDataFrameLinesCuttedByBox.geometry[minelem].centroid.y) + np.cos(
np.deg2rad(anglep)) * projectDistance
externalPoint = Point((xp, yp))
#print(externalPoint)
geoDistance = []
index = []
for i in range(len(geoDataFrameLinesCuttedByBox)):
#print('-> %s' % ( str( i)))
distanceCalculated = (externalPoint.distance(
geoDataFrameLinesCuttedByBox.geometry[i].centroid))
geoDistance.append(distanceCalculated)
#print(distanceCalculated)
index.append(i)
dataFrameLineCuttedByBoxBuffer = pd.DataFrame({
'len':
geoDataFrameLineCuttedByBoxBuffer.length,
'geo_dist':
geoDistance,
'idx':
index
})
geoDataFrameLinesCuttedByBox = gpd.GeoDataFrame(
dataFrameLineCuttedByBoxBuffer,
crs=crsEpsgId,
geometry=geoDataFrameLineCuttedByBoxBuffer)
mergedLongLinesCuttedByOMBwDistFileName = os.path.join(
dirPathLines, 'merged_lines_long_cut_ombb_wdist.shp'
) #dirPathLines+'/'+'merged_lines_long_cut_ombb_wdist.shp'
geoDataFrameLinesCuttedByBox.to_file(
driver='ESRI Shapefile',
filename=mergedLongLinesCuttedByOMBwDistFileName)
#######################################################################################
#######################################################################################
############## FILTERING LINES LOOKING FOR CANDIDATES #################################
#######################################################################################
#######################################################################################
sortedDistance = np.argsort(geoDistance).astype('int')
idByGeo = [x for _, x in sorted(zip(sortedDistance, index))]
newObjDistancesSorted = np.sort(geoDistance)
#Removing Adjacents and lines duplicates
newObjDistancesSorted = crutils.removeAdjacentsInArray(
newObjDistancesSorted)
#print('====== new distances sorted =====')
#print(newObjDistancesSorted)
crutils.printLogMsg(crglobals.DONE_MSG + 'Candidate lines: %s ' %
str(len(newObjDistancesSorted)))
##Removing Closing Lines
#pairsdistances = zip([0]+newObjDistancesSorted, newObjDistancesSorted)
#TODO: distancesFiltered
#distancesFiltered = [pair[1] for pair in pairsdistances if abs(pair[0]-pair[1]) >=0.5 ]
###########################################
## OTRO APPROACH TO FIND DISTANCES
groups, current_group, first = [], [], newObjDistancesSorted[0]
for item in newObjDistancesSorted:
# Check if this element falls under the current group
if item - first <= 1.3:
current_group.append(item)
else:
# If it doesn't, create a new group and add old to the result
groups.append(current_group[:])
current_group, first = [item], item
# Add the last group which was being gathered to the result
groups.append(current_group[:])
distancesFiltered = [np.max(item) for item in groups]
#iter 1 removing proximal lines
pairsdistances2 = zip([0] + distancesFiltered, distancesFiltered)
distancesFiltered = [
pair[1] for pair in pairsdistances2 if abs(pair[0] - pair[1]) >= 0.4
]
#iter 2 removing proximal lines
pairsdistances3 = zip([0] + distancesFiltered, distancesFiltered)
distancesFiltered = [
pair[1] for pair in pairsdistances3 if abs(pair[0] - pair[1]) >= 0.9
] #>=0.8 -preff: 0.9
######################################3
#print('====== distances filtered =====')
#print(distancesFiltered)
crutils.printLogMsg(crglobals.DONE_MSG +
'Resulting lines: %s ' % str(len(distancesFiltered)))
#TODO: final
#cut final lines by mask
dataFrameCandidateLines = (geoDataFrameLinesCuttedByBox.intersection(
boundsMaskGeoDataFrame.geometry.iloc[0]))
candidateLinesFileName = os.path.join(
dirPathLines,
'candidate_lines.shp') #dirPathLines+'/'+'candidate_lines.shp'
dataFrameLineCuttedByMask = pd.DataFrame({
'distance':
dataFrameCandidateLines.length,
'geo_dist':
geoDistance,
'idx':
index
})
geoDataFrameLineCuttedByMask = gpd.GeoDataFrame(
dataFrameLineCuttedByMask,
crs=crsEpsgId,
geometry=dataFrameCandidateLines)
geoDataFrameLineCuttedByMask.to_file(driver='ESRI Shapefile',
filename=candidateLinesFileName)
#####################################
## NEW CROPROWS - GEOMETRY SEARCH
#####################################
#save candidateLinesbuffer
candidateLinesBufferFileName = os.path.join(dirPathLines,
'candidate_lines_buffer.shp')
candidateLinesBuffer = geoDataFrameLineCuttedByMask.buffer(0.3)
s = candidateLinesBuffer
#ADDING FEATURE 3-9-2018
#DISOLVE OVERLAPPING BUFFER POLYGONS
#https://gis.stackexchange.com/questions/271733/geopandas-dissolve-overlapping-polygons/271735
overlap_matrix = s.apply(lambda x: s.overlaps(x)).values.astype(int)
n, ids = connected_components(overlap_matrix)
df = gpd.GeoDataFrame({'geometry': s, 'group': ids}, crs=crsEpsgId)
res = df.dissolve(by='group')
res.to_file(driver='ESRI Shapefile', filename=candidateLinesBufferFileName)
candidateLinesBufferCentroidFileName = os.path.join(
dirPathLines, 'candidate_lines_buffer_centroid.shp')
points = res.copy()
points.geometry = res['geometry'].centroid
points.crs = res.crs
points.head()
points.to_file(driver='ESRI Shapefile',
filename=candidateLinesBufferCentroidFileName)
df_lines = dataFrameCandidateLines.geometry
df_points = points.geometry
#print(len(df_points))
#print(len(df_lines))
idClosestLineArr = []
#find the closest candidate line to point
for x in range(0, len(df_points)):
minDistancePointLine = df_lines.distance(df_points[x]).min()
allDistanceToLines = df_lines.distance(df_points[x])
idClosestLine = np.where(allDistanceToLines == minDistancePointLine)[0]
idClosestLineArr.append(idClosestLine[0])
#print('centroid point: %s - id closest line: ' % (str(x)) , (str(idClosestLine)) )
#print(idClosestLineArr)
selcr = []
for x in range(0, len(df_lines)):
selcr = df_lines[idClosestLineArr]
crf = 0
geoidcr = []
croprowLength = []
for y in range(0, len(selcr)):
#print(selcr.geometry.iloc[y])
#print(selcr.geometry.iloc[y].length)
croprowLength.append(selcr.geometry.iloc[y].length)
geoidcr.append(crf)
crf = crf + 1
dataFrameCr = pd.DataFrame({
'geometry': selcr,
'crlen': croprowLength,
'idg': geoidcr,
'crg': 'Generated by Crop Rows Generator v1'
})
geoDataFrameCropRows = gpd.GeoDataFrame(dataFrameCr, crs=crsEpsgId)
cropRowsFileNameByGeom = os.path.join(dirPathLines, 'croprows_lines.shp')
geoDataFrameCropRows.to_file(driver='ESRI Shapefile',
filename=str(cropRowsFileNameByGeom))
##EXPORT CROP ROWS RESULTS TO WGS84 SHP AND KML FORMATS
crsExportID = {'init': 'epsg:' + str(crglobals.EXPORT_EPSG)}
exportCropRowsShapeFile = os.path.join(
os.path.dirname(os.path.dirname(dirPathLines)), crglobals.EXPORTDIR,
'croprows_wgs84.shp')
geoDataFrameCropRowsWGS84 = gpd.GeoDataFrame(dataFrameCr, crs=crsEpsgId)
geoDataFrameCropRowsWGS84 = geoDataFrameCropRowsWGS84.to_crs(crsExportID)
geoDataFrameCropRowsWGS84.to_file(driver='ESRI Shapefile',
filename=str(exportCropRowsShapeFile))
exportCropRowsShapeFileKML = os.path.join(
os.path.dirname(os.path.dirname(dirPathLines)), crglobals.EXPORTDIR,
'croprows_wgs84.kml')
geoDataFrameCropRowsWGS84.to_file(driver='kml',
filename=str(exportCropRowsShapeFileKML))
crutils.printLogMsg(
crglobals.DONE_MSG +
'Exported Resulting Crop Rows to KML and SHP format in WGS84 CRS')
cropRowsBufferFileName = os.path.join(dirPathLines,
'croprows_lines_buffer.shp')
cropRowsLinesBuffer = geoDataFrameCropRows.buffer(0.3)
cropRowsLinesBufferGeoData = gpd.GeoDataFrame(crs=crsEpsgId,
geometry=cropRowsLinesBuffer)
cropRowsLinesBufferGeoData.to_file(driver='ESRI Shapefile',
filename=str(cropRowsBufferFileName))
#####################################
## OLD CROPROWS - STAT SEARCH
#####################################
getIndexes = lambda x, xs: [
i for (y, i) in zip(xs, range(len(xs))) if x == y
]
cuttedLineArray = []
#look for
k = []
flagCounter3 = 0
for x in distancesFiltered:
#print(distancesFiltered[i])
#print(getIndexes(distancesFiltered[i],newobjdistances))
k.append(getIndexes(distancesFiltered[flagCounter3], geoDistance)[0])
flagCounter3 = flagCounter3 + 1
#Reindex lines filtered
index2 = []
flagCounter2 = 0
m = []
j = 0
croprowLength = []
for x in k:
m.append(dataFrameCandidateLines[k[j]])
index2.append(flagCounter2)
#line len for each geometry
croprowLength.append(m[j].length)
flagCounter2 += 1
j = j + 1
#print('index2:')
#print(index2)
#print('k')
#print(k)
#print('m')
#print(m)
sortdistance2 = np.argsort(distancesFiltered).astype('int')
idByGeo2 = [x for _, x in sorted(zip(sortdistance2, index2))]
#print('idByGeo2')
#print(idByGeo2)
crutils.printLogMsg(crglobals.DONE_MSG + 'Re-indexing candidate lines !')
#Fix distances substracting projectDistance
arrayDistances = np.array(distancesFiltered)
#fixdist = arrayDistances - projectDistance
crutils.printLogMsg(crglobals.DONE_MSG + 'Distances fixed !')
#print(croprowLength)
#fixdist
dataFrameFixedLines = pd.DataFrame({
'id': k,
'geo_dist': arrayDistances,
'idgeo': idByGeo2,
'crlen': croprowLength
})
#dataFrameFixedLines = pd.DataFrame({ })
geoDataFrameFixedLines = gpd.GeoDataFrame(dataFrameFixedLines,
crs=crsEpsgId,
geometry=m)
geoDataFrameFixedLines.dropna()
crutils.printLogMsg(crglobals.DONE_MSG + 'Result lines generated !')
cropRowsLinesFileName = os.path.join(dirPathLines,
'croprows_lines_stat.shp')
geoDataFrameFixedLines.to_file(driver='ESRI Shapefile',
filename=str(cropRowsLinesFileName))
crutils.printLogMsg(crglobals.DONE_MSG +
'Writing file with resulting lines : %s ' %
(cropRowsLinesFileName))
#saveResultXMLFile(cropRowsLinesFileName)
resultingFiles = [
cropRowsFileNameByGeom, cropRowsBufferFileName,
exportCropRowsShapeFile, exportCropRowsShapeFileKML,
str(epsgValue),
str(len(newObjDistancesSorted)),
str(len(distancesFiltered)), vectorMask
]
saveResultXMLFile(resultingFiles)
#saveResultXMLFile(cropRowsFileNameByGeom,cropRowsBufferFileName,exportCropRowsShapeFile,exportCropRowsShapeFileKML)
#####################################
return 1
def LineGroupingFromSHP(abs_file_path, MINIMALDIST):
sf = shapefile.Reader(abs_file_path)
#------------------------ read lines from shapefile ---------------------------
chains=[]
for geom in sf.shapeRecords():
chain=[(geom.shape.points[0][0],geom.shape.points[0][1]),(geom.shape.points[1][0],geom.shape.points[1][1])]
chains.append(chain)
#------------------------------------------------------------------------------
#------------------ group lines & fix unconnected vertices --------------------
closed_chains=[]
k=1
RADIUS=MINIMALDIST
print '#-----------------------------'
print 'k=', k, 'RADIUS=', RADIUS
print 'len(chains)', len(chains)
print 'len(closed_chains)', len(closed_chains)
while (k<=5 and len(chains)>0):
if len(chains)==1:
pt11=Point(chains[0][0][0], chains[0][0][1])
pt12=Point(chains[0][-1][0],chains[0][-1][1])
if pt11.distance(pt12)<=RADIUS:
chains.pop(0)
l1=LineString([chain1[0], chain1[1]])
l2=LineString([chain1[-1], chain1[-2]])
new_pts1=fix_disjoint_vertices(l1, l2)
new_chain=chain1[1:-1]+new_pts1
closed_chains.append(new_chain)
break
else:
print 'wawawa'
k=k+1
RADIUS=RADIUS+MINIMALDIST
print '#-----------------------------'
print 'k=', k, 'RADIUS=', RADIUS
print 'len(chains)', len(chains)
print 'len(closed_chains)', len(closed_chains)
break
L=len(chains)
for i in range(0, len(chains)-1):
chain1=chains[i]
pt11=Point(chain1[0][0], chain1[0][1])
pt12=Point(chain1[-1][0],chain1[-1][1])
if pt11.distance(pt12)<=RADIUS:
chains.pop(i)
l1=LineString([chain1[0], chain1[1]])
l2=LineString([chain1[-1], chain1[-2]])
new_pts1=fix_disjoint_vertices(l1, l2)
new_chain=chain1[1:-1]+new_pts1
closed_chains.append(new_chain)
break
for j in range(i+1, len(chains)+1):
if j==len(chains):
break
chain2=chains[j]
pt21=Point(chain2[0][0], chain2[0][1])
pt22=Point(chain2[-1][0],chain2[-1][1])
if pt11.distance(pt21)<=RADIUS:
l1=LineString([chain1[0], chain1[1]])
l2=LineString([chain2[0], chain2[1]])
new_pts1=fix_disjoint_vertices(l1, l2)
if pt12.distance(pt22)<=RADIUS:
# closed
l1=LineString([chain1[-1], chain1[-2]])
l2=LineString([chain2[-1], chain2[-2]])
new_pts2=fix_disjoint_vertices(l1, l2)
chains.pop(j)
chains.pop(i)
chain1.reverse()
new_chain=new_pts2+chain1[1:-1]+new_pts1+chain2[1:-1]
closed_chains.append(new_chain)
break
else:
chains.pop(j)
chains.pop(i)
chain1.reverse()
new_chain=chain1[0:-1]+new_pts1+chain2[1:]
chains.append(new_chain)
break
elif pt11.distance(pt22)<=RADIUS:
l1=LineString([chain1[0], chain1[1]])
l2=LineString([chain2[-1], chain2[-2]])
new_pts1=fix_disjoint_vertices(l1, l2)
if pt12.distance(pt21)<=RADIUS:
# closed
l1=LineString([chain1[-1], chain1[-2]])
l2=LineString([chain2[0], chain2[1]])
new_pts2=fix_disjoint_vertices(l1, l2)
chains.pop(j)
chains.pop(i)
new_chain=new_pts1+chain1[1:-1]+new_pts2+chain2[1:-1]
closed_chains.append(new_chain)
break
else:
chains.pop(j)
chains.pop(i)
new_chain=chain2[0:-1]+new_pts1+chain1[1:]
chains.append(new_chain)
break
elif pt12.distance(pt21)<=RADIUS:
l1=LineString([chain1[-1], chain1[-2]])
l2=LineString([chain2[0], chain2[1]])
new_pts1=fix_disjoint_vertices(l1, l2)
chains.pop(j)
chains.pop(i)
new_chain=chain1[0:-1]+new_pts1+chain2[1:]
chains.append(new_chain)
break
elif pt12.distance(pt22)<=RADIUS:
l1=LineString([chain1[-1], chain1[-2]])
l2=LineString([chain2[-1], chain2[-2]])
new_pts1=fix_disjoint_vertices(l1, l2)
chains.pop(j)
chains.pop(i)
chain2.reverse()
new_chain=chain1[0:-1]+new_pts1+chain2[1:]
chains.append(new_chain)
break
else:
continue
if j==L:
continue
else:
break
if i==L-2 and j==L:
print 'hahaha'
k=k+1
RADIUS=RADIUS+MINIMALDIST
print '#-----------------------------'
print 'k=', k, 'RADIUS=', RADIUS
print 'len(chains)', len(chains)
print 'len(closed_chains)', len(closed_chains)
else:
continue
print '#-----------------------------'
print 'len(chains)', len(chains)
print 'len(closed_chains)', len(closed_chains)
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
groups_P=[]
for i in range(0, len(closed_chains)):
if len(closed_chains[i])>2:
if Polygon(closed_chains[i]).is_valid==True:
ply=Polygon(closed_chains[i])
new_ply=polygon.orient(ply, sign=1.0)
groups_P.append(list(new_ply.exterior.coords)[0:-1])
else:
ply=Polygon(closed_chains[i]).buffer(0).exterior.coords
new_ply=polygon.orient(ply, sign=1.0)
groups_P.append(list(new_ply.exterior.coords)[0:-1])
else:
print 'closed_chains ',i,' only has two points'
return groups_P
def build_interp(self, constraint_lines, long_step, constant_long_disc):
"""
Build interpolation, add points and segments
@param constraint_lines <[ConstraintLine]>: list of constraint lines
@param long_step <float>: longitudinal space step
@param constant_long_disc <bool>
"""
nb_pts_inter = 0
self.build_initial_profiles()
# LOOP ON ZONES (between 2 consecutive cross-sections)
logger.info("~> Building mesh per zone and then per bed")
for i, (prev_section, next_section) in enumerate(
zip(self.section_seq, self.section_seq[1:])):
logger.debug("> Zone n°{} : between {} and {}".format(
i, prev_section, next_section))
if constant_long_disc:
nb_pts_inter = prev_section.compute_nb_pts_inter(
next_section, long_step)
Xp_adm_list = np.linspace(0.0, 1.0, num=nb_pts_inter + 2)[1:-1]
# Looking for common limits between cross-sections
common_limits_id = prev_section.common_limits(
next_section.limits.keys())
logger.debug("Common limits: {}".format(list(common_limits_id)))
if len(common_limits_id) < 2:
raise TatooineException(
"No interpolation in the interval %i, between %s and %s (%i common limits)"
% (i, prev_section, next_section, len(common_limits_id)))
else:
first_bed = True
# LOOP ON BEDS
for j, (id1, id2) in enumerate(
zip(common_limits_id, common_limits_id[1:])):
pt_list_L1 = []
pt_list_L2 = []
logger.debug("Bed {}-{}".format(id1, id2))
# Extraction of cross-section portions (= beds)
bed_1 = prev_section.extract_bed(id1, id2)
bed_2 = next_section.extract_bed(id1, id2)
# Curvilinear abscissa along constraint lines
(Xp_profil1_L1,
Xp_profil1_L2) = prev_section.get_Xt_lines(id1, id2)
(Xp_profil2_L1,
Xp_profil2_L2) = next_section.get_Xt_lines(id1, id2)
dXp_L1 = Xp_profil2_L1 - Xp_profil1_L1
dXp_L2 = Xp_profil2_L2 - Xp_profil1_L2
if dXp_L1 < 0:
raise TatooineException(
"The constraint line {} is not oriented correctly".
format(id1))
if dXp_L2 < 0:
raise TatooineException(
"The constraint line {} is not oriented correctly".
format(id2))
if not constant_long_disc:
nb_pts_inter = math.ceil(
min(dXp_L1, dXp_L2) / long_step) - 1
Xp_adm_list = np.linspace(0.0,
1.0,
num=nb_pts_inter + 2)[1:-1]
L1_coord_int = constraint_lines[
id1].coord_sampling_along_line(Xp_profil1_L1,
Xp_profil2_L1,
Xp_adm_list)
L2_coord_int = constraint_lines[
id2].coord_sampling_along_line(Xp_profil1_L2,
Xp_profil2_L2,
Xp_adm_list)
# LOOP ON INTERMEDIATE CROSS-SECTIONS
for k in range(nb_pts_inter):
Xp = Xp_adm_list[k]
P1 = Point(tuple(L1_coord_int[k]))
P2 = Point(tuple(L2_coord_int[k]))
if self.nb_pts_lat is None:
nb_pts_lat = math.ceil(
P1.distance(P2) / self.lat_step) + 1
else:
nb_pts_lat = self.nb_pts_lat
array = bed_1.interp_coord_linear(
bed_2, Xp, nb_pts_lat)
bed_int = Bed(array, ['Xt', 'xt'])
bed_int.move_between_targets(P1, P2)
coord_int = bed_int.array[[
'X', 'Y', 'xt', 'Xt_upstream', 'Xt_downstream'
]] # Ignore `Xt`
pt_list_L1.append(self.i_pt + 1)
if not first_bed:
# ignore first point because the constraint line was already considered
coord_int = coord_int[1:]
self.add_points(coord_int, i, Xp, j)
pt_list_L2.append(self.i_pt)
pt_list_L2 = np.array(
[prev_section.get_limit_by_id(id2)['id_pt']] +
pt_list_L2 +
[next_section.get_limit_by_id(id2)['id_pt']])
self.add_segments_from_node_list(pt_list_L2)
if first_bed:
pt_list_L1 = np.array(
[prev_section.get_limit_by_id(id1)['id_pt']] +
pt_list_L1 +
[next_section.get_limit_by_id(id1)['id_pt']])
self.add_segments_from_node_list(pt_list_L1)
first_bed = False
def contour_intersection(contour_x, contour_y, line_x, line_y, do_plot_in_case_of_failure=False):
"""
Computes the intersection point between two lines.
The first line should be the environmental contour and the second line a
straight line. If there are more multiple intersections the point that has
the longest distance to the origin is returned (assuming the origin is at
the first point of the straight line).
Parameters
----------
contour_x : ndarray of floats,
Coordinates in the first dimension of the contour.
contour_y : ndarray of floats
Coordinates in the second dimension of the contour.
line_x : ndarray of floats
Coordinates in the first dimension of the straight line.
line_y : ndarray of floats
Coordaintes in the second dimension of the straight line.
do_plot_in_case_of_failure : Boolean,
if True a plot of the two lines for which no intersection could be
found is shown.
Returns
-------
x : float
Intersection coordinate in the first dimension.
y : float
Intersection coordinate in the second dimension.
"""
point_list_l1 = list()
for x,y in zip(contour_x, contour_y):
point = Point(x, y)
point_list_l1.append(point)
contour = LineString(point_list_l1)
point_list_l2 = list()
for x,y in zip(line_x, line_y):
point = Point(x, y)
point_list_l2.append(point)
line2 = LineString(point_list_l2)
intersection = contour.intersection(line2)
if type(intersection) is Point:
return intersection.x, intersection.y
if type(intersection) is MultiPoint:
if len(intersection.geoms) > 0:
print(str(len(intersection.geoms)) + ' intersections were found.'
+ ' Using the intersection that is the farthest'
+ ' away from the origin.')
origin = Point(line_x[0], line_y[0])
for i, p in enumerate(intersection.geoms):
if i == 0:
inter_x = p.x
inter_y = p.y
longest_distance = origin.distance(p)
else:
if origin.distance(p) > longest_distance:
inter_x = p.x
inter_y = p.y
return inter_x, inter_y
else:
print('The result is: ' + str(intersection))
warnings.warn('No point of intersection could be found. '
'Returning (nan, nan).', UserWarning)
if do_plot_in_case_of_failure:
fig = plt.figure(figsize=(5, 5), dpi=150)
fig.add_subplot(111)
plt.plot(contour_x, contour_y, 'b-')
plt.plot(line_x, line_y, 'r-')
plt.show()
return np.nan, np.nan
def trova_spazi_parziali_da_frontiere_v2(plan_o, lista_pixel_frontiere, immagine_cluster, labels): #devo flippare le coordinate di lista_pixel_frontiere lista_pixel = [] #mi tengo una copia for p in lista_pixel_frontiere: a = copy.deepcopy(p) lista_pixel.append(a) for p in lista_pixel_frontiere: p.y = immagine_cluster.shape[0]-1 - p.y for p in lista_pixel_frontiere: altezza = len(immagine_cluster) y_p2 = - p.x+ altezza x_p2 = - p.y+ altezza p.x = x_p2 p.y = y_p2 counter=collections.Counter(labels) stanze_gt_con_frontiera = [] ordinamento_frontiere = [] for spazio in plan_o.spazi: for celletta in spazio.cells: num_pixel = 0 cluster = None prima_volta = True c = [] for pixel in lista_pixel_frontiere: posizione = Point(pixel.x,pixel.y) if posizione.distance(celletta.cella) == 0: #significa che quel pixel e' all'interno #print "ci entro????????? mai " num_pixel+=1 c.append(pixel.cluster)#added #if prima_volta == True: #cluster = pixel.cluster #prima_volta = False #print "-------------------<<<<<<<<<<<<", num_pixel #--------aggiungo parte dove faccio media del cluster dominante #nel caso questa cosa va aggiunta anche dalle altre parti max = 0 for elem in c: if c.count(elem) > max: max = c.count(elem) cluster = elem #--------------------- n_elementi_cluster = counter[cluster] #print "il numero di n_elementi_cluster", n_elementi_cluster #if pixel_diversi >= 0.3 * n_elementi_cluster and n_elementi_cluster > 0: #la copertura deve essere il 30% di quel cluster if num_pixel >= 15: #elimino un po' di rumore celletta.set_vedo_frontiera(True) celletta.set_celletta_out(False) celletta.set_celletta_parziale(True) celletta.set_cluster_frontiera(cluster) else: celletta.set_vedo_frontiera(False) celletta.set_celletta_out(False) celletta.set_celletta_parziale(False) celletta.set_cluster_frontiera(None) #se la cella non ha una frontiera associata allora non esiste il cluster frontiera del lista_pixel_frontiere #rifaccio tornare la lista come prima lista_pixel_frontiere = [] for p in lista_pixel: lista_pixel_frontiere.append(p)
def dist_to_shape(pp, s):
p = Point(pp)
d = p.distance(s)
if (d == 0.0):
d = -p.distance(s.exterior)
return d
carundcent = Point((centx, c2[1]))
carupcent = Point((centx, c1[1]))
""" 차의 중앙 지점과 겹치는 곳이 있으면 그곳이 차의 위치 """
for val in vals:
if int(x[-1]) == val:
cnt += 1
if l_poly.intersects(carcent):
l_cnt += 1
if r_poly.intersects(carcent):
r_cnt += 1
if c_poly.intersects(carcent):
c_cnt += 1
if c_cnt > 1: c_cnt = 1
# 앞 차량과의 거리계산
pl = carundcent.distance(Point(whalf - 5, 720))
dist = (pl * 1.8 /
(next_frame[6] -
next_frame[2])) * 180 / np.pi
dist = round(map(dist, 20, 40, 10, 70), 2)
# 앞 차량의 Detection Box----------------------------
cv2.rectangle(frame, c1, c2, blue, 1)
t_size = cv2.getTextSize(label, font2, 1, 1)[0]
c2 = c1[0] + t_size[0], c1[1] - t_size[1]
cv2.rectangle(frame, c1, c2, blue, -1)
#---------------------------------------------------
cv2.line(frame, (centx, c1[1]),
def calc_gz(GL_FILE='',WIDTH_FILE='',BASIN_FILE='',VEL_FILE='',POINT_FILE='',region='',dist=0,N=0,vel_thr=0):
#-- read the grounding lines
df_gl = gpd.read_file(GL_FILE)
#-- read widths
df_w = gpd.read_file(WIDTH_FILE)
#-- read the basin file
basins = gpd.read_file(BASIN_FILE)
idx = basins.index[basins['NAME']==region]
#-- get polygon
poly = basins['geometry'][idx[0]]
#-- add a 5km buffer to find the corresponding GLs
region_poly = poly.buffer(5e3)
lines = []
dates = []
for i in range(len(df_gl)):
#-- extract geometry to see if it's in region of interest
ll = df_gl['geometry'][i]
if ll.intersects(region_poly):
lines.append(ll)
dates.append(df_gl['FILENAME'][i].split("_")[2])
#-- get width lines
ws = []
for i in range(len(df_w)):
ws.append(df_w['geometry'][i])
widths = MultiLineString(ws)
#-- merge all lines into linestring
lm = ops.linemerge(lines)
#-- also create a polygon to represent the GZ with a small buffer (10cm)
gz_file = os.path.join(os.path.dirname(GL_FILE),'GZ_{0}.shp'.format(region))
if os.path.exists(gz_file):
print('Reading GZ polygon from file.')
gz_df = gpd.read_file(gz_file)
gz_poly = []
for i in range(len(gz_df)):
gz_poly.append(gz_df['geometry'][i])
gz_poly = MultiPolygon(gz_poly)
else:
print('Creating GZ polygon.')
ep = lm.buffer(1e-1)
#-- get the boundary of the polygon containing all lines to make new polygon of just the envelope
gz_poly = []
for ip in ep:
x,y = ip.exterior.coords.xy
gz_poly.append(Polygon(zip(x,y)))
#-- save the error polygon
#-- first make DataFrame
df = {'REGION':[],'center_x':[],'center_y':[]}
out_geo = []
for p in gz_poly:
#-- note the width can be calculated from area and perimeter
w = (-p.length+np.sqrt(p.length**2 - 16*p.area))/4
l = p.length/2 - w
print(w,l)
if (w > 1 and l > 1):
df['REGION'].append(region)
x,y = p.centroid.coords.xy
df['center_x'].append(x[0])
df['center_y'].append(y[0])
out_geo.append(p)
out_gdf = gpd.GeoDataFrame(df,geometry=out_geo,crs=df_gl.crs)
out_gdf.to_file(gz_file,driver='ESRI Shapefile')
#-- read velocity field
vel_fid = nc.Dataset(VEL_FILE,'r')
x = vel_fid['x'][:]
y = vel_fid['y'][:]
vx = vel_fid['VX'][:]
vy = vel_fid['VY'][:]
#-- also read lat and lon
# vel_lat = vel_fid['lat'][:]
# vel_lon = vel_fid['lon'][:]
vel_fid.close()
#-- select the points for the calculation of GZ width
#-- in order to generate points, we randomly draw a line from the
#-- mutliline, and then draw a random distance to go along the line to get
#-- a coordinate. We repeat until the specified number of points is reached
#-- first we will the array with the given points in POINTS_FILE, and fill
#-- the rest randomly.
xlist = np.zeros(N)
ylist = np.zeros(N)
gz = np.zeros(N)
date1_list = [None]*N
date2_list = [None]*N
vel_transects = {}
cn_transects = {}
#-- read given points
df_pts = gpd.read_file(POINT_FILE)
#-- reproject to the projection of GL data
df_pts = df_pts.to_crs(df_gl.crs)
N_given = len(df_pts)
print("{0:d} points prescribed out a total of {1:d}".format(N_given,N))
for i in range(N_given):
xx,yy = df_pts['geometry'][i].coords.xy
xlist[i] = float(xx[0])
ylist[i] = float(yy[0])
random.seed(13)
for i in range(N_given,N):
#-- draw a random index for line along multilines
ind_line = random.randrange(0,len(lm))
rand_line = lm[ind_line]
rand_dist = random.uniform(0, rand_line.length)
rand_pt = rand_line.interpolate(rand_dist)
xx,yy = rand_pt.coords.xy
xlist[i] = float(xx[0])
ylist[i] = float(yy[0])
#-- make special polygons that require a different transect length
plong = Polygon([[-1175399.2293594137,-1124281.6845298712],
[-1166026.3695500833,-1132757.1428680948],
[-1194493.9384390623,-1149957.337730963],
[-1198332.822509906,-1146467.4431211061]])
#-- loop through points and calculate GZ
for i,(xi,yi) in enumerate(zip(xlist,ylist)):
if i%100 == 0:
print(i)
#-- A) velocity based approach
#-- get list of distances to get a list of closest points
#- For a given coordinate, get the flow angle and then the intersecting line
ii = np.argmin(np.abs(x - xi))
jj = np.argmin(np.abs(y - yi))
#-- chech if velocity is above required threshold
vel_mag = np.sqrt(vy[jj,ii]**2 + vx[jj,ii]**2)
if vel_mag > vel_thr:
#-- find flow angle
ang = np.arctan(vy[jj,ii]/vx[jj,ii])
#-- Now constuct a line of a given length, centered at the
#-- chosen coordinates, with the angle above
if Point(xi,yi).within(plong):
dx,dy = 25e3*np.cos(ang),25e3*np.sin(ang)
else:
dx,dy = dist*np.cos(ang),dist*np.sin(ang)
vel_transects[i] = LineString([[x[ii]-dx,y[jj]-dy],[x[ii],y[jj]],[x[ii]+dx,y[jj]+dy]])
#-- get intersection length
vel_int = vel_transects[i].intersection(gz_poly)
gz[i] = vel_int.length
#-- get dates
pt0 = vel_int.interpolate(0,normalized=True)
pt1 = vel_int.interpolate(1,normalized=True)
for l in range(len(lines)):
if lines[l].distance(pt1) < 0.2:
date1_list[i] = dates[l]
elif lines[l].distance(pt0) < 0.2:
date2_list[i] = dates[l]
else:
#-- B) retrieve width from QGIS centerline width calculation
#-- first get the closest line to the point
po = Point(xi,yi)
wdist = np.zeros(len(widths))
for wi in range(len(widths)):
wdist[wi] = widths[wi].distance(po)
ind_w = np.argmin(wdist)
cn_transects[i] = widths[ind_w]
#-- get length
gz[i] = cn_transects[i].length
#-- also get the corresponding dates
pt0 = cn_transects[i].interpolate(0,normalized=True)
pt1 = cn_transects[i].interpolate(1,normalized=True)
for l in range(len(lines)):
if lines[l].distance(pt1) < 0.2:
date1_list[i] = dates[l]
elif lines[l].distance(pt0) < 0.2:
date2_list[i] = dates[l]
#-- write grounding zone widths to file
outfile = os.path.join(os.path.dirname(GL_FILE),'GZ_widths-hybrid_{0}.csv'.format(region))
outfid = open(outfile,'w')
outfid.write('X (m),Y (m),width (km),date1,date2\n')
for i in range(N):
outfid.write('{0:.6f},{1:.6f},{2:.3f},{3},{4}\n'.\
format(xlist[i],ylist[i],gz[i]/1e3,date1_list[i],date2_list[i]))
outfid.close()
#-- plot a sample of points to check the grounding zones
fig = plt.figure(1,figsize=(10,8))
ax = fig.add_subplot(111)
pp = PolygonPatch(poly,alpha=0.3,fc='lawngreen',ec='lawngreen',zorder=1)
ax.add_patch(pp)
for il in lines:
xs,ys = il.coords.xy
ax.plot(xs,ys,linewidth=0.4,alpha=0.8,color='k',zorder=2)
for i in range(30):
if i < N_given:
ip = copy(i)
if i == 0:
plot_pts = [Point(xlist[ip],ylist[ip])]
else:
plot_pts.append(Point(xlist[ip],ylist[ip]))
else:
ip = random.randrange(0,N)
#-- while distance to any of the previous points is less than 20km,
#-- keep trying new indices (doesn't apply to 1st point)
pt = Point(xlist[ip],ylist[ip])
while (pt.distance(MultiPoint(plot_pts)) < 12e3):
ip = random.randrange(0,N)
pt = Point(xlist[ip],ylist[ip])
#-- now we can ensure the points aren't overlapping
print("minimum distance to previous points: ", pt.distance(MultiPoint(plot_pts)))
plot_pts.append(pt)
#-- Now plot the transect for the given index
if ip in vel_transects.keys():
lx,ly = vel_transects[ip].coords.xy
ax.plot(lx,ly,linewidth=2.0,alpha=1.0,color='red',zorder=3)
elif ip in cn_transects.keys():
lx,ly = cn_transects[ip].coords.xy
ax.plot(lx,ly,linewidth=2.0,alpha=1.0,color='darkorange',zorder=3)
ax.text(xlist[ip]+5e3,ylist[ip]+5e3,'{0:.1f}km'.format(gz[ip]/1e3),color='darkred',\
fontsize=6,fontweight='bold',bbox=dict(facecolor='mistyrose', alpha=0.5))
# ax.scatter(xlist[ip],ylist[ip],s=10,color='darkorchid',zorder=4,alpha=0.5)
ax.plot([],[],color='red',label="Velocity-based Intersect")
ax.plot([],[],color='darkorange',label="Centerline-based Intersect")
ax.get_xaxis().set_ticks([])
ax.get_yaxis().set_ticks([])
ax.set_title("Grounding Zone Width for {0}".format(region))
plt.legend()
plt.tight_layout()
plt.savefig(outfile.replace('.csv','.pdf'),format='PDF')
plt.close(fig)
import sys
fn = sys.argv[1]
path = sys.argv[2]
def Pixel2World ( geoMatrix, i , j ): #import matrix that represents pixels in the input image
ulX = geoMatrix[0]
ulY = geoMatrix[3]
xDist = geoMatrix[1]
yDist = geoMatrix[5]
rtnX = geoMatrix[2]
rtnY = geoMatrix[4]
return(1.0 * i * xDist + ulX, -1.0 * j * xDist + ulY)
ds8 = gdal.Open(path+'8band/'+'8band_'+fn+'.tif') #assign 8-band geoTIFF image to var ds8
ds3 = gdal.Open(path+'3band/'+'3band_'+fn+'.tif') #assign 3-band geoTIFF image to var ds3
geoTrans = ds8.GetGeoTransform()
with open(path + 'vectorData/geoJson/'+fn+'_Geo.geojson','r') as f: #import geoJSON file with building footprint represented as polygon
js = json.load(f)
dist = np.zeros((ds8.RasterXSize, ds8.RasterYSize))
for i in range(ds8.RasterXSize): #for each pixel along x axis of matrix
for j in range(ds8.RasterYSize): #for each pixel along y axis of matrix
point = Point(Pixel2World( geoTrans, i , j )) #point = pixel at (i, j)
pd = -100000.0
for feature in js['features']: #for each annotated feature in the geoJSON file (the buildings that are represented as polygons)
polygon = shape(feature['geometry']) #a polygon is a feature contained in the field 'geometry'
newpd = point.distance(polygon.boundary) #newpd = the distance of the point (pixel) from the polygon
if False == polygon.contains(point): #if the building polygon does not contain the pixel
newpd = -1.0 * newpd #pixel is an exterior pixel and has a negative distance
if newpd > pd : #if the distance of the point from the polygon is greater than pd
pd = newpd #set pd to the distance of the point from the polygon
dist[i,j] = pd
np.save(path+'CosmiQ_distance/'+fn+'.distance',dist)
def cut_line_features_at_points(self, geometry, ratio=0.5, points=None):
"""
cut_line_features_at_points
:type geometry: shapely.geometry.*
:type ratio: float, default: 0.5
:type points: [shapely.geometry.Point], default None
:return: [shapely.geometry.LineString]
"""
self.__assert_all_geometry_type(geometry)
new_geometries = []
if isinstance(geometry, (LineString, LinearRing)):
new_geometries = list(geometry.coords)
if ratio is not None:
points_coords = [
geometry.interpolate(ratio, normalized=True).xy
]
new_geometries[1:1] = points_coords
elif points is not None:
start_point = Point(new_geometries[0])
points_on_line_mapping = {
point.coords[0]: start_point.distance(point)
for point in points if start_point.distance(point) > 0
and start_point.distance(point) < geometry.length
and geometry.envelope.intersects(point.envelope)
}
if len(points_on_line_mapping) > 0:
points_on_line_mapping_sorted = OrderedDict(
sorted(points_on_line_mapping.items(),
key=lambda x: x[1]))
points_coords = [
point for point in points_on_line_mapping_sorted
]
new_geometries[1:1] = points_coords
new_geometries = [
LineString(pair) for pair in zip(
new_geometries[:-1], new_geometries[1:])
]
else:
new_geometries = [geometry]
elif isinstance(geometry, MultiLineString):
geometries = geometry.geoms
for geometry in geometries:
lines = list(
self.cut_line_features_at_points(geometry, ratio,
points).geoms)
new_geometries.extend(lines)
elif isinstance(geometry, (Point, MultiPoint)):
new_geometries = None
else:
geom_lines = self.convert_geometry_to_simple_linestrings(
geometry).geoms
for geom in geom_lines:
lines = self.cut_line_features_at_points(geom, ratio,
points).geoms
new_geometries.extend(lines)
return MultiLineString(new_geometries)
