def near_xy(self, **kwargs):
"""
TODO: Implement ncell near_xy
"""
point = kwargs.get("point", None)
if point == None:
lat = kwargs.get("lat", None)
lon = kwargs.get("lon", None)
point = Location4D(latitude=lat, longitude=lon)
num = kwargs.get("num", 1)
ncell = kwargs.get("ncell", False)
if ncell:
if num > 1:
pass
else:
distance = AsaGreatCircle.great_distance(
start_lats=self._yarray,
start_lons=self._xarray,
end_lats=point.latitude,
end_lons=point.longitude)["distance"]
inds = np.where(distance == np.nanmin(distance))
xinds, yinds = inds, inds
else:
if self._ndim == 2:
distance = AsaGreatCircle.great_distance(
start_lats=self._yarray,
start_lons=self._xarray,
end_lats=point.latitude,
end_lons=point.longitude)["distance"]
yinds, xinds = np.where(distance == np.nanmin(distance))
else:
#if self._xmesh == None and self._ymesh == None:
# self._xmesh, self._ymesh = np.meshgrid(self._xarray, self._yarray)
if num > 1:
minlat = np.abs(self._yarray - point.latitude)
minlon = np.abs(self._xarray - point.longitude)
lat_cutoff = np.sort(minlat)[num - 1]
lon_cutoff = np.sort(minlon)[num - 1]
elif num == 1:
lat_cutoff = np.nanmin(
np.abs(self._yarray - point.latitude))
lon_cutoff = np.nanmin(
np.abs(self._xarray - point.longitude))
yinds = np.where(
np.abs(self._yarray - point.latitude) <= lat_cutoff)
xinds = np.where(
np.abs(self._xarray - point.longitude) <= lon_cutoff)
return yinds, xinds
def test_reverse_10_times_then_start_point(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting, end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point, end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react( start_point = starting,
hit_point = int4d,
end_point = ending,
feature = intersection['feature'],
distance = distance,
angle = angle,
azimuth = difference['azimuth'],
reverse_azimuth = difference['reverse_azimuth'],
reverse_distance = 9999999999999999999999999999)
# Should be start location
assert final_point.longitude == starting.longitude
assert final_point.latitude == starting.latitude
assert final_point.depth == starting.depth
def test_reverse_distance_traveled(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting, end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point, end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react( start_point = starting,
hit_point = int4d,
end_point = ending,
feature = intersection['feature'],
distance = distance,
angle = angle,
azimuth = difference['azimuth'],
reverse_azimuth = difference['reverse_azimuth'],
reverse_distance = 0.000001)
# Resulting point should be VERY close to the hit point.
assert abs(int4d.latitude - final_point.latitude) < 0.005
assert abs(int4d.longitude - final_point.longitude) < 0.005
def test_reverse_up_left(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting, end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point, end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react( start_point = starting,
hit_point = int4d,
end_point = ending,
feature = intersection['feature'],
distance = distance,
angle = angle,
azimuth = difference['azimuth'],
reverse_azimuth = difference['reverse_azimuth'])
# Resulting latitude should be between the startpoint and the intersection point
assert final_point.latitude > int4d.latitude
assert final_point.latitude < starting.latitude
# Resulting longitude should be between the startpoint and the intersection point
assert final_point.longitude < int4d.longitude
assert final_point.longitude > starting.longitude
def test_reverse_half_distance_until_in_water(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting, end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point, end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react( start_point = starting,
hit_point = int4d,
end_point = ending,
feature = intersection['feature'],
distance = distance,
angle = angle,
azimuth = difference['azimuth'],
reverse_azimuth = difference['reverse_azimuth'],
reverse_distance = 40000)
# Should be in water
assert s.intersect(start_point=final_point.point, end_point=final_point.point) is None
def test_reverse_distance_traveled(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting,
end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point,
end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react(start_point=starting,
hit_point=int4d,
end_point=ending,
feature=intersection['feature'],
distance=distance,
angle=angle,
azimuth=difference['azimuth'],
reverse_azimuth=difference['reverse_azimuth'],
reverse_distance=0.000001)
# Resulting point should be VERY close to the hit point.
assert abs(int4d.latitude - final_point.latitude) < 0.005
assert abs(int4d.longitude - final_point.longitude) < 0.005
def test_reverse_left(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.1, longitude=-74.91, depth=0)
ending = Location4D(latitude=39.1, longitude=-74.85, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting, end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point, end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react( start_point = starting,
hit_point = int4d,
end_point = ending,
feature = intersection['feature'],
distance = distance,
angle = angle,
azimuth = difference['azimuth'],
reverse_azimuth = difference['reverse_azimuth'])
# Since we are on a stright horizonal line, the latitude will change only slightly
assert abs(final_point.latitude - starting.latitude) < 0.005
# Resulting longitude should be between the startpoint and the intersection point
assert final_point.longitude < int4d.longitude
assert final_point.longitude > starting.longitude
def test_reverse_12_times_then_start_point(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting,
end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point,
end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react(start_point=starting,
hit_point=int4d,
end_point=ending,
feature=intersection['feature'],
distance=distance,
angle=angle,
azimuth=difference['azimuth'],
reverse_azimuth=difference['reverse_azimuth'],
reverse_distance=9999999999999999999999999999)
# Should be start location
assert final_point.longitude == starting.longitude
assert final_point.latitude == starting.latitude
assert final_point.depth == starting.depth
def test_reverse_half_distance_until_in_water(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting,
end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point,
end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react(start_point=starting,
hit_point=int4d,
end_point=ending,
feature=intersection['feature'],
distance=distance,
angle=angle,
azimuth=difference['azimuth'],
reverse_azimuth=difference['reverse_azimuth'],
reverse_distance=40000)
# Should be in water
assert s.intersect(start_point=final_point.point,
end_point=final_point.point) is None
def test_reverse_up_left(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.05, longitude=-75.34, depth=0)
ending = Location4D(latitude=38.96, longitude=-75.315, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting,
end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point,
end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react(start_point=starting,
hit_point=int4d,
end_point=ending,
feature=intersection['feature'],
distance=distance,
angle=angle,
azimuth=difference['azimuth'],
reverse_azimuth=difference['reverse_azimuth'])
# Resulting latitude should be between the startpoint and the intersection point
assert final_point.latitude > int4d.latitude
assert final_point.latitude < starting.latitude
# Resulting longitude should be between the startpoint and the intersection point
assert final_point.longitude < int4d.longitude
assert final_point.longitude > starting.longitude
def test_reverse_left(self):
s = Shoreline(type='reverse')
starting = Location4D(latitude=39.1, longitude=-74.91, depth=0)
ending = Location4D(latitude=39.1, longitude=-74.85, depth=0)
difference = AsaGreatCircle.great_distance(start_point=starting,
end_point=ending)
angle = AsaMath.azimuth_to_math_angle(azimuth=difference['azimuth'])
distance = difference['distance']
intersection = s.intersect(start_point=starting.point,
end_point=ending.point)
int4d = Location4D(point=intersection['point'])
final_point = s.react(start_point=starting,
hit_point=int4d,
end_point=ending,
feature=intersection['feature'],
distance=distance,
angle=angle,
azimuth=difference['azimuth'],
reverse_azimuth=difference['reverse_azimuth'])
# Since we are on a stright horizonal line, the latitude will change only slightly
assert abs(final_point.latitude - starting.latitude) < 0.005
# Resulting longitude should be between the startpoint and the intersection point
assert final_point.longitude < int4d.longitude
assert final_point.longitude > starting.longitude
def near_xy(self, **kwargs):
"""
TODO: Implement ncell near_xy
"""
point = kwargs.get("point", None)
if point == None:
lat = kwargs.get("lat", None)
lon = kwargs.get("lon", None)
point = Location4D(latitude=lat, longitude=lon)
num = kwargs.get("num", 1)
ncell = kwargs.get("ncell", False)
if ncell:
if num > 1:
pass
else:
distance = AsaGreatCircle.great_distance(
start_lats=self._yarray, start_lons=self._xarray, end_lats=point.latitude, end_lons=point.longitude
)["distance"]
inds = np.where(distance == np.nanmin(distance))
xinds, yinds = inds, inds
else:
if self._ndim == 2:
distance = AsaGreatCircle.great_distance(
start_lats=self._yarray, start_lons=self._xarray, end_lats=point.latitude, end_lons=point.longitude
)["distance"]
yinds, xinds = np.where(distance == np.nanmin(distance))
else:
# if self._xmesh == None and self._ymesh == None:
# self._xmesh, self._ymesh = np.meshgrid(self._xarray, self._yarray)
if num > 1:
minlat = np.abs(self._yarray - point.latitude)
minlon = np.abs(self._xarray - point.longitude)
lat_cutoff = np.sort(minlat)[num - 1]
lon_cutoff = np.sort(minlon)[num - 1]
elif num == 1:
lat_cutoff = np.nanmin(np.abs(self._yarray - point.latitude))
lon_cutoff = np.nanmin(np.abs(self._xarray - point.longitude))
yinds = np.where(np.abs(self._yarray - point.latitude) <= lat_cutoff)
xinds = np.where(np.abs(self._xarray - point.longitude) <= lon_cutoff)
return yinds, xinds
def __bounce(self, **kwargs):
"""
Bounce off of the shoreline.
NOTE: This does not work, but left here for future implementation
feature = Linestring of two points, being the line segment the particle hit.
angle = decimal degrees from 0 (x-axis), couter-clockwise (math style)
"""
start_point = kwargs.pop('start_point')
hit_point = kwargs.pop('hit_point')
end_point = kwargs.pop('end_point')
feature = kwargs.pop('feature')
distance = kwargs.pop('distance')
angle = kwargs.pop('angle')
# Figure out the angle of the shoreline here (beta)
points_in_shore = map(lambda x: Point(x), list(feature.coords))
points_in_shore = sorted(points_in_shore, key=lambda x: x.x)
# The point on the left (least longitude is always the first Point)
first_shore = points_in_shore[0]
last_shore = points_in_shore[-1]
shoreline_x = abs(abs(first_shore.x) - abs(last_shore.x))
shoreline_y = abs(abs(first_shore.y) - abs(last_shore.y))
beta = math.degrees(math.atan(shoreline_x / shoreline_y))
theta = 90 - angle - beta
bounce_azimuth = AsaMath.math_angle_to_azimuth(angle=2 * theta + angle)
print "Beta: " + str(beta)
print "Incoming Angle: " + str(angle)
print "ShorelineAngle: " + str(theta + angle)
print "Bounce Azimuth: " + str(bounce_azimuth)
print "Bounce Angle: " + str(
AsaMath.azimuth_to_math_angle(azimuth=bounce_azimuth))
after_distance = distance - AsaGreatCircle.great_distance(
start_point=start_point, end_point=hit_point)['distance']
new_point = AsaGreatCircle.great_circle(distance=after_distance,
azimuth=bounce_azimuth,
start_point=hit_point)
return Location4D(latitude=new_point['latitude'],
longitude=new_point['longitude'],
depth=start_point.depth)
def __bounce(self, **kwargs):
"""
Bounce off of the shoreline.
NOTE: This does not work, but left here for future implementation
feature = Linestring of two points, being the line segment the particle hit.
angle = decimal degrees from 0 (x-axis), couter-clockwise (math style)
"""
start_point = kwargs.pop("start_point")
hit_point = kwargs.pop("hit_point")
end_point = kwargs.pop("end_point")
feature = kwargs.pop("feature")
distance = kwargs.pop("distance")
angle = kwargs.pop("angle")
# Figure out the angle of the shoreline here (beta)
points_in_shore = map(lambda x: Point(x), list(feature.coords))
points_in_shore = sorted(points_in_shore, key=lambda x: x.x)
# The point on the left (least longitude is always the first Point)
first_shore = points_in_shore[0]
last_shore = points_in_shore[-1]
shoreline_x = abs(abs(first_shore.x) - abs(last_shore.x))
shoreline_y = abs(abs(first_shore.y) - abs(last_shore.y))
beta = math.degrees(math.atan(shoreline_x / shoreline_y))
theta = 90 - angle - beta
bounce_azimuth = AsaMath.math_angle_to_azimuth(angle=2 * theta + angle)
print "Beta: " + str(beta)
print "Incoming Angle: " + str(angle)
print "ShorelineAngle: " + str(theta + angle)
print "Bounce Azimuth: " + str(bounce_azimuth)
print "Bounce Angle: " + str(AsaMath.azimuth_to_math_angle(azimuth=bounce_azimuth))
after_distance = (
distance - AsaGreatCircle.great_distance(start_point=start_point, end_point=hit_point)["distance"]
)
new_point = AsaGreatCircle.great_circle(distance=after_distance, azimuth=bounce_azimuth, start_point=hit_point)
return Location4D(latitude=new_point["latitude"], longitude=new_point["longitude"], depth=start_point.depth)
