def gps_taginfo(image_path):
exif = gpsphoto.getGPSData(image_path)
file_name = (os.path.basename(image_path))
if exif:
lat = (exif['Latitude'])
lng = (exif['Longitude'])
date = (exif['Date'])
d = date.split('/')
year = d[2]
#print('the latitude is {0}, the longitude is {1} and the year is year {2}' .format(lat,lng,year))
url = f'https://api.bigdatacloud.net/data/reverse-geocode?latitude={lat}&longitude={lng}8&localityLanguage=en&key=2028335aee824d0ba128d6bcf363abdc'
response = requests.get(url,timeout=5)
try:
country = response.json()["countryName"]
except KeyError:
country = "NoData"
try:
state = response.json()["principalSubdivision"]
except KeyError:
state = "NoData"
try:
city = response.json()["locality"]
except:
city = "NoData"
response.close()
return(file_name,city,state,country,year)
else:
print("ERROR:Exif data not present in pic")
unknown = 'NoExif Data'
directory_path = directory_path_maker(image_path,unknown)
directory_checker(directory_path,image_path)
return(None,None,None,None,None)
def main():
# -- plot layouts --
root = Path("./data/plot_layer/")
fn = Path("Simpson_plots_2019.shp")
path = root / fn
data = gpd.read_file(path)
data.plot()
plt.savefig("./layout.png", transparent=True, dpi=300, bbox_inches='tight')
plt.close("all")
# -- compute Vegetative Indices --
img_path = "./data/NEPAC_L4_170801_200ft/DJI_1930.JPG"
gps_coord = gpsphoto.getGPSData(img_path)
raw_img = np.array(Image.open(img_path))
vari_img = compute_vgi(raw_img, "vari")
vari_img = normalize_img(vari_img)
fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(vari_img, interpolation='none')
plt.savefig("./vgi_vari.png",
transparent=True,
bbox_inches='tight',
dpi=300)
plt.close("all")
tgi_img = compute_vgi(raw_img, "tgi")
fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(tgi_img, interpolation='none')
plt.savefig("./vgi_tgi.png",
transparent=True,
bbox_inches='tight',
dpi=300)
plt.close("all")
def main():
# -- plot layouts --
root = Path("./data/plot_layer/")
plot_layout = load_plot_layout(root)
plot_layout = plot_layout.to_crs('EPSG:32616')
# -- sampling area layer --
root = Path("./data/sampling_areas/")
sampling_areas = load_sampling_areas(root)
sampling_areas = sampling_areas.to_crs('EPSG:32616')
# -- load example image --
img_path = "./data/NEPAC_L4_170801_200ft/DJI_1930.JPG"
gps_coord = gpsphoto.getGPSData(img_path)
gps_coord = gps_to_crs(gps_coord, 'EPSG:32616')
raw_img = np.array(Image.open(img_path))
print("Image at {}".format(gps_coord))
# -- plot sampling area and plot layout --
fig, ax = plt.subplots(figsize=(8, 8))
plot_layout.plot(ax=ax, alpha=0.5)
sampling_areas.plot(column='Sarea_ID', ax=ax)
plt.savefig("./output/sample_and_plot_layer_proj.png",
transparent=True,
bbox_inches='tight')
plt.close("all")
def make_pic_data_csv(paths_arr):
file_name = 'pic_coords_time.csv' # TODO: not hardcode this
print("creating: %s" % file_name)
outfile = open(file_name, 'w+')
outfile.write('path, coordinates, date\n')
for path in paths_arr:
for root, dirs, files in os.walk(path):
for name in files:
full_path = os.path.join(root, name)
try:
data = gpsphoto.getGPSData(full_path)
if data != {}:
csv_str = "%s, %s %s, %s,\n" % (
full_path, data.get('Latitude'),
data.get('Longitude'),
to_timestamp(data['Date'], data['UTC-Time']))
print(csv_str.rstrip())
outfile.write(csv_str)
except (ValueError, KeyError) as e:
print("---ERROR---")
print(full_path)
print(e)
outfile.close()
print("created: %s" % file_name)
return file_name
def wrt_geo_viz():
'''given a directory of jpeg images, a geojson file is written with long,lat and alt for each image'''
path = '/media/antor/Transcend/drone/data/dhanmondi/100MEDIA/'
json_out_path = './new_home/geojson_viz.json'
file_lst = [f for f in listdir(path) if isfile(join(path, f))]
empt = {"type": "FeatureCollection", "features": []}
print('writing long, lat to geojson file ......')
for i in range(len(file_lst)):
file_path = join(path, file_lst[i])
data = gpsphoto.getGPSData(file_path)
empt["features"].append({
"id": str(file_lst[i]),
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [data['Longitude'], data['Latitude']]
},
"properties": {
"image_id": str(file_lst[i]),
"longitude": data['Longitude'],
"latitude": data['Latitude'],
"altitude": data['Altitude']
}
})
if i % 501 == 500 or i == len(file_lst):
print(str(i) + ' images processed....')
with open(json_out_path, 'w') as f:
json.dump(empt, f)
def get_gps(file_name):
from GPSPhoto import gpsphoto
gps_data = gpsphoto.getGPSData(file_name)
try:
return gps_data['Latitude'], gps_data['Longitude']
except:
return [] #exif 파일이 아닐 경우 빈 값 리턴
def extract_information_from_images(
self
) -> dict: # Time Complexity : O(n) where n is the number of images in all the folders
image_source_path = self.__source
crops_geo_data = {}
crop_folders_list = [
name for name in os.listdir(image_source_path)
if name != ".DS_Store"
]
for folder_name in tqdm(crop_folders_list):
folder_location = "{}\{}".format(image_source_path, folder_name)
file_names_list = [
name for name in os.listdir(folder_location)
if name != ".DS_Store"
]
for file_name in file_names_list:
if folder_name not in crops_geo_data:
crops_geo_data[folder_name] = []
file_location = "{}\{}".format(folder_location, file_name)
# Get the data from image file and return a dictionary
data = gpsphoto.getGPSData(file_location)
if data: #Some Images dont have exif data
crops_geo_data[folder_name].append(
(data['Latitude'], data['Longitude']))
return crops_geo_data
def get_coordinates(filepath):
try:
data = gpsphoto.getGPSData(filepath)
long = str(data['Longitude'])
lat = str(data['Latitude'])
coords = lat + "," + long
params = {'latlng': coords, 'key': API_KEY, 'language': 'ru'}
maps_params = coords
url_maps = 'https://www.google.com/maps/search/?api=1&query='
url_maps_full = url_maps + maps_params
url_params = urllib.parse.urlencode(params)
google_GeoCode_Url = 'https://maps.googleapis.com/maps/api/geocode/json?'
url = google_GeoCode_Url + url_params
response = requests.get(url)
data = response.json()
if data['status'] == 'OK':
result = data['results'][0]
location = result['formatted_address']
print(location)
print(url_maps_full)
else:
print("Произошла ошибка", data['status'])
except:
print("Файл не содержит координат.")
def lambda_handler(event, context):
#print("Received event: " + json.dumps(event, indent=2))
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = event['Records'][0]['s3']['object']['key']
try:
print("trying to get " + key + " from bucket " + bucket)
response = s3.get_object(Bucket=bucket, Key=key)
download_path = '/tmp/foo.jpg'
s3.download_file(bucket, key, download_path)
print(response)
print(download_path)
data = gpsphoto.getGPSData(download_path)
print(data['Latitude'], data['Longitude'])
latLon = "(" + str(data['Latitude']) + ", " + str(data['Longitude']) + ")"
now = datetime.now()
current_time = now.isoformat()
dynamodb.put_item(TableName='Dogs', Item={'location_found':{'S':latLon},'datetime_found':{'S':current_time}})
print("CONTENT TYPE: " + response['ContentType'])
return response['ContentType']
except Exception as e:
print(e)
print('Error getting object {} from bucket {}. Make sure they exist and your bucket is in the same region as this function.'.format(key, bucket))
raise e
def gps(fileName):
data = gpsphoto.getGPSData(getOutdoorImage(fileName))
gpsData = str(data['Latitude']) + "," + str(data['Longitude'])
writeTemp(gpsData)
if "Latitude" in data:
return gpsData
else:
return "No GPS Data"
def get_geo_info(file_path):
# Get the data from image file and return a dictionary
data = gpsphoto.getGPSData(file_path)
rawData = gpsphoto.getRawData(file_path)
if 'Latitue' in data:
return (data['Latitude'], data['Longitude'])
else:
return None
def search(file):
if Image:
try:
img = Image.open(file)
data = gpsphoto.getGPSData(file)
print('in file', file, 'GPS tag was founded: ', data['Latitude'], data['Longitude'])
except:
pass
def get_meta_gps(img_path):
try:
gps_data = gpsphoto.getGPSData(img_path)
except:
return None, None
# If GPS coordinates are in metadata, use those
if gps_data is not None and 'Latitude' in gps_data and 'Longitude' in gps_data:
return gps_data['Latitude'], gps_data['Longitude']
return None, None
def main():
orig_pic = '/Users/Leon/Documents/project/modPhotoGPS/data/IMG_0752.jpeg'
print(os.path.exists(orig_pic))
data = gpsphoto.getGPSData(orig_pic)
rawdata = gpsphoto.getRawData(orig_pic)
for tag in data.keys():
print("%s: %s" % (tag, data[tag]))
print("%s : %s" % (data['Latitude'], data['Longitude']))
print("Hellps")
def get_data(picture):
a = gpsphoto.getGPSData(picture)
try:
return f"{a['Latitude']},{a['Longitude']}"
except Exception as e:
return ("ERROR")
def loadPictureOnDict(picture, picturesDict, latLongDict, path):
#print('Will read GPS data from picture '+picture)
try:
innerPath = path / picture
data = gpsphoto.getGPSData(innerPath.as_posix())
picturesDict[picture] = (data['Latitude'], data['Longitude'])
latLongDict[str((data['Latitude'], data['Longitude']))] = picture
except:
print('Failed to read the GPS data from the picture ' + picture)
def get_image_location(url):
urllib.request.urlretrieve(url, "tempimg.jpg")
data = gp.getGPSData("tempimg.jpg")
lat = data.get("Latitude")
longe = data.get("Longitude")
os.remove("tempimg.jpg")
if (lat != None and longe != None):
return {"latitude": lat, "longitude": longe}
return None
def main():
"""Calibrate images here"""
args = get_args()
img_list = glob.glob(f'{args.dir}/*.tif', recursive=True)
out_path = args.outdir
if not os.path.isdir(out_path):
os.makedirs(out_path)
for img in img_list:
meta_path = img.replace('.tif', '_meta.csv')
filename = os.path.basename(img)
outfile = os.path.join(os.getcwd(), out_path, filename)
print(outfile)
meta_df = pd.read_csv(meta_path, delimiter=';')
print(meta_df['TempFPA'][0])
g_img = gdal.Open(img)
exif_dict = piexif.load(img)
zeroth = str(exif_dict['0th'])
exif = str(exif_dict['Exif'])
GPS = str(exif_dict['GPS'])
gps_data = gpsphoto.getGPSData(img)
rawData = gpsphoto.getRawData(img)
raw_data = g_img.GetRasterBand(1).ReadAsArray().astype('float')
tc = raw2temp(raw_data, meta_df)
create_geotiff(tc, (0, 0, 0, 0), outfile, None, True, None,
extra_metadata=[
f'0th={str(zeroth.strip("{}"))}\n\
Exif={str(exif.strip("{}"))}\n\
GPS={str(GPS.strip("{}"))}\n'
], compress=False)
cmd = f'exiftool -overwrite_original -TagsFromFile {img} {outfile}'
subprocess.call(cmd, shell=True)
exif_dict = piexif.load(outfile)
gps_data = gpsphoto.getGPSData(outfile)
print(f'{gps_data}\n')
def coords(path):
try:
gps_data = gpsphoto.getGPSData(path)
if "Latitude" in gps_data and "Longitude" in gps_data:
return gps_data.get("Latitude", 0.0), gps_data.get("Longitude", 0.0)
else:
return None
except:
print("Error getting GPS data from file {}".format(path))
return None
def upload_images(bulk_dir):
image_records = []
for root, subdirs, files in os.walk(bulk_dir):
for file in files:
ext = os.path.splitext(file)[1].lower()
if ext in supported_formats:
imgPath = os.path.join(root, file)
tags = exifread.process_file(open(imgPath, 'rb'))
gpsData = gpsphoto.getGPSData(imgPath)
Latitude = none_check_float(gpsData.get('Latitude'))
Longitude = none_check_float(gpsData.get('Longitude'))
Altitude = none_check_float(gpsData.get('Altitude'))
DateTime = none_check_str(tags.get('Image DateTime'))
ExposureTime = none_check_str(tags.get('EXIF ExposureTime'))
FNumber = none_check_str(tags.get('EXIF FNumber'))
MeteringMode = none_check_str(tags.get('EXIF MeteringMode'))
FocalLength = none_check_str(tags.get('EXIF FocalLength'))
ExifVersion = none_check_str(tags.get('EXIF ExifVersion'))
Software = none_check_str(tags.get('Image Software'))
Make = none_check_str(tags.get('Image Make'))
Model = none_check_str(tags.get('Image Model'))
BodySerialNumber = none_check_str(
tags.get('EXIF BodySerialNumber'))
LightSource = none_check_str(tags.get('EXIF LightSource'))
WhiteBalance = none_check_str(tags.get('EXIF WhiteBalance'))
GainControl = none_check_str(tags.get('EXIF GainControl'))
Contrast = none_check_str(tags.get('EXIF Contrast'))
Saturation = none_check_str(tags.get('EXIF Saturation'))
Sharpness = none_check_str(tags.get('EXIF Sharpness'))
Compression = none_check_str(tags.get('Image Compression'))
ImageWidth = none_check_int(
tags.get('Image ImageWidth')) or none_check_int(
tags.get('EXIF ExifImageWidth'))
ImageLength = none_check_int(
tags.get('Image ImageLength')) or none_check_int(
tags.get('EXIF ExifImageLength'))
ISOSpeed = none_check_int(
tags.get('EXIF ISOSpeed')) or none_check_int(
tags.get('EXIF ISOSpeedRatings'))
ExposureProgram = none_check_str(
tags.get('EXIF ExposureProgram')) or none_check_str(
tags.get('EXIF ExposureMode'))
image_records.insert(
0,
(None, None, str(imgPath), str(ext), DateTime, Latitude,
Longitude, Altitude, ImageWidth, ImageLength,
ExposureTime, FNumber, ISOSpeed, MeteringMode,
LightSource, FocalLength, ExposureProgram, WhiteBalance,
GainControl, Contrast, Saturation, Sharpness, Compression,
ExifVersion, Software, Make, Model, BodySerialNumber))
image_dao.insert_images(image_records)
def getCoordinates(image_name):
data = gpsphoto.getGPSData(image_name)
latitude = data['Latitude']
longitude = data['Longitude']
list = []
list.append(latitude)
list.append(longitude)
return list
def getTag(path):
metaData = gpsphoto.getGPSData(path)
geoLocalization = [0,0]
for tag in metaData.keys():
#print ("%s: %s" % (tag, metaData[tag]))
if tag == "Latitude":
geoLocalization[0] = metaData[tag]
if tag == "Longitude":
geoLocalization[1] = metaData[tag]
return geoLocalization
def get_data_from_exif(self):
"""
Get image information from its EXIF metadata.
:return: images information
:rtype: tuple
"""
dic = gpsphoto.getGPSData(self.path)
self.lat = "{0:.6f}".format(dic["Latitude"])
self.lon = "{0:.6f}".format(dic["Longitude"])
self.datetime = exif_to_sql(dic['Date'], dic['UTC-Time'])
return self.lat, self.lon, self.datetime
def get_gps_search_tokens(image_filename: str,
resolver: LatLongResolver) -> List[str]:
try:
data = gpsphoto.getGPSData(image_filename)
if 'Latitude' in data and 'Longitude' in data:
tokens = resolver.nearest(data['Latitude'], data['Longitude'])
return tokens
else:
return []
except Exception as ex:
logging.error('Unable to parse GPS coordinates for {} {}'.format(
image_filename, ex))
return []
def get_position_by_api(self):
try:
gps_info = gpsphoto.getGPSData(self.path)
location = f"{gps_info.get('Longitude')},{gps_info.get('Latitude')}"
resp = requests.get(
self.url_get_position.format(location, self.api_key)).json()
address = resp.get('regeocode').get('formatted_address')
city = resp.get('regeocode').get('addressComponent').get('city')
self.city = city
self.address = address
return address, city
except Exception as err:
return None, None
def get_date_and_location(path_to_image):
name_date_location_list = []
for i in os.listdir(path_to_image):
time_stamp = (Image.open(path_to_image + i)._getexif()[36867])
data = gpsphoto.getGPSData(path_to_image + i)
name_date_location_list.append(
[i, time_stamp, data['Latitude'], data['Longitude']])
return name_date_location_list
def __init__(self, path):
self.path = path
data = gpsphoto.getGPSData(path)
if "Latitude" in data.keys() and "Longitude" in data.keys():
lat, lon = (data["Latitude"], data["Longitude"])
if "Altitude" in data.keys():
self.height = data['Altitude']
z, l, x, y = utm.project((lon, lat))
self.lat = lat
self.lon = lon
self.zone = z
self.zone_letter = l
self.x = x
self.y = y
self.has_georeference = True
def get_map_screenshot():
"""
Returns screenshot of whole google map page
"""
image = "./test.jpg"
data = gpsphoto.getGPSData(image)
Lat, Long = data["Latitude"], data["Longitude"]
url = "https://www.google.co.in/maps?q=" + str(Lat) + ",+" + str(Long)
driver = webdriver.Firefox()
# driver.set_window_position(-2000,0)
driver.get(url)
driver.save_screenshot("map.png")
img = cv2.imread("map.png",1)
img = img[:,int(0.35*img.shape[1]):,:]
cv2.imwrite("map.png",img)
def closest_plant(photo_path):
data = gpsphoto.getGPSData(photo_path)
try:
photo_gps = (float(data['Latitude']), float(data['Longitude']))
closest = None
for i in plants:
plant_gps = (float(i[10]), float(i[11]))
if closest is None:
closest = [haversine(plant_gps, photo_gps)] + i
if closest[0] > haversine(plant_gps, photo_gps):
closest = [haversine(plant_gps, photo_gps)] + i
return closest
# Catch KeyError so we can ignore photos without any GPS.
except KeyError:
return None
def img_worker(self, fpath, fid):
self.logger.info("PID:" + str(os.getpid()) + " fid = " + str(fid) +
" img_worker target = " + str(fpath))
try:
gpx = gpsphoto.getGPSData(fpath)
with open(fpath, "rb") as inputfile:
dpath = os.path.join(
Path(fpath).parent, "image",
os.path.splitext(os.path.basename(fpath))[0] + "_d.jpg")
img_data = inputfile.read()
img_np_arr = np.array(
Image.open(io.BytesIO(img_data)).convert("RGB"))
img = {
'fid': fid,
'img_data': img_np_arr,
'img_path': fpath,
'dimg_path': dpath,
'speed': 0,
'VIDEOTIME': 0,
'isframe': 0
}
if (gpx != {}):
self.logger.debug("img_worker fid:" + str(fid) +
" Find GPS data...")
img['lat'] = gpx['Latitude']
img['lon'] = gpx['Longitude']
img['kmp'] = kmplush(self.kmpoints, {
'lat': gpx['Latitude'],
'lon': gpx['Longitude']
})
img['UTCTIME'] = datetime.datetime.strptime(
gpx['Date'] + " " + gpx['UTC-Time'],
'%m/%d/%Y %H:%M:%S')
else:
self.logger.error("GPS data Miss " + fpath)
img['lat'] = 23.470119
img['lon'] = 120.957689
img['kmp'] = {'name': "K0+0", 'meter': 0}
img['UTCTIME'] = datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S")
self.imgs.put(img)
# self.logger.debug(img)
endflag = {'fid': fid, 'endflag': True}
self.imgs.put(endflag)
self.logger.debug(str(fid) + " endflag sended")
except Exception as err:
raise err
os.kill(os.getpid(), signal.SIGTERM)
