def test_utm_latlon_conversion(self):
"check utm to latlon conversion of Dry Creek actually maps there"
# bbox corners from upper left clockwise around
east0 = 569029.6
east1 = 569452.1
north0 = 4842544.9
north1 = 4842177.4
utm_zone = 11
utm_letter = 'T'
latlons = utm2latlon(bsamp=east0, bline=north0, dsamp=east1-east0,
dline=north1-north0, nsamp=2, nline=2,
utm_zone=utm_zone, utm_letter=utm_letter)
from utm import to_latlon
ll0 = to_latlon(east0, north0, utm_zone, utm_letter)
ll1 = to_latlon(east1, north0, utm_zone, utm_letter)
ll2 = to_latlon(east1, north1, utm_zone, utm_letter)
ll3 = to_latlon(east0, north1, utm_zone, utm_letter)
assert (ll0 == latlons[0]).all
assert (ll1 == latlons[1]).all
assert (ll2 == latlons[2]).all
assert (ll3 == latlons[3]).all
def distance(UTM_ini, UTM_fin):
"""
distance returns the calculated distance (in kms) between two points
defined in the UTM coordinate system
"""
UTM_ini_x = UTM_ini[0]
UTM_ini_y = UTM_ini[1]
UTM_ini_zone = UTM_ini[2]
UTM_fin_x = UTM_fin[0]
UTM_fin_y = UTM_fin[1]
UTM_fin_zone = UTM_fin[2]
[LAT_INI, LONG_INI] = utm.to_latlon(
UTM_ini_x, UTM_ini_y, int(UTM_ini_zone[0:2]), str(UTM_ini_zone[3])
) # to get dd.dd from utm
[LAT_FIN, LONG_FIN] = utm.to_latlon(
UTM_fin_x, UTM_fin_y, int(UTM_fin_zone[0:2]), str(UTM_fin_zone[3])
) # to get dd.dd from utm
point_i = (LAT_INI, LONG_INI)
point_f = (LAT_FIN, LONG_FIN)
distance = great_circle(
point_i, point_f
).kilometers # gives you a distance (in kms) between two coordinate in dd.dd
return distance
def get_LOS_vector(self, locations):
"""
calculate beta - the angle at earth center between reference point
and satellite nadir
"""
utmZone = self.location_UTM_zone
refPoint = vmath.Vector3(self.ref[0], self.ref[1], 0)
satAltitude = self.satellite_altitude
satAzimuth = self.satellite_azimuth
satIncidence = self.ref_incidence
earthRadius = self.local_earth_radius
DEG2RAD = np.pi / 180.
alpha = satIncidence * DEG2RAD
beta = (earthRadius / (satAltitude + earthRadius)) * np.sin(alpha)
beta = alpha - np.arcsin(beta)
beta = beta / DEG2RAD
# calculate angular separation of (x,y) from satellite track passing
# through (origx, origy) with azimuth satAzimuth
# Long lat **NOT** lat long
origy, origx = utm.to_latlon(
refPoint.x, refPoint.y, np.abs(utmZone), northern=utmZone > 0
)
xy = np.array([
utm.to_latlon(u[0], u[1], np.abs(utmZone), northern=utmZone > 0)
for u in locations
])
y = xy[:, 0]
x = xy[:, 1]
angdist = self._ang_to_gc(x, y, origx, origy, satAzimuth)
# calculate beta2, the angle at earth center between roaming point and
# satellite nadir track, assuming right-looking satellite
beta2 = beta - angdist
beta2 = beta2 * DEG2RAD
# calculate alpha2, the new incidence angle
alpha2 = np.sin(beta2) / (
np.cos(beta2) - (earthRadius / (earthRadius + satAltitude))
)
alpha2 = np.arctan(alpha2)
alpha2 = alpha2 / DEG2RAD
# calculate pointing vector
satIncidence = 90 - alpha2
satAzimuth = 360 - satAzimuth
los_x = -np.cos(satAzimuth * DEG2RAD) * np.cos(satIncidence * DEG2RAD)
los_y = -np.sin(satAzimuth * DEG2RAD) * np.cos(satIncidence * DEG2RAD)
los_z = np.sin(satIncidence * DEG2RAD)
return vmath.Vector3(los_x, los_y, los_z)
def export_kml(self, name, tx_id):
# TODO I've changed some stuff ... make sure this output is still sensible.
# E.g.: https://developers.google.com/kml/documentation/kmlreference#gxtrack
# TODO The file is way longer than it needs to be, since I wanted to display
# the coordinates and datetime in the tooltip that appears in Google Earth.
# Perhaps what we want is not a gx:track, but something fucnctionally
# similar.
# TODO Add northing, easting to output.
try:
import utm
except ImportError:
print "function export_kml() requires \"utm\" library, please install"
raise
fd = open('%s_track.kml' % name, 'w')
fd.write('<?xml version="1.0" encoding="UTF-8"?>\n')
fd.write('<kml xmlns="http://www.opengis.net/kml/2.2"\n')
fd.write(' xmlns:gx="http://www.google.com/kml/ext/2.2">\n')
fd.write('<Folder>\n')
fd.write(' <Placemark>\n')
fd.write(' <name>%s (deploymentID=%d)</name>\n' % (name, tx_id))
fd.write(' <gx:Track>\n')
for (pos_id, dep_id, t, easting, northing, utm_number, utm_letter, ll, activity) in self.table:
tm = time.gmtime(t)
t = '%04d-%02d-%02dT%02d:%02d:%02dZ' % (tm.tm_year, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec)
fd.write(' <when>%s</when>\n' % t)
for (pos_id, dep_id, t, easting, northing, utm_number, utm_letter, ll, activity) in self.table:
(lat, lon) = utm.to_latlon(easting, northing, utm_number, utm_letter)
fd.write(' <gx:coord>%f %f 0</gx:coord>\n' % (lon, lat))
fd.write(' <ExtendedData>\n')
fd.write(' <SchemaData schemaUrl="#schema">\n')
fd.write(' <gx:SimpleArrayData name="Time">\n')
for (pos_id, dep_id, t, easting, northing, utm_number, utm_letter, ll, activity) in self.table:
tm = time.gmtime(t)
t = '%04d-%02d-%02d %02d:%02d:%02d' % (tm.tm_year, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec)
fd.write(' <gx:value>%s</gx:value>\n' % t)
fd.write(' </gx:SimpleArrayData>\n')
fd.write(' <gx:SimpleArrayData name="(lat, long)">\n')
for (pos_id, dep_id, t, easting, northing, utm_number, utm_letter, ll, activity) in self.table:
(lat, lon) = utm.to_latlon(easting, northing, utm_number, utm_letter)
fd.write(' <gx:value>%fN, %fW</gx:value>\n' % (lat, lon))
fd.write(' </gx:SimpleArrayData>\n')
fd.write(' <gx:SimpleArrayData name="positionID">\n')
for (pos_id, dep_id, t, easting, northing, utm_number, utm_letter, ll, activity) in self.table:
tm = time.gmtime(t)
t = '%04d-%02d-%02d %02d:%02d:%02d' % (tm.tm_year, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec)
fd.write(' <gx:value>%d</gx:value>\n' % pos_id)
fd.write(' </gx:SimpleArrayData>\n')
fd.write(' </SchemaData>\n')
fd.write(' </ExtendedData>\n')
fd.write(' </gx:Track>\n')
fd.write(' </Placemark>\n')
fd.write('</Folder>\n')
fd.write('</kml>')
fd.close()
def to_gps(x = 0.0, y = 0.0):
#print x, y, type(x), type(y)
if x < 400000:
lat, lon = utm.to_latlon(x, y, 51,'R')
return lon, lat
elif x > 400000:
lat, lon = utm.to_latlon(x, y, 16,'T')
return lon, lat
def test_to_latlon(self):
'''to_latlon should give known result with known input'''
for latlon, utm, utm_kw in self.known_values:
result = UTM.to_latlon(*utm)
self.assert_latlon_equal(latlon, result)
result = UTM.to_latlon(*utm[0:3], **utm_kw)
self.assert_latlon_equal(latlon, result)
def test_to_latlon_range_checks(self):
'''to_latlon should fail with out-of-bounds input'''
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 0, 5000000, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 99999, 5000000, 32, 'U')
for i in range(100000, 999999, 1000):
UTM.to_latlon(i, 5000000, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 1000000, 5000000, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 100000000000, 5000000, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, -100000, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, -1, 32, 'U')
for i in range(10, 10000000, 1000):
UTM.to_latlon(500000, i, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 10000001, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 50000000, 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 0, 'U')
for i in range(1, 60):
UTM.to_latlon(500000, 5000000, i, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 61, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 1000, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 32, 'A')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 32, 'B')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 32, 'I')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 32, 'O')
for i in range(ord('C'), ord('X')):
i = chr(i)
if i != 'I' and i != 'O':
UTM.to_latlon(500000, 5000000, 32, i)
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 32, 'Y')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, 500000, 5000000, 32, 'Z')
def rectilinear(self, nx, ny):
"""
function that generates a rectilinear grid
"""
#### Step 1) define a regular grid ####
#NW = (29.017842, -95.174746)
NW = (29.036487, -95.131658)
#NE = (29.459124, -94.413252)
NE = (29.439981, -94.465266)
#SW = (28.777523, -94.979306)
SW = (28.807300, -95.005893)
#### Calculate the length in x- and y- direction ####
Lx = self.distance_on_unit_sphere(NW[0], NW[1], NE[0], NE[1])
Ly = self.distance_on_unit_sphere(NW[0], NW[1], SW[0], SW[1])
new_NW = utm.from_latlon(NW[0], NW[1])[0:2]
#new_SW = (new_NW[0]-Ly, new_NW[1])
#new_NE = (new_NW[0], new_NW[1]+Lx)
y = np.linspace(new_NW[1]-Ly, new_NW[1], ny)
x = np.linspace(new_NW[0], new_NW[0]+Lx, nx)
xv, yv = np.meshgrid(x, y)
#origin = (xv[0,-1], yv[0,-1])
origin = new_NW
tem_xv = xv - origin[0]
tem_yv = yv - origin[1]
#### Step 2) rotate the grid from an angle ####
def rotate(yv, xv, theta):
"""Rotates the given polygon which consists of corners represented as (x,y),
around the ORIGIN, clock-wise, theta degrees"""
theta = math.radians(theta)
out_yv = np.zeros_like(yv)
out_xv = np.zeros_like(xv)
(nx, ny) = xv.shape
for i in range(nx):
for j in range(ny):
out_yv[i,j] = yv[i,j]*math.cos(theta)-xv[i,j]*math.sin(theta)
out_xv[i,j] = yv[i,j]*math.sin(theta)+xv[i,j]*math.cos(theta)
return out_yv, out_xv
tem_yv, tem_xv = rotate(tem_yv, tem_xv, -35)
new_xv = tem_xv + origin[0] #lon
new_yv = tem_yv + origin[1] #lat
lon = np.zeros_like(new_xv)
lat = np.zeros_like(new_yv)
#pdb.set_trace()
for i in range(ny):
for j in range(nx):
(lat[i,j], lon[i,j]) = utm.to_latlon(new_xv[i,j], new_yv[i,j],15,'U')[0:2]
dx = Lx / nx
dy = Ly / ny
return lon, lat, dx, dy
def utm_to_latlong(input_data_file=None, output_data_file=None, log_file=None, log_level=DEFAULT_LOG_LEVEL):
"""Converts UTM coordinates into latitude/longitude.
assumes rows are easting, northing, zone number, either 'N' for northern
hemisphere or 'S' for southern hemisphere
"""
logger = logger_message(__name__, log_file, log_level)
# Check required input and output data file names were given.
assert input_data_file is not None, 'An input CSV file with columns of values.'
assert output_data_file is not None, 'An output CSV file to write new values.'
_in = open(input_data_file, 'r')
try:
_out = open(output_data_file, 'w')
try:
data = csv.reader(_in)
output = csv.writer(_out)
for row_ind, row in enumerate(data):
east = float(row[0])
north = float(row[1])
zone = int(row[2])
latlong = utm.to_latlon(east, north, zone, northern=('N' == row[3]))
logger.info('Changed row {} from: {} to: {}'.format(row_ind,
(row[0], row[1]), latlong))
output.writerow(latlong)
finally:
_out.close()
finally:
_in.close()
def insert_db(self, db_con, dep_id, bearing_ids, zone):
''' Insert position and bearings into the database.
Inputs:
db_con, dep_id, zone
bearing_ids -- bearingIDs (serial identifiers in the database) of the bearings
corresponding to bearing data. These are used for provenance
in the database.
'''
if self.p is None:
return None
number, letter = zone
lat, lon = utm.to_latlon(self.p.imag, self.p.real, number, letter)
cur = db_con.cursor()
cur.execute('''INSERT INTO position
(deploymentID, timestamp, latitude, longitude, easting, northing,
utm_zone_number, utm_zone_letter, likelihood,
activity, number_est_used)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)''',
(dep_id, self.t, round(lat,6), round(lon,6),
self.p.imag, self.p.real, number, letter,
self.likelihood, self.activity,
self.num_est))
pos_id = cur.lastrowid
handle_provenance_insertion(cur, {'bearing': tuple(bearing_ids)},
{'position' : (pos_id,)})
return pos_id
def get_data(path='data/Historical Marker_20150521_145030_254.csv'):
with open(path, 'r') as fp:
reader = csv.DictReader(fp)
for row in reader:
text = row['markertext']
years = find_years(text)
row['address'] = row['address'].strip()
# add our own data
row['years'] = years
row['classifications'] = Classifier(years, text=text).classify()
try:
lat, lon = utm.to_latlon(
int(row['utm_east']),
int(row['utm_north']),
int(row['utm_zone']),
northern=True,
)
row['location'] = {
"lat": lat,
"lon": lon,
}
except ValueError:
# log warn missing
pass
yield row
def sync_gis():
request_cookie = requests.get(app.config['GIS_URL_COOKIE'])
request_data = requests.get(app.config['GIS_URL_DATA'], cookies=request_cookie.cookies)
data = request_data.json()['features']
for dataset in data:
if Tree.query.filter_by(external_id=dataset['attributes']['OBJECTID']).count() == 0:
print "Add new Dataset with external ID %s" % dataset['attributes']['OBJECTID']
new_tree = Tree()
new_tree.external_id = dataset['attributes']['OBJECTID']
lat_lng = utm.to_latlon(dataset['geometry']['x'], dataset['geometry']['y'], 32, 'U')
new_tree.lat = lat_lng[0]
new_tree.lng = lat_lng[1]
if len(dataset['attributes']['ADRESSE'].strip()):
new_tree.address = dataset['attributes']['ADRESSE']
if len(dataset['attributes'][u'GEH\xf6lZFL\xe4c'].strip()):
new_tree.tree_type_old = dataset['attributes'][u'GEH\xf6lZFL\xe4c']
if len(dataset['attributes'][u'F\xe4lLGRUND'].strip()):
new_tree.chop_reason = dataset['attributes'][u'F\xe4lLGRUND']
descr = ''
if len(dataset['attributes'][u'F\xe4lLUNG'].strip()):
descr += u'Zeitpunkt der Fällung: ' + dataset['attributes'][u'F\xe4lLUNG'].strip()
new_tree.descr = descr
new_tree.created_at = datetime.datetime.now()
new_tree.updated_at = datetime.datetime.now()
new_tree.author = 'Stadt Bochum'
new_tree.email = '*****@*****.**'
new_tree.city = 'Bochum'
new_tree.public = 1
new_tree.postalcode = ''
new_tree.type = 4
new_tree.source = 'Stadt Bochum'
db.session.add(new_tree)
db.session.commit()
def local_to_global(origin, x, y, theta=0.0):
"""
Converts from a local frame in meters into a global frame in lon/lat.
Note that heading is in degrees!
@param origin (lon, lat, heading)
@param point shapely.geometry.Point() in local frame
@return (longitude, latitude, heading) in WGS84
"""
# Create local transformation frame.
import utm
ox, oy, zone, hemi = utm.from_latlon(origin[1], origin[0])
o_theta = (90 - origin[2]) * (math.pi/180.0)
# Translate and rotate point to origin.
point = shapely.geometry.Point(x, y)
point = shapely.affinity.rotate(point, o_theta,
origin=ORIGIN, use_radians=True)
point = shapely.affinity.translate(point, ox, oy)
p_theta = theta + o_theta
heading = 90 - (p_theta * 180.0/math.pi)
# Return transformed point.
lat, lon = utm.to_latlon(point.x, point.y, zone, hemi)
return lon, lat, heading
def export_kml(self, name, dep_id):
fd = open('%s_pos.kml' % name, 'w')
fd.write('<?xml version="1.0" encoding="UTF-8"?>\n')
fd.write('<kml xmlns="http://www.opengis.net/kml/2.2"\n')
fd.write(' xmlns:gx="http://www.google.com/kml/ext/2.2">\n')
fd.write('<Folder>\n')
fd.write(' <Placemark>\n')
fd.write(' <MultiGeometry>\n')
fd.write(' <name>%s (deploymentID=%d) position cloud</name>\n' % (name, dep_id))
for row in self.table:
(P, t, ll, pos_id) = (np.complex(row[0], row[1]),
float(row[2]),
float(row[3]),
int(row[4]))
tm = time.gmtime(t)
t = '%04d-%02d-%02d %02d:%02d:%02d' % (tm.tm_year, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec)
(lat, lon) = utm.to_latlon(P.imag, P.real, self.zone, self.letter)
fd.write(' <Point id="%d">\n' % pos_id)
fd.write(' <coordinates>%f,%f,0</coordinates>\n' % (lon, lat))
fd.write(' </Point>\n')
fd.write(' </MultiGeometry>\n')
fd.write(' </Placemark>\n')
fd.write('</Folder>\n')
fd.write('</kml>')
fd.close()
def ChangeXYView(request):
if request.method == "POST":
form = ChangeXYForm(request.POST)
if form.is_valid():
obs = Occurrence.objects.get(pk=request.POST["DB_id"])
coordinates = utm.to_latlon(int(request.POST["new_easting"]), int(request.POST["new_northing"]), 37, "N")
pnt = GEOSGeometry("POINT (" + str(coordinates[1]) + " " + str(coordinates[0]) + ")", 4326) # WKT
obs.geom = pnt
obs.save()
messages.add_message(request, messages.INFO, 'Successfully Updated Coordinates For %s.' % obs.catalog_number)
return redirect("/admin/mlp/occurrence")
else:
selected = list(request.GET.get("ids", "").split(","))
if len(selected) > 1:
messages.error(request, "You can't change the coordinates of multiple points at once.")
return redirect("/admin/mlp/occurrence")
selected_object = Occurrence.objects.get(pk=int(selected[0]))
initial_data = {"DB_id": selected_object.id,
"barcode": selected_object.barcode,
"old_easting": selected_object.easting,
"old_northing": selected_object.northing,
"item_scientific_name": selected_object.item_scientific_name,
"item_description": selected_object.item_description
}
the_form = ChangeXYForm(initial=initial_data)
return render_to_response('projects/changeXY.html', {"theForm": the_form}, RequestContext(request))
def ProcessLocalization(self, msg):
"""Process Localization, stat mileages and save driving path."""
localization = LocalizationEstimate()
localization.ParseFromString(msg)
timestamp = localization.header.timestamp_sec
cur_pos = localization.pose.position
# Stat mileages.
if (self._last_position is not None and
self._current_driving_mode is not None):
driving_mode = Chassis.DrivingMode.Name(self._current_driving_mode)
meters = utm_distance_meters(self._last_position, cur_pos)
if driving_mode in self.record.stat.mileages:
self.record.stat.mileages[driving_mode] += meters
else:
self.record.stat.mileages[driving_mode] = meters
# Sample driving path.
G = gflags.FLAGS
if (self._last_position_sampled is None or
(timestamp - self._last_position_sampled_time >
G.pos_sample_min_duration and
utm_distance_meters(self._last_position_sampled, cur_pos) >
G.pos_sample_min_distance)):
self._last_position_sampled = cur_pos
self._last_position_sampled_time = timestamp
lat, lon = utm.to_latlon(cur_pos.x, cur_pos.y,
G.utm_zone_id, G.utm_zone_letter)
self.record.stat.driving_path.add(lat=lat, lon=lon)
# Update position.
self._last_position = cur_pos
def start_simulator_spin():
rospy.init_node("Controller_Tester", anonymous=True)
simulator_pub = rospy.Publisher('Pose', Pose, queue_size=10)
c_tester = ControllerTester()
command_listener = rospy.Subscriber("Command", Command, c_tester.command_callback)
#initialize()
while not rospy.is_shutdown():
#apply the model
#use np.dot(a, b) for matrix product of two 2d-lists a and b
#print(model)
c_tester.x = np.dot(c_tester.model, c_tester.x)
#publish a new pose message using simulator_pub
simulated_pose = Pose()
#lat_long is a 2-tuple
#for syntax of the utm package see python package index
#The syntax is utm.to_latlon(EASTING, NORTHING, ZONE NUMBER, ZONE LETTER).
#The return has the form (LATITUDE, LONGITUDE).
lat_long = utm.to_latlon(c_tester.x[0][0], c_tester.x[1][0], c_tester.utm_zone_number, c_tester.utm_zone_letter)
simulated_pose.latitude_deg = lat_long[0]
simulated_pose.longitude_deg = lat_long[1]
simulated_pose.heading_rad = c_tester.x[3][0]
simulator_pub.publish(simulated_pose)
c_tester.updateModel(c_tester.x)
#rospy.spin()
c_tester.rate.sleep()
def derive_taz_attributes(cur, list_taz):
description_taz=[]
for taz_id in list_taz:
s='select ST_AsText(ST_Centroid(TAZ.geom)) from taz_boundary_scag_2009 TAZ where TAZ.gid = '+str(taz_id)+';'
cur.execute(s)
rows=cur.fetchall()
for row in rows:
pos_centroid_UTM = (str(row[0]))
pos_centroid_UTM = pos_centroid_UTM[6:len(pos_centroid_UTM)-1]
pos_centroid_UTM = pos_centroid_UTM.split()
pos_centroid_UTM = map(float, pos_centroid_UTM)
lat_centroid, lng_centroid = utm.to_latlon(pos_centroid_UTM[0], pos_centroid_UTM[1] , 11, 'N') #The shapefiles are in the UTM "11N" coordinates
if is_in_LA_Box(lat_centroid, lng_centroid):
s='select count(*) from taz_boundary_scag_2009 TAZ, la_network_nodes_v2 nodes where TAZ.gid = '+str(taz_id)+' AND ST_Contains(TAZ.geom, nodes.geom);'
cur.execute(s)
rows=cur.fetchall()
for row in rows:
nb_nodes_in_taz = int(str(row[0]))
s='select TAZ.area_ from taz_boundary_scag_2009 TAZ where TAZ.gid = '+str(taz_id)+';'
cur.execute(s)
rows=cur.fetchall()
for row in rows:
area_taz = float(str(row[0]))
description_taz.append([taz_id, lat_centroid, lng_centroid, nb_nodes_in_taz, area_taz])
return description_taz
def calc_list( l_points, EP, func_fretch ):
if not calc_list_precheck(l_points, func_fretch):
return None
pr, level = calc_list_core(l_points, EP, func_fretch)
if pr:
latitude, longitude = utm.to_latlon(pr.x, pr.y, pr.zone, pr.mark)
return latitude, longitude, pr.r, level
return None
def eval(self, values, X):
if self.tnci_time != self.t:
self.tnci.set_time(self.t)
self.tnci_time = self.t
latlon = utm.to_latlon(X[0], X[1], utm_zone, utm_band)
# OTPS has lon, lat coordinates!
values[0] = self.tnci.get_val((latlon[1], latlon[0]), allow_extrapolation=True)
def test_to_latlon_numpy(self):
if not use_numpy:
return
result = UTM.to_latlon(np.array([166021.44317933032,
277707.83075574087,
544268.12794623]),
np.array([0.0,
331796.29167519242,
663220.7198366751]),
31, northern=True)
self.assert_latlon_equal((np.array([0.0, 3.0, 6.0]),
np.array([0.0, 1.0, 3.4])),
result)
for latlon, utm, utm_kw in self.known_values:
utm = [np.array([x]) for x in utm[:2]] + list(utm[2:])
result = UTM.to_latlon(*utm)
self.assert_latlon_equal(latlon, result)
def add_node_attribute(G, burr_dict):
for node in G.nodes():
if burr_dict[node][0] > 0 and burr_dict[node][1] >0:
latitude, longitude = utm.to_latlon(burr_dict[node][0], burr_dict[node][1], 11, northern = True)
G.node[node]["Latitude"] = latitude
G.node[node]["Longitude"] = longitude
else: print ("node with missing location"), node
return G
def convert_lon(context):
if context:
utm_e = context.current_parameters.get('coord_utm_e')
utm_n = context.current_parameters.get('coord_utm_n')
utm_zone_n = context.current_parameters.get('coord_utm_zone_n')
utm_zone_letter = context.current_parameters.get('coord_utm_zone_letter')
if utm_e and utm_n:
lat, lon = utm.to_latlon(utm_e, utm_n, utm_zone_n, utm_zone_letter)
return lon
def convert_to_lonlat(self,zone_number,northern=False):
import utm
lon=np.zeros(self.x.size,dtype=self.x.dtype)
lat=np.zeros(self.x.size,dtype=self.x.dtype)
for i in range(self.x.size):
lat[i],lon[i]=utm.to_latlon(self.x[i], self.y[i], zone_number=zone_number, northern=northern)
self.lon=lon
self.lat=lat
def pix_2_latlon(gt, px, py, zone_number, northern):
x = px * gt[1] + gt[0]
y = py * gt[5] + gt[3]
if zone_number is not None:
lat, lon = utm.to_latlon(x, y, zone_number, northern=northern)
else:
lat, lon = y, x
return lon, lat, 0
def coonvert():
for tree in tqdm.tqdm(Tree.query(), total=Tree.query().count()):
utm_e = tree.coord_utm_e
utm_n = tree.coord_utm_n
if utm_e and utm_n:
if 100000 < utm_e < 999999 and utm_n:
lat, lon = utm.to_latlon(utm_e, utm_n, 19, northern=False)
tree.coord_lat = lat
tree.coord_lon = lon
tree.save()
def LatLngConvert(UTMpoints):
import utm
points = []
pt = utm.to_latlon([UTMpoints[1], UTMpoints[0]])
spt = Point(pt[1], pt[0])
points.append(spt)
return points
def set_position(self, true_position):
"""
Set True Position and update LAT, LON, ALT
"""
lat, lon = utm.to_latlon(
self._initial_utm[0] + true_position[0],
self._initial_utm[1] + true_position[1],
self._initial_utm[2],
self._initial_utm[3])
self.set_true_value(numpy.array([lat, lon, true_position[2]]))
def generate_ground_truth_message(self):
(x, y) = (self.x[0], self.x[1])
(lat, lon) = utm.to_latlon(x, y, self.utm_zone, self.utm_letter)
msg = Pose()
msg.latitude_deg = lat
msg.longitude_deg = lon
msg.heading_rad = self.x[3]
return msg
def eval(self, values, X):
global tnci_time
if tnci_time != self.t:
print0("Setting Tidal forcing time to %f " % self.t)
self.tnci.set_time(self.t)
tnci_time = self.t
latlon = utm.to_latlon(X[0], X[1], self.utm_zone, self.utm_band)
# OTPS has lon, lat coordinates!
values[0] = self.tnci.get_val((latlon[1], latlon[0]), allow_extrapolation=True)
mymap = tiff.imread(result_path + map_tif)
bin_mask_array = postprocess_masks(mymat, mymat.shape)
this_slice = result_tif[:-11]
mask_array_to_poly_json(bin_mask_array,
result_path,
this_slice,
reqd_class_label=['Trees', 'Crops', 'Water'])
print("Written Polygons from binary mask into json for {}".format(
result_tif))
print("Completed {} out of {}".format(current_file_count + 1,
total_files_count))
# In[4]:
x1, y1 = 358011.19999999995, 3038709.5999999996
x2, y2 = utm.to_latlon(x1, y1, 17, 'N')
print(x2, y2)
# ## Define functions and path
# In[5]:
result_path = '/home/ekbana/computer_vision/satellite-image/Planet.com/Planet_Data_Sliced/tif/result/'
post_proc_temp_path = result_path + 'Post-Process-Temp/'
result_filenames = os.listdir(result_path)
result_filenames = [
file for file in result_filenames if file[-10:] == 'polys.json'
]
meta_path = '/home/ekbana/computer_vision/satellite-image/Planet.com/Planet-Data/'
def generate_csv(x_resolution, y_resolution, x1, y1, x2, y3, GSD, zone_no,
zone_name, pixel_to_km):
import utm
# print x_resolution, y_resolution, x1, y1, x2, y3, GSD, zone_no, zone_name
centres = mesh(
x_resolution, y_resolution, x1, y1, x2, y3, GSD,
pixel_to_km) # generates a matrix of coordinates for the path
# print centres, 'centres'
line_path = pathline(
centres) # converts the matrix into a 1d list, for the final path
name_int = 0
centre_lat, centre_lon = utm.to_latlon((x1 + x2) / 2, (y1 + y3) / 2,
zone_no, zone_name)
while (1):
try:
temp_file = KMLFile.objects.get(
name=str(name_int)) # Files are named using plain integers
name_int += 1
# print name_int
continue
except:
break
path = os.path.join(settings.MEDIA_ROOT, 'csv',
'csv' + str(name_int) + '.csv')
# print path
proj = Proj(proj='utm', zone=zone_no,
ellps='WGS84') # Proj instance for utm to lat long conversions
elevation_dir = os.path.join(settings.MEDIA_ROOT, 'hgt')
heightmap = SrtmHeightMap(centre_lat, centre_lon, x_resolution,
y_resolution, proj, pixel_to_km, GSD, x1, y1, x2,
y3, elevation_dir)
csvfile = open(str(path), "w+b")
filewriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)
filewriter.writerow(['X', 'Y', 'Elevation'])
tiles = {}
for i in range(0, len(line_path)):
lat, lng = utm.to_latlon((line_path[i]['X']), (line_path[i]['Y']),
zone_no, zone_name)
tile_key = SrtmHeightMap._tileKey(lat, lng)
if not tiles.has_key(tile_key):
try:
tiles[tile_key] = SrtmHeightMap._loadTile(
heightmap.data_dir, lat, lng)
except:
return HttpResponse(
"HGT data does not exist. Please copy %s file in the media/hgt folder."
% (SrtmHeightMap._tileKey(lat, lng)))
# print 'Loaded tile', tile_key
v = tiles[tile_key].getAltitudeFromLatLon(lat, lng)
# print line_path[i]['X'], line_path[i]['Y']
filewriter.writerow(
[str(line_path[i]['X']),
str(line_path[i]['Y']), v]
) # , str(get_elevation(utm.to_latlon((line_path[i]['X']), (line_path[i]['Y']), zone_no, zone_name)))
csvfile.close()
# t = datetime.now()
# print t
dev = get_projection_north_deviation(heightmap.proj, heightmap.lat,
heightmap.lng)
# observer at the centre of the point of interest
gatech = ephem.Observer()
gatech.lon, gatech.lat = '%.2f' % heightmap.lng, '%.2f' % heightmap.lat # pyephem takes input as strings and not float!!!
sun = ephem.Sun()
# print gatech.date, heightmap.lng, heightmap.lat # date by default is UTC which should be used as other calculations are made accordingly
# print gatech.lon, gatech.lat
sun.compute(gatech)
# print("%s %s" % (sun.alt, sun.az))
azimuth = sun.az
altitude = sun.alt
sunpos = {
'azimuth': degree_to_rad(azimuth),
'altitude': degree_to_rad(altitude)
}
sun_x = -sin(sunpos['azimuth'] - dev) * cos(sunpos['altitude'])
sun_y = -cos(sunpos['azimuth'] - dev) * cos(sunpos['altitude'])
sun_z = sin(sunpos['altitude'])
shadowmap = ShadowMap(centre_lat, centre_lon, x_resolution, y_resolution,
heightmap.size_x, heightmap.size_y, heightmap.proj,
pixel_to_km, GSD, x1, y1, x2, y3, sun_x, sun_y,
sun_z, heightmap, 1.5)
render_matrix = shadowmap.render()
# 0 means shadow, 1 means lit
print render_matrix
# print shadowmap.size_y, shadowmap.size_x
#print render_matrix
s = ephem.Sun()
s.compute()
o = ephem.Observer()
o.lat = '%0.2f' % heightmap.lat
o.lon = '%0.2f' % heightmap.lng
# print o.lat, o.lon
# print 'O', o.date
# print render_matrix
render_matrix = rever(render_matrix,
shadowmap) # Single lined path for render_matrix
# print o.next_rising(s), o.previous_setting(s)
next_rising = ephem_to_datetime(o.next_rising(s))
previous_setting = ephem_to_datetime(o.previous_setting(s))
current_time = ephem_to_datetime(o.date)
# print previous_setting, current_time, next_rising
# Check if the path isn't plotted after sunset or before sunrise
if next_rising.day == previous_setting.day: # Sun is set
for i in xrange(0, len(render_matrix)):
render_matrix[i] = 0
kml_file = KMLFile()
kml_file.name = str(name_int)
# f = open(path)
# kml_file.csv_file.save(str(kml_file.name)+'.csv', File(f))
# kml_file.file_path.name = kml_path
kml_file.save()
kml_file.zone_name = zone_name
kml_file.zone_no = zone_no
kml_file.save()
# print len(centres) == len(render_matrix)
generate_kml(path, kml_file, render_matrix)
i = 0
new_path = os.path.join(settings.MEDIA_ROOT, 'csv',
'csv_final' + str(name_int) + '.csv')
with open(path, 'rb') as inp, open(str(new_path), 'wb') as out:
writer = csv.writer(out)
count = 0
for row in csv.reader(inp):
if render_matrix[i] != 0:
writer.writerow(row)
count += 1
if count == 0:
writer.writerow(['X', 'Y', 'Elevation'])
i += 1
f = open(new_path)
kml_file.csv_file.save(str(kml_file.name) + '.csv', File(f))
os.remove(path)
# print heightmap.heights
# print render_matrix
# print len(render_matrix) == shadowmap.size_x * shadowmap.size_y
return kml_file
'<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2" xmlns:kml="http://www.opengis.net/kml/2.2" xmlns:atom="http://www.w3.org/2005/Atom">'
)
file.write('<Document>\n')
row_count = ws.max_row
for i in range(2, row_count - 1):
cP1 = Coordenadas(sheet_ranges['A' + str(i)].value,
sheet_ranges['B' + str(i)].value,
sheet_ranges['C' + str(i)].value,
sheet_ranges['D' + str(i)].value)
print('{0}, {1}, {2}, {3}'.format(cP1.nome, cP1.pX, cP1.pY, cP1.pZ))
file.write('<Placemark>')
file.write('<name>' + cP1.nome + '</name>')
file.write('<Point>')
if (tipoCoord == 1):
zoneNumber = int(input("Digite o numero da zona: "))
zoneLetter = input("Digite a letra da zona: ")
uLatLon = utm.to_latlon(cP1.pX, cP1.pY, zoneNumber, zoneLetter)
file.write('<coordinates> {1}, {0}, {2}'.format(
uLatLon[0], uLatLon[1], cP1.pZ) + '</coordinates>')
else:
file.write(
'<coordinates> {0}, {1}, {2}'.format(cP1.pX, cP1.pY, cP1.pZ) +
'</coordinates>')
file.write('</Point>')
file.write('</Placemark>')
file.write('</Document>\n')
file.write('</kml>')
file.close()
def getUTMs(row):
tup = utm.to_latlon(row.ix[0], row.ix[1], 10, 'U')
return pd.Series(tup[:2])
def pixel_to_latlon(trans, row, col, zone_num, zone_let):
px, py = imagexy2geo(trans, row, col)
lat, lon = utm.to_latlon(px, py, zone_num, zone_let)
return lat, lon
# time = 24 #seconds or min?
# Integrate on the x direction
velocityX = cumtrapz(accelerationX)
# Integrate on the x direction
velocityY = cumtrapz(accelerationY)
# Integrate velocity to get x position
positionX = cumtrapz(velocityX)
# Integrate velocity to get y position
positionY = cumtrapz(velocityY)
# Insert initial position
positionX = np.concatenate([[x0], positionX])
positionY = np.concatenate([[y0], positionY])
# Using cumulative sum instead of for
positionX = np.cumsum(positionX)
positionY = np.cumsum(positionY)
# Gets latitude and longitude of an object in the fluid waste
lat, lon = utm.to_latlon(
positionX[-1], positionY[-1], utmZoneNumber, utmZoneLetter)
print(
'''Final position:
lat: %f
lon: %f
''' % (lat, lon)
)
def extract(self):
msp = self.doc.modelspace()
poles = []
labels = []
# iterate through all drawing entities
for e in msp:
# grab any labels
if e.dxftype() == 'MTEXT':
# process the label text
new_label = {
'type': e.dxftype(),
# remove special characters from pole names and flag for manual check
'text': self.flag_special_label(e.text),
'x': e.dxf.insert[0],
'y': e.dxf.insert[1],
}
# flag duplicate pole names
if labels:
for l in labels:
if new_label['text'] == l['text']:
new_label['text'] = "xxx" + f"{len(labels)}" + new_label['text']
labels.append(new_label)
# grab any poles
if e.dxftype() == 'INSERT':
# print(e.dxftype(), e.dxf.layer, e.dxf.name, e.dxf.insert)
x = e.dxf.insert[0]
y = e.dxf.insert[1]
lat_lon = utm.to_latlon(x, y, 17, "T")
new_pole = {
'type': e.dxftype(),
'text': e.dxf.name,
'x': x,
'y': y,
'lat': lat_lon[0],
'lon': lat_lon[1],
}
poles.append(new_pole)
# find nearest label for each pole
self.poles_labels = []
for n, p in enumerate(poles):
shortest_dist = 10
i = -1
for index, l in enumerate(labels):
dist = self.find_dist(p, l)
if dist < shortest_dist:
i = index
shortest_dist = dist
if i != -1:
new_pair = {
'pole': p,
'label': labels[i]
}
else:
new_pair = {
'pole': p,
'label': {
'text': f"xxx{n}None",
}
}
# poles, their lat/lon and label
self.poles_labels.append(new_pair)
def convert_to_latlon(easting, northing, zone_number, zone_letter):
return utm.to_latlon(easting, northing, zone_number, zone_letter)
def timeseries():
global date
global DATA
global NODE_KEY
with open(file_path, 'r') as f:
print 'PROCESSING: '+str(file_path)
node = 0
for line in f:
line = line.strip().split(' ')
if len(line)==9 or len(line)==4: # NODE
if len(line)==9:
try:
line = [float(i) for i in line]
except Exception, e:
print e
continue
node += 1
lat, lng = utm.to_latlon(line[0], line[1], UTM_ZONE, 'U')
u = line[3]
v = line[4]
speed = round(math.sqrt((u**2)+(v**2)), 3)
direction = round(math.degrees(math.atan2(v, u)), 2)
# NORTH
if direction>0 and direction<=90: # Q1
direction = 90-direction
if direction>90 and direction<=180: # Q4
direction = 450-direction
if direction>-90 and direction<=0: # Q2
direction = 90-direction
if direction>-180 and direction<=-90: # Q3
direction = 90-direction
direction = round(direction, 2)
key = '{}:{}'.format(lng, lat)
day = str(date.timetuple().tm_yday)
mins = '{}'.format(date.hour*60+date.minute)
NODE_KEY[node] = key
DATA[key] = {}
DATA[key][day] = {}
DATA[key][day][mins] = [speed, direction]
elif len(line)==4:
line = [float(i) for i in line]
node += 1
u = line[1]
v = line[2]
speed = round(math.sqrt((u**2)+(v**2)), 3)
direction = round(math.degrees(math.atan2(v, u)), 2)
# NORTH
if direction>0 and direction<=90: # Q1
direction = 90-direction
if direction>90 and direction<=180: # Q4
direction = 450-direction
if direction>-90 and direction<=0: # Q2
direction = 90-direction
if direction>-180 and direction<=-90: # Q3
direction = 90-direction
direction = round(direction, 2)
key = NODE_KEY[node]
day = str(date.timetuple().tm_yday)
mins = '{}'.format(date.hour*60+date.minute)
if day in DATA[key]:
DATA[key][day][mins] = [speed, direction]
else:
DATA[key][day] = {}
DATA[key][day][mins] = [speed, direction]
if node==NODE_COUNT:
node = 0
date += timestep
print 'TIMESTEP: '+str(date)
# mm = np.unravel_index(np.argmin(result), result.shape)
aVol = loc(dst, r, 8, e, [0, dst.shape[0]], [0, dst.shape[1]],
[0, dst.shape[2]])
#aSup= loc
mm = aVol['mPos']
m = aVol['min']
# if aVol['min']<aSup['min']:
# mm=aVol['mPos']
# m=aVol['min']
# else:
# mm = aSup['mPos']
# m = aSup['min']
x = grid[0, mm[0], mm[1], mm[2]]
y = grid[1, mm[0], mm[1], mm[2]]
z = grid[2, mm[0], mm[1], mm[2]]
lat, lon = utm.to_latlon(x, y, 25, 'L')
lat = lat + (np.random.rand() * 2 - 1) / 10000
lon = lon + (np.random.rand() * 2 - 1) / 10000
ttt = UTCDateTime(tt)
#ttt.day=UTCDateTime.now().day
#ttt.month = UTCDateTime.now().month
ev = {
'id': UTCDateTime(ttt).strftime("%Y%m%d%H%M%S"),
'time': UTCDateTime(ttt),
# 'text': 'SWARM ev. mag' + str(pp[5]),
'lat': lat,
'lon': lon,
'dpt': z,
'mag': 1.5, #np.log(np.max(vpp)/0.000001),
'note': 'error ' + str(m)
}
if way_points[index].latitude > 0:
utm_data = utm.from_latlon(way_points[index].latitude,
way_points[index].longitude)
video_kalman.update_estimations(np.array(utm_data[:2]).T)
print(way_points[index])
index += 1
success, image = video.read()
if not success:
print("Error in reading video!", file=sys.stderr)
break
cv.imshow("Good Weather", image)
video_kalman.predict_values()
zone_num, zone_letter = utm_data[2], utm_data[3]
lat, long = utm.to_latlon(video_kalman.predicted_data[0],
video_kalman.predicted_data[1], zone_num,
zone_letter)
nearest_data = geographic_db.retrieve_nearest_point(long, lat)
if nearest_data is not None:
# print(nearest_data["distance"])
if current_image != nearest_data["image_path"]:
current_image = nearest_data["image_path"]
threading.Thread(target=image_load_job,
args=(current_image, )).start()
if near_image is not None:
cv.imshow("Bad Weather", near_image)
cv.waitKey(1)
clock.tick(target_fps)
new_time = time.time()
current_diff = new_time - prev_time
print(f'FPS: {1 / current_diff}')
def parse_html(xml):
soup = BeautifulSoup(xml, "html.parser")
data = {
"lots": [],
"last_updated": soup.find('wfs:featurecollection')["timestamp"][:-1]
}
region = "Hamburg"
forecast = False
for member in soup.find('wfs:featurecollection').find_all('gml:featuremember'):
name = member.find('de.hh.up:name').string
count = 0
try:
count = int(member.find('de.hh.up:stellplaetze_gesamt').string)
except AttributeError:
pass
free = 0
state = "nodata"
situation = member.find('de.hh.up:situation')
if situation and situation.string != "keine Auslastungsdaten":
free = int(member.find('de.hh.up:frei').string)
status = member.find('de.hh.up:status').string
if status == "frei" or status == "besetzt":
state = "open"
else:
state = "closed"
lot_type = member.find('de.hh.up:art').string
if lot_type == "Straßenrand":
lot_type = "Parkplatz"
lot_id = member.find('de.hh.up:id').string
address = ""
try:
address = member.find('de.hh.up:einfahrt').string
except AttributeError:
try:
address = member.find('de.hh.up:strasse').string
try:
address += " " + member.find('de.hh.up:hausnr').string
except (AttributeError, TypeError):
pass
except AttributeError:
pass
coord_member = member.find('gml:pos')
if coord_member:
coord_string = coord_member.string.split()
latlon = utm.to_latlon(float(coord_string[0]), float(coord_string[1]), 32, 'U')
coords = {
"lat": latlon[0],
"lng": latlon[1]
}
else:
coords = None
data['lots'].append({
"coords":coords,
"name":name,
"id": lot_id,
"lot_type": lot_type,
"total":count,
"free":free,
"state":state,
"region":region,
"forecast":forecast,
"address":address
})
return data
def foliumMapGenerator(file_names, field_values, innerCells):
#generates a map based on coords
fullField = fieldShape(file_names.fieldFileName, field_values.bufferGiven)
xmin, ymin, xmax, ymax = fiona.open(file_names.fieldFileName).bounds
x, y = utm.to_latlon((xmax + xmin) / 2, (ymax + ymin) / 2, 12, 'T')
field_map = folium.Map([x, y], zoom_start=15)
#applies field shape and field grid to the map
fieldGrid = gpd.read_file(file_names.fieldFileName + "_grid.shp")
field = gpd.read_file(file_names.fieldFileName)
newshape = gpd.GeoDataFrame()
newshape['geometry'] = None
index = 0
newshape.loc[index, 'geometry'] = transform(project, fullField)
field_map.choropleth(geo_data=newshape.to_json(),
data=None,
columns=['geometry'],
line_opacity=1,
fill_opacity=0,
fill_color="Purple")
newdata = gpd.GeoDataFrame()
newdata['geometry'] = None
index = 0
for items in fieldGrid["geometry"]:
items = transform(project, items)
newdata.loc[index, 'geometry'] = items
index = index + 1
#takes cells and makes them into something that can be applied to folium
for cells in innerCells:
bounds = [cells.ur_x, cells.ur_y, cells.bl_x, cells.bl_y]
shapeOfFeature = Polygon([(cells.bl_x, cells.bl_y),
(cells.ur_x, cells.bl_y),
(cells.ur_x, cells.ur_y),
(cells.bl_x, cells.ur_y)])
shapeOfFeature = transform(project, shapeOfFeature)
bl_x, bl_y, ur_x, ur_y = shapeOfFeature.bounds
bounds = [ur_y, ur_x, bl_y, bl_x]
field_values.nitrogenList.sort()
fill_color = str(color(field_values, cells.nitrogen))
folium.features.RectangleMarker(
bounds=bounds,
popup=
"Protein: %.2f <br> Yield: %.2f <br> Nitrogen: %d <br> Entry: %d" %
(cells.protein, cells.cropYield, cells.nitrogen, cells.entryNum),
color="Black",
fill_color=fill_color,
fill_opacity=1).add_to(field_map)
#popups on field. Probably want to change these
html = """
<p><strong> map of field </strong></p>
"""
iframe = folium.IFrame(html=html, width=200, height=50)
popup = folium.Popup(iframe, max_width=2650)
x, y = utm.to_latlon((xmax + xmin) / 2, (ymax + 25), 12, 'T')
folium.Marker([x, y], popup=popup).add_to(field_map)
html = """<p> Color Guide </p> <br>"""
i = 0
while i < len(field_values.nitrogenList):
opening = "<p><font color = " + color(
field_values, field_values.nitrogenList[i]) + ">"
newString = "█ nitrogen level of %d" % (
field_values.nitrogenList[i])
closing = "</font></p>"
breakLine = "<br>"
fullstring = opening + newString + closing + breakLine
html = html + fullstring
i = i + 1
iframe = folium.IFrame(html=html, width=100, height=300)
popup = folium.Popup(iframe, max_width=2650)
x, y = utm.to_latlon((xmin - 25), (ymax + ymin) / 2, 12, 'T')
folium.Marker([x, y], popup=popup).add_to(field_map)
folium.LatLngPopup().add_to(field_map)
#saves and opens
field_map.save("created_map.html")
webbrowser.open_new_tab("created_map.html")
return
def CovertToLatLon(self, east, north, zoneNumber, zoneLetter):
lat, lon = utm.to_latlon(east, north, zoneNumber, zoneLetter)
return [lat, lon]
def longitude(row,zone,E_off,N_off):
EastNorth = (row['Easting']+E_off, row['Northing']+N_off)
latlon = utm.to_latlon(*EastNorth, zone, northern=True)
return(round(latlon[1],4))
def UTMconversion(UTM_XY):
WGS84_XY = utm.to_latlon(UTM_XY[0], UTM_XY[1], 15, 'N')
return WGS84_XY
def coordenadas_utm(utm_norte, utm_este, zona, letra):
return utm.to_latlon(utm_este, utm_norte, zona, letra)
import utm
import csv
import sys
TIMESTAMP = 1354579200
if (len(sys.argv) <= 4):
print 'Error. Usage: input output zone_number zone_letter'
exit()
input = open(sys.argv[1])
#input.readline()
csv_reader = csv.reader(input, delimiter=' ')
output = open(sys.argv[2], 'w+')
output.write(str(TIMESTAMP) + '\n')
output.write(str(TIMESTAMP) + '\n')
for point in csv_reader:
try:
x = float(point[0])
y = float(point[1])
#print x, y
latlng = utm.to_latlon(x, y, int(sys.argv[3]), sys.argv[4])
output.write(
str(TIMESTAMP) + ',' + str(latlng[0]) + ',' + str(latlng[1]) +
'\n')
except ValueError:
print 'Skipped ' + str(point)
def __init__(self,
dataConfig,
topo,
start_date,
end_date,
time_zone='UTC',
dataType='wrf',
tempDir=None,
forecast_flag=False,
day_hour=0,
n_forecast_hours=18):
if (tempDir is None) | (tempDir == 'WORKDIR'):
tempDir = os.environ['WORKDIR']
self.tempDir = tempDir
self.dataConfig = dataConfig
self.dataType = dataType
self.start_date = start_date
self.end_date = end_date
self.time_zone = time_zone
self.forecast_flag = forecast_flag
self.day_hour = day_hour
self.n_forecast_hours = n_forecast_hours
# degree offset for a buffer around the model domain
self.offset = 0.1
self.force_zone_number = None
if 'zone_number' in dataConfig:
self.force_zone_number = dataConfig['zone_number']
# The data that will be output
self.variables = [
'air_temp', 'vapor_pressure', 'precip', 'wind_speed',
'wind_direction', 'cloud_factor', 'thermal'
]
# get the bounds of the model so that only the values inside
# the model domain are used
self.x = topo.x
self.y = topo.y
self.lat = topo.topoConfig['basin_lat']
self.lon = topo.topoConfig['basin_lon']
# get the zone number and the bounding box
u = utm.from_latlon(topo.topoConfig['basin_lat'],
topo.topoConfig['basin_lon'],
self.force_zone_number)
self.zone_number = u[2]
self.zone_letter = u[3]
ur = np.array(
utm.to_latlon(np.max(self.x), np.max(self.y), self.zone_number,
self.zone_letter))
ll = np.array(
utm.to_latlon(np.min(self.x), np.min(self.y), self.zone_number,
self.zone_letter))
buff = 0.1 # buffer of bounding box in degrees
ur += buff
ll -= buff
self.bbox = np.append(np.flipud(ll), np.flipud(ur))
self._logger = logging.getLogger(__name__)
# load the data
if dataType == 'wrf':
self.load_from_wrf()
elif dataType == 'netcdf':
self.load_from_netcdf()
elif dataType == 'hrrr_grib':
self.load_from_hrrr()
else:
raise Exception('Could not resolve dataType')
reference_file_name = 'orkney.dat'
times = (0., 100.)
boundary_xy = numpy.loadtxt('orkney.xy')
tide = uptide.Tides(constituents)
tide.set_initial_time(initial_time)
tnci = uptide.tidal_netcdf.OTPSncTidalInterpolator(tide, grid_file_name,
data_file_name, ranges)
vals_t = []
for t in times:
tnci.set_time(t)
vals = []
for xy in boundary_xy:
latlon = utm.to_latlon(xy[0], xy[1], utm_zone, utm_band)
vals.append(
tnci.get_val((latlon[1], latlon[0]), allow_extrapolation=True))
vals_t.append(vals)
vals_t = numpy.array(vals_t).T
# uncomment to update reference:
#numpy.savetxt(reference_file_name, vals_t)
reference = numpy.loadtxt(reference_file_name)
err = numpy.abs(reference - vals_t).max()
print("err = ", err)
if err > 1e-3:
print("Error too large")
sys.exit(1)
url = bus127.buses[busurl]
res = requests.get(url).json()
points = res['Sc']['Crs'][0]['Ps']
for point in points:
route.append([point['Y'], point['X']])
# print(route)
# stations = res['Sc']['Crs'][0]['Ss']
# for station in stations:
# # print(station['Pt']['Y'])
# station_point.append([station['Pt']['X'], station['Pt']['Y']])
bus_lt, bus_ln = utm.to_latlon(658048,
4790628,
43,
zone_letter='T',
northern=None,
strict=True)
station_lt, station_ln = 43.26525, 76.948869
print(bus_lt, bus_ln)
get_route()
def route_dir():
dist_list = []
clockwise = True
segments = 0
# расстояние до автобуса всех точек
for i in range(0, len(route)):
dist_list.append(get_dist(route[i][0], route[i][1], bus_lt, bus_ln))
def UTM(E, N, zone_num, zone_let):
return utm.to_latlon(E, N)
def test_to_latlon_range_checks(self):
'''to_latlon should fail with out-of-bounds input'''
# test easting range
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(0),
np.array(5000000), 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(99999),
np.array(5000000), 32, 'U')
for i in range(100000, 999999, 1000):
UTM.to_latlon(np.array(i), np.array(5000000), 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon,
np.array(1000000), np.array(5000000), 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon,
np.array(100000000000), np.array(5000000), 32, 'U')
# test northing range
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(-100000), 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(-1), 32, 'U')
for i in range(10, 10000000, 1000):
UTM.to_latlon(np.array(500000), np.array(i), 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(10000001), 32, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(50000000), 32, 'U')
# test zone numbers
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 0, 'U')
for i in range(1, 60):
UTM.to_latlon(np.array(500000), np.array(5000000), i, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 61, 'U')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 1000, 'U')
# test zone letters
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 32, 'A')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 32, 'B')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 32, 'I')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 32, 'O')
for i in range(ord('C'), ord('X')):
i = chr(i)
if i != 'I' and i != 'O':
UTM.to_latlon(np.array(500000), np.array(5000000), 32, i)
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 32, 'Y')
self.assertRaises(UTM.OutOfRangeError, UTM.to_latlon, np.array(500000),
np.array(5000000), 32, 'Z')
'lightblue', 'lightgreen', 'gray', 'black', 'lightgray'
]))
colour = defaultdict(lambda: next(colour_iter))
m = folium.Map(location=[50.75, -1], zoom_start=10)
#It's zone 30N UTM, so EPSG code is 32630
#pickle.dump(tracks, open("./ss.pkl", "wb"))
for track in tracks:
print(detector.zone_number, detector.northern, measurement_model.mapping)
points = [
utm.to_latlon(*state.state_vector[measurement_model.mapping, :],
detector.zone_number,
northern=detector.northern,
strict=False) for state in track
]
folium.PolyLine(points, color=colour[track.metadata.get('MMSI')]).add_to(m)
folium.Marker(points[-1],
icon=folium.Icon(icon='fa-ship',
prefix="fa",
color=colour[track.metadata.get('MMSI')]),
popup="\n".join(
"{}: {}".format(key, value)
for key, value in track.metadata.items())).add_to(m)
# %%
# sphinx_gallery_thumbnail_path = '_static/sphinx_gallery/AIS_Solent_Tracker_thumb.png'
def getPoint(row):
x = float(row['Gis_X'].replace(',', '.'))
y = float(row['Gis_Y'].replace(',', '.'))
latlon = utm.to_latlon(x, y, 30, northern=True)
point = geojson.Point(latlon[::-1], precision=8)
return point
def getStationsFromDomain(self, maxlat, maxlon, minlat, minlon, height):
"""Searches station list for radar stations that would be relevant
to the domain provided.
maxlat: maximum latitude of domain
maxlon: maximum longitude of domain
minlat: minimum lattitude of domain
minlon: minimum longitude of domain
height: height above sealevel in meters for domain
returns: list of station ids ex. ['KIND', 'KLVX']
"""
# http://geokov.com/education/utm.aspx
# easting values increase towards east
# max lon is east side
# max lat is north
maxeast_domain, maxnorth_domain, max_zone_number, max_zone_letter = utm.from_latlon(
maxlat, maxlon)
mineast_domain, minnorth_domain, min_zone_number, min_zone_letter = utm.from_latlon(
minlat, minlon)
relevant_stations = []
possibly_relevant_stations = []
for i, latlon in enumerate(STATION_LATLONS):
lat, lon = latlon
station_radius = self._calculateRadiusAtHeight(
height, STATION_INDEX[i]['station_elevation'])
if station_radius is None:
continue
relevant_radius = RELEVANT_DISTANCE_COEFFICENT * station_radius
maxeast = maxeast_domain + relevant_radius
maxnorth = maxnorth_domain + relevant_radius
domain_maxlat, domain_maxlon = utm.to_latlon(maxeast,
maxnorth,
max_zone_number,
max_zone_letter,
strict=False)
mineast = mineast_domain - relevant_radius
minnorth = minnorth_domain - relevant_radius
domain_minlat, domain_minlon = utm.to_latlon(mineast,
minnorth,
min_zone_number,
min_zone_letter,
strict=False)
# Vertical band of relevant domain bounded by user-given domain
if ((lat <= domain_maxlat and lat >= domain_minlat)
and (lon <= maxlon and lon >= minlon)):
relevant_stations.append(STATION_INDEX[i]['station_id'])
# Horizontal band of relevant domain bounded by user-given domain
elif ((lat <= maxlat and lat >= minlat)
and (lon <= domain_maxlon and lon >= domain_minlon)):
relevant_stations.append(STATION_INDEX[i]['station_id'])
# north east corner of relevant domain
elif ((lat <= domain_maxlat and lat >= maxlat)
and (lon <= domain_maxlon and lon >= maxlon)
and _isStationInDomainCorner(
maxlat, maxlon, STATION_INDEX[i]['latitude'],
STATION_INDEX[i]['longitude'], relevant_radius)):
relevant_stations.append(STATION_INDEX[i]['station_id'])
# south east corner of relevant domain
elif ((lat <= domain_minlat and lat >= minlat)
and (lon <= domain_maxlon and lon >= maxlon)
and _isStationInDomainCorner(
minlat, maxlon, STATION_INDEX[i]['latitude'],
STATION_INDEX[i]['longitude'], relevant_radius)):
relevant_stations.append(STATION_INDEX[i]['station_id'])
# south west corner of relevant domain
elif ((lat <= domain_minlat and lat >= minlat)
and (lon <= domain_minlon and lon >= minlon)
and _isStationInDomainCorner(
minlat, minlon, STATION_INDEX[i]['latitude'],
STATION_INDEX[i]['longitude'], relevant_radius)):
relevant_stations.append(STATION_INDEX[i]['station_id'])
# north west corner of relevant domain
elif ((lat <= domain_maxlat and lat >= maxlat)
and (lon <= domain_minlon and lon >= minlon)
and _isStationInDomainCorner(
maxlat, minlon, STATION_INDEX[i]['latitude'],
STATION_INDEX[i]['longitude'], relevant_radius)):
relevant_stations.append(STATION_INDEX[i]['station_id'])
return relevant_stations
def extract_state_arr_mean(state_crop_csv,
state_sm_dir,
point_no,
fdir=None,
point_level='high'):
"""
Extract state array of field data from munich test sites.
:param state_crop_csv: filename of crop field data csv
:param state_sm_dir: directory location of soil moisture field data
:param point_no: field point number, corresponding to munich test site numbering
:param fdir: directory to save the output
:param point_level: which point to use choice of: 'low', 'high', 'med', 'mean'
:return:
"""
state_dat = mlab.csv2rec(state_crop_csv, skiprows=1, delimiter=',')
dates = state_dat['none']
date_str = [a.strftime("%Y/%m/%d %H:%M") for a in dates]
lai_high = state_dat['lai']
lai_low = state_dat['lai_1']
lai_med = state_dat['lai_2']
lai_mean = state_dat['lai_mean_hants']
lai_std = state_dat['lai_std']
canht_high = state_dat['height_cm'] / 100.
canht_low = state_dat['height_cm_1'] / 100.
canht_med = state_dat['height_cm_2'] / 100.
canht_mean = state_dat['height_cm_mean'] / 100.
canht_std = state_dat['height_cm_std'] / 100.
sm_loc_dat = mlab.csv2rec(state_sm_dir + '/locations_utm_epsg-32632.csv')
easting = sm_loc_dat['point_x'][(sm_loc_dat['id'] == point_no)
& (sm_loc_dat['esu'] == 'med')]
northing = sm_loc_dat['point_y'][(sm_loc_dat['id'] == point_no)
& (sm_loc_dat['esu'] == 'med')]
file_head_1 = sm_loc_dat['esu_sm'][(sm_loc_dat['id'] == point_no)
& (sm_loc_dat['esu'] == 'med')][0]
file_head_2 = sm_loc_dat['esu_sm'][(sm_loc_dat['id'] == point_no)
& (sm_loc_dat['esu'] == 'high')][0]
file_head_3 = sm_loc_dat['esu_sm'][(sm_loc_dat['id'] == point_no)
& (sm_loc_dat['esu'] == 'low')][0]
lat, lon = utm.to_latlon(easting, northing, 32, 'U')
sm_csv1 = glob.glob(state_sm_dir + '/' + file_head_1 + '*SM.csv')[0]
sm_dat1 = mlab.csv2rec(sm_csv1)
sm_csv2 = glob.glob(state_sm_dir + '/' + file_head_2 + '*SM.csv')[0]
sm_dat2 = mlab.csv2rec(sm_csv2)
sm_csv3 = glob.glob(state_sm_dir + '/' + file_head_3 + '*SM.csv')[0]
sm_dat3 = mlab.csv2rec(sm_csv3)
#sm_idx = [find_nearest(sm_dat['date'], dt.datetime.combine(x,dt.datetime.min.time()))[1] for x in dates]
sm_dates = sm_dat1['date'][3:]
date_str_sm = [a.strftime("%Y/%m/%d %H:%M") for a in sm_dates]
sm1_port1 = sm_dat1['port1_sm'][3:]
sm1_port2 = sm_dat1['port2_sm'][3:]
sm1_mean = np.nanmean((sm1_port1, sm1_port2), axis=0)
sm2_port1 = sm_dat2['port1_sm']
sm2_port2 = sm_dat2['port2_sm']
sm2_mean = np.nanmean((sm2_port1, sm2_port2), axis=0)
sm3_port1 = sm_dat3['port1_sm'][3:]
sm3_port2 = sm_dat3['port2_sm'][3:]
sm3_mean = np.nanmean((sm3_port1, sm3_port2), axis=0)
sm_mean = np.nanmean((sm1_mean, sm2_mean, sm3_mean), axis=0)
sm_std = np.nanstd(
(sm1_port1, sm1_port2, sm2_port1, sm2_port2, sm3_port1, sm3_port2),
axis=0)
save_arr_lai_canht = np.array([
date_str, lai_mean, canht_mean,
np.array([lat] * len(dates)),
np.array([lon] * len(dates)), lai_std, canht_std
]).T
fname_lai_canht = fdir + '/mni_lai_canht_field_' + str(
point_no) + '_' + str(point_level) + '.csv'
np.savetxt(fname_lai_canht,
save_arr_lai_canht,
fmt='%s',
delimiter=',',
header='date, lai, canht, lat, lon, lai_std, '
'canht_std')
save_arr_sm = np.array([
date_str_sm, sm_mean,
np.array([lat] * len(sm_dates)),
np.array([lon] * len(sm_dates)), sm_std
]).T
fname_sm = fdir + '/mni_sm_field_' + str(point_no) + '_' + str(
point_level) + '.csv'
np.savetxt(fname_sm,
save_arr_sm,
fmt='%s',
delimiter=',',
header='date, sm, lat, lon, sm_std')
return sm_dates, lat, lon
zoneLetter = root.find("Georeference").find("zoneLetter").text
print("georeferenceMatrix", georeferenceMatrix)
print("zoneNumber", zoneNumber)
print("zoneLetter", zoneLetter)
coordinates_map = []
coordinates_gps = []
for t in root.find('Transformations'):
gps_str = t.find("gps").text
if gps_str is not None:
#print (gps_str)
d = gps_str.split()
ll1 = d[0]
ll2 = d[1]
ll3 = d[2]
coordinates_gps.append([ll1, ll2, ll3])
m = t.find('Affine').find('Data').text
mm = stringToNp(m)
v = np.array([mm[3, 0], mm[3, 1], mm[3, 2], 1])
b = georeferenceMatrix.dot(v)
#print (b)
(lat, lon) = utm.to_latlon(b[1],
b[0],
zone_number=zoneNumber,
zone_letter=zoneLetter)
coordinates_map.append([lat, lon])
kfile = open(fname_base + "_map.kml", 'w')
generateKML(kfile, coordinates_map, coordinates_gps)
def get_LOS_vector(self, locations):
"""
calculate beta - the angle at earth center between reference point
and satellite nadir
"""
if not isinstance(locations, list):
locations = [locations]
utmZone = self.location_UTM_zone
refPoint = vmath.Vector3(self.ref.x, self.ref.y, 0)
satAltitude = self.satellite_altitude
satAzimuth = self.satellite_azimuth
satIncidence = self.ref_incidence
earthRadius = self.local_earth_radius
DEG2RAD = np.pi / 180.
alpha = satIncidence * DEG2RAD
beta = (earthRadius / (satAltitude + earthRadius)) * np.sin(alpha)
beta = alpha - np.arcsin(beta)
beta = beta / DEG2RAD
# calculate angular separation of (x,y) from satellite track passing
# through (origx, origy) with azimuth satAzimuth
# Long lat **NOT** lat long
origy, origx = utm.to_latlon(
refPoint.x, refPoint.y, np.abs(utmZone), northern=utmZone > 0
)
xy = np.array([
utm.to_latlon(u[0], u[1], np.abs(utmZone), northern=utmZone > 0)
for u in locations
])
y = xy[:, 0]
x = xy[:, 1]
angdist = self._ang_to_gc(x, y, origx, origy, satAzimuth)
# calculate beta2, the angle at earth center between roaming point and
# satellite nadir track, assuming right-looking satellite
beta2 = beta - angdist
beta2 = beta2 * DEG2RAD
# calculate alpha2, the new incidence angle
alpha2 = np.sin(beta2) / (
np.cos(beta2) - (earthRadius / (earthRadius + satAltitude))
)
alpha2 = np.arctan(alpha2)
alpha2 = alpha2 / DEG2RAD
# calculate pointing vector
satIncidence = 90 - alpha2
satAzimuth = 360 - satAzimuth
los_x = -np.cos(satAzimuth * DEG2RAD) * np.cos(satIncidence * DEG2RAD)
los_y = -np.sin(satAzimuth * DEG2RAD) * np.cos(satIncidence * DEG2RAD)
los_z = np.sin(satIncidence * DEG2RAD)
return vmath.Vector3Array([los_x, los_y, los_z])
def fromUTM(self, coords):
# Conversion
return utm.to_latlon(coords)
