def exif(img, vision):
"""
writes the json data into the exif fields of the output jpg, which is
currently called from detector.
"""
metadata = pyexiv2.ImageMetadata(img)
metadata.read()
# info = metadata.exif_keys
# for key in info:
# print("key: " + str(key))
metadata['Exif.Photo.UserComment'] = json.dumps(vision)
metadata['Exif.Image.Make'] = 'python'
try:
metadata.write()
except IOError:
print('An error occured trying to read the file.')
# printing the exif data to check it was all written
metadata = pyexiv2.ImageMetadata(img)
metadata.read()
userdata = json.loads(metadata['Exif.Photo.UserComment'].value)
pprint.pprint(userdata)
def get_create_time(fname, camera_manufacturer):
if camera_manufacturer == 'DJI':
metadata = pyexiv2.ImageMetadata(fname)
metadata.read()
create_time_local = metadata['Exif.Image.DateTime'].value
create_time = (create_time_local - datetime(
1970, 1, 1)).total_seconds() - 3600 * 9 # GMT+9 (S.Korea)
return create_time
elif camera_manufacturer == 'AIMIFY/FLIR/Visible':
metadata = pyexiv2.ImageMetadata(fname)
metadata.read()
create_time_local = metadata['Exif.GPSInfo.GPSTimeStamp'].value
create_time = (create_time_local - datetime(
1970, 1, 1)).total_seconds() - 3600 * 9 # GMT+9 (S.Korea)
return create_time
# time_string = fname.split('/')[-1][0:15]
# year = int(time_string[0:4])
# month = int(time_string[4:6])
# day = int(time_string[6:8])
# hour = int(time_string[9:11])
# minute = int(time_string[11:13])
# second = int(time_string[13:15])
#
# dt = datetime(year, month, day, hour, minute, second)
return datetime.timestamp(dt)
def main(file_list, outdir):
# copy parameters to arrays
K = np.array([[1743.23312, 0, 2071.06177], [0, 1741.57626, 1476.48298],
[0, 0, 1]])
d = np.array([-0.307412748, 0.300929683, 0, 0,
0]) # just use first two terms (no translation)
logging.debug("Starting loop")
for image in file_list:
logging.debug("var %s", image)
imgname = image.split("/")[-1]
new_image_path = os.path.join(outdir, imgname)
if not os.path.exists(new_image_path):
logging.debug("Undistorting %s . . . ", imgname)
# read one of your images
img = cv2.imread(image)
h, w = img.shape[:2]
# un-distort
newcamera, roi = cv2.getOptimalNewCameraMatrix(K, d, (w, h), 0)
newimg = cv2.undistort(img, K, d, None, newcamera)
# cv2.imwrite("original.jpg", img)
cv2.imwrite(new_image_path, newimg)
# Write metadata
old_meta = pyexiv2.ImageMetadata(image)
new_meta = pyexiv2.ImageMetadata(new_image_path)
old_meta.read()
new_meta.read()
old_meta.copy(new_meta)
new_meta.write()
else:
logging.debug("Image already processed")
def shrinkIfNeededByPIL(path, maxDimension):
if imageMaxDimensionByPIL(path) > maxDimension:
print "Shrinking " + path
imagePath = getTempPath(path)
img = Image.open(path)
(w, h) = img.size
if (w > h):
img2 = img.resize((maxDimension, (h * maxDimension) / w),
Image.ANTIALIAS)
else:
img2 = img.resize(((w * maxDimension) / h, maxDimension),
Image.ANTIALIAS)
img2.save(imagePath, 'JPEG', quality=99)
# now copy EXIF data from original to new
src_image = pyexiv2.ImageMetadata(path)
src_image.read()
dst_image = pyexiv2.ImageMetadata(imagePath)
dst_image.read()
src_image.copy(dst_image, exif=True)
# overwrite image size based on new image
dst_image["Exif.Photo.PixelXDimension"] = img2.size[0]
dst_image["Exif.Photo.PixelYDimension"] = img2.size[1]
dst_image.write()
return imagePath
return path
def save_with_compr(self, out_dir, compression):
img = cv2.imread(self.path)
shape = img.shape
for blur in self.blurs:
blur.apply(img, shape)
outpath = os.path.join(out_dir, os.path.basename(self.path))
metadata = pyexiv2.ImageMetadata(self.path)
metadata.read()
cv2.imwrite(outpath, img, [cv2.IMWRITE_JPEG_QUALITY, compression])
metadata_new = pyexiv2.ImageMetadata(outpath)
metadata_new.read()
metadata.copy(metadata_new)
for key in metadata.exif_keys:
try:
tag = metadata[key]
except UnicodeDecodeError as err:
sys.stderr.write("Skipping EXIF key {} due to {}\n".format(key, err))
metadata_new.__delitem__(key)
if "Exif.Image.Orientation" in metadata:
metadata_new.__delitem__("Exif.Image.Orientation")
# Update thumbnail
thumb = pyexiv2.exif.ExifThumbnail(metadata_new)
np_arr = numpy.frombuffer(bytes(thumb.data), numpy.uint8)
if np_arr.size > 0:
thumb_img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
thumb_shape = thumb_img.shape
for blur in self.blurs:
blur_for_thumb = blur.transform_to(shape, thumb_shape)
blur_for_thumb.apply(thumb_img, thumb_shape)
retval, buf = cv2.imencode(".jpg", thumb_img)
thumb.data = buf.tobytes()
metadata_new.write()
return os.path.getsize(outpath)
def do_copy(args):
""" Copy relevant tags from one file to another
"""
src_photo = args[0]
dst_photo = args[1]
try:
metadata_src = pyexiv2.ImageMetadata(src_photo)
metadata_src.read()
except IOError:
cprint('Error reading %s' % src_photo, 'red', 'on_yellow')
exit(1)
try:
metadata_dst = pyexiv2.ImageMetadata(dst_photo)
metadata_dst.read()
except IOError:
cprint('Error reading %s' % dst_photo, 'red', 'on_yellow')
exit(1)
print "Writing to %s" % dst_photo
try:
dtag = metadata_src[DATE_TAG]
print 'DateTimeOriginal: %s' % str(dtag.value)
metadata_dst[DATE_TAG] = str(dtag.value)
except KeyError:
pass
try:
ctag = metadata_src[COMMENT_TAG]
print 'UserComment: %s' % str(ctag.value)
metadata_dst[COMMENT_TAG] = str(ctag.value)
except KeyError:
pass
metadata_dst.write()
def import_image(path):
'''
import a single image.
'''
# get the filename...
file_name = os.path.split(path)[-1]
file_name_base = file_name.split('.')[0]
# start with metadata...
metadata = pyexiv2.ImageMetadata(path)
metadata.read()
# add path to the original as a comment...
if metadata['Exif.Photo.UserComment'].value.strip() == '':
metadata['Exif.Photo.UserComment'] = 'RAW path: ' + os.path.abspath(
path)
else:
metadata['Exif.Photo.UserComment'] = preview_metadata[
'Exif.Photo.UserComment'].value + '\n\nRAW path: ' + os.path.abspath(
path)
# extract preview from raw file (largest)...
orig_preview_path = os.path.join(ARCHIVE_PATH, HIRES_DIR, file_name)
## orig_preview = metadata.previews[-1]
## orig_preview.write_to_file(orig_preview_path)
##!!! HACK: use a lib instead of exec-ing a command for each image...
cmd = 'exiv2 -f -l "%s" -ep%s "%s"' % (os.path.join(
ARCHIVE_PATH, TMP_DIR), len(metadata.previews), path)
os.system(cmd)
##!!! HACK: guessing the file name...
orig_preview_path = os.path.join(
ARCHIVE_PATH, TMP_DIR,
'%s-preview%s.jpg' % (file_name_base, len(metadata.previews)))
# generate preview and save to preview dir...
preview_path = os.path.join(ARCHIVE_PATH, PREVIEW_DIR, file_name_base)
orig = Image.open(orig_preview_path)
scale = PREVIEW_SIZE / float(max(*orig.size))
## preview = orig.resize((int(orig.size[0]*scale), int(orig.size[1]*scale)), Image.BICUBIC)
preview = orig.resize(
(int(orig.size[0] * scale), int(orig.size[1] * scale)),
Image.ANTIALIAS)
preview.save(preview_path + '.jpg')
preview_metadata = pyexiv2.ImageMetadata(preview_path + '.jpg')
preview_metadata.read()
metadata.copy(preview_metadata)
preview_metadata.write()
# generate thumb and save to thumb dir...
thumb_path = os.path.join(ARCHIVE_PATH, THUMBS_DIR, file_name_base)
preview.thumbnail((THUMB_SIZE, THUMB_SIZE), Image.ANTIALIAS)
preview.save(thumb_path + '.jpg')
thumb_metadata = pyexiv2.ImageMetadata(thumb_path + '.jpg')
thumb_metadata.read()
metadata.copy(thumb_metadata)
thumb_metadata.write()
def copy_tags(raw_filename, undistorted_filename):
metadata_raw = pyexiv2.ImageMetadata(raw_filename)
metadata_raw.read()
metadata_undistorted = pyexiv2.ImageMetadata(undistorted_filename)
metadata_undistorted.read()
metadata_raw.copy(metadata_undistorted, comment=False)
metadata_undistorted.write()
def compNewVals(p_file_1, p_file_2, p_file_3):
#p_file_1 is unitialized, p_file_2 is initialized but unchanged, p_file_3's value was changed from p_file_2
#this finds the new keys for file2 and file3
#then it compares to see which values from those keys changed.
f_metadata1 = pyexiv2.ImageMetadata(p_file_1)
f_metadata1.read()
f_metadata2 = pyexiv2.ImageMetadata(p_file_2)
f_metadata2.read()
f_metadata3 = pyexiv2.ImageMetadata(p_file_3)
f_metadata3.read()
f_newkeys = newKeys(p_file_1, p_file_2)
f_vals = []
for key in f_newkeys:
if key == 'Xmp.xmp.CreateDate' or key == 'Xmp.MicrosoftPhoto.DateAcquired':
f_vals.append("???")
continue
if (key in f_metadata2.exif_keys or \
key in f_metadata2.iptc_keys or \
key in f_metadata2.xmp_keys) and \
(key in f_metadata3.exif_keys or \
key in f_metadata3.iptc_keys or \
key in f_metadata3.xmp_keys): #if key really exists in both files
if f_metadata2[key].value != f_metadata3[key].value:
f_vals.append("Yes. Data changed")
else:
f_vals.append("No")
else:
f_vals.append("key missing")
return f_vals
def whichParser(p_file_1, p_file_2):
# prints value in file2 using all potential parsing methods
f_metadata1 = pyexiv2.ImageMetadata(p_file_1)
f_metadata1.read()
f_metadata2 = pyexiv2.ImageMetadata(p_file_2)
f_metadata2.read()
f_newkeys = newKeys(p_file_1, p_file_2)
f_vals = []
for key in f_newkeys:
if key == 'Exif.Photo.0xea1c' or key == 'Exif.Image.0xea1c': #these values are too long and worthless
f_vals.append("useless")
elif key == 'Xmp.xmpMM.InstanceID' or key == 'Exif.Image.ExifTag': # these values are also useless
f_vals.append("useless")
elif key == 'Xmp.xmp.CreateDate' or key == 'Xmp.MicrosoftPhoto.DateAcquired':
f_vals.append("???")
elif key=='Exif.Image.XPComment' or \
key=='Exif.Image.XPSubject' or \
key=='Exif.Image.XPTitle' or \
key=='Exif.Image.XPKeywords' or \
key=='Exif.Image.XPAuthor':
f_vals.append(
"MetadataManager.raw_to_cleanStr(f_metadata2[key].value)")
elif key == key == 'Exif.Image.XMLPacket':
f_vals.append(
"pyexiv2.utils.undefined_to_string(f_metadata2[key].value)")
elif key=='Xmp.dc.description' or \
key=='Xmp.dc.title':
f_vals.append("f_metadata2[key].value['x-default']")
else:
f_vals.append("f_metadata2[key].value")
return f_vals
def shrinkIfNeededByPIL(path, maxDimension):
if imageMaxDimensionByPIL(path) > maxDimension:
print "-> shrinking " + path
imagePath = getTempPath(path)
img = Image.open(path)
(w, h) = img.size
if (w > h):
img2 = img.resize((maxDimension, (h * maxDimension) / w),
Image.ANTIALIAS)
else:
img2 = img.resize(((w * maxDimension) / h, maxDimension),
Image.ANTIALIAS)
img2.save(imagePath, 'JPEG', quality=99)
# now copy EXIF data from original to new
if HAS_PYEXIV2:
# Method 1: use PYEXIV2
src_image = pyexiv2.ImageMetadata(path)
src_image.read()
dst_image = pyexiv2.ImageMetadata(imagePath)
dst_image.read()
src_image.copy(dst_image, exif=True)
# overwrite image size based on new image
dst_image["Exif.Photo.PixelXDimension"] = img2.size[0]
dst_image["Exif.Photo.PixelYDimension"] = img2.size[1]
dst_image.write()
elif HAS_EXIF:
# Method 2: use EXIFTOOL
subprocess.call(
[exifTool, "-q", "-q", "-tagsfromfile", path, imagePath])
return imagePath
return path
def read_metadata_temp(filename):
try:
image = pyexiv2.ImageMetadata(filename)
image.read()
temp = None
except (IOError, UnicodeDecodeError):
temp = system.TempFile(suffix=os.path.splitext(filename)[-1])
shutil.copy2(filename, temp.path)
image = pyexiv2.ImageMetadata(temp.path)
image.read()
return image, temp
def match_metadata(image1_path, image2_path):
"""Compare images metadata"""
try:
import pyexiv2
image1 = pyexiv2.ImageMetadata(image1_path)
image1.read()
image2 = pyexiv2.ImageMetadata(image2_path)
image2.read()
metadata1 = sorted([(key, image1[key].value) for key in image1.exif_keys])
metadata2 = sorted([(key, image2[key].value) for key in image2.exif_keys])
return metadata1 == metadata2
except IOError:
return True
def copyMetadata(imgSource, imgDest):
#Copies over all metadata from one image to another
metaSource = pyexiv2.ImageMetadata(imgSource)
metaSource.read()
metaDest = pyexiv2.ImageMetadata(imgDest)
metaDest.read()
metaSource.copy(metaDest, comment=False)
metaDest.write()
return
def copy(im1, im2):
"""
Copies metadata from im1 to im2
:param im1: string containing image1 filename
:param im2: string containing image2 filename
"""
meta1 = pyexiv2.ImageMetadata(im1)
meta2 = pyexiv2.ImageMetadata(im2)
meta1.read()
meta2.read()
meta1.copy(meta2)
meta2.write(preserve_timestamps=True)
def move_date_taken(sql, photoids, dtfix, giventime):
if not sql is None:
logging.debug('Getting photo ids from database.')
photoids = get_int_list_from_database(sql)
if not isinstance(photoids, list):
photoids = photoids.split(',')
photoids = [int(i) for i in photoids]
setidtoset, photoidtophoto = get_local_sets_and_photos()
# Ensure that all photos have been loaded by constructing a dictionary.
photoidtolocalphoto = dict([[id, os.path.join(photorootdir, photoidtophoto[id][0][0], photoidtophoto[id][0][1])] for id in photoids])
datekeys = ['Exif.Photo.DateTimeOriginal', 'Exif.Photo.DateTimeDigitized']
photoidtodatetime = dict()
for id in photoidtolocalphoto:
metadata = pyexiv2.ImageMetadata(photoidtolocalphoto[id])
metadata.read()
for datekey in datekeys:
if datekey in metadata.exif_keys:
dt = metadata[datekey].value
if id not in photoidtodatetime:
photoidtodatetime[id] = dt
elif dt != photoidtodatetime[id]:
raise Exception('Different dates in photo.')
if id not in photoidtodatetime:
if giventime is not None:
photoidtodatetime[id] = giventime
else:
raise 'No take date found from photo'
for id in photoidtolocalphoto:
logging.debug('Changing taken dates of photo %s %s.' % (id, photoidtolocalphoto[id]))
metadata = pyexiv2.ImageMetadata(photoidtolocalphoto[id])
metadata.read()
dt = photoidtodatetime[id]
if giventime is None:
dt = dt + dtfix
for datekey in datekeys:
if datekey in metadata.exif_keys:
metadata[datekey].value = dt
else:
metadata[datekey] = pyexiv2.ExifTag(datekey, dt)
metadata.write()
for id in photoidtolocalphoto:
logging.debug('Replacing photo %s ''%s''.' % (id, photoidtolocalphoto[id]))
flickr_api.Upload.replace(photo_id = id, async = False, photo_file = photoidtolocalphoto[id])
def copy_image_metadata(source_file, dest_file):
source_metadata = pyexiv2.ImageMetadata(source_file)
source_metadata.read()
dest_metadata = pyexiv2.ImageMetadata(dest_file)
dest_metadata.read()
for key in source_metadata.exif_keys:
tag = source_metadata[key]
try:
dest_metadata[key] = pyexiv2.ExifTag(key, tag.value)
except:
pass
dest_metadata.write()
def get_exif_data(photo):
"""
NOTE: these attributes are not escaped
"""
try:
photo_exif = pyexiv2.ImageMetadata(photo)
photo_exif.read()
except Exception:
raise
yield ('mime:exif', photo_exif.mime_type)
yield ('width', photo_exif.dimensions[0])
yield ('height', photo_exif.dimensions[1])
#yield ('dimensions', photo_exif.dimensions)
yield ('comment', photo_exif.comment)
if not photo_exif.keys():
yield ('hasExif', False)
yield ('a', 'Image')
return
else:
yield ('hasExif', True)
yield ('a', 'Photo')
for (k, v) in photo_exif.iteritems():
if 'date' in k.lower():
yield (k, v.value.isoformat())
else:
yield (k, v.raw_value)
def __openFile(self):
try:
self.metaData = pyexiv2.ImageMetadata(self.pathFile)
self.__extractMetadata()
except:
self.metaDictionary["Error"] = "Isn't JPG File"
def set_gps_location(self, file_name, lat, lng):
"""Adds GPS position as EXIF metadata
Keyword arguments:
file_name -- image file
lat -- latitude (as float)
lng -- longitude (as float)
"""
lat_deg = self.to_deg(lat, ["S", "N"])
lng_deg = self.to_deg(lng, ["W", "E"])
print (lat_deg)
print (lng_deg)
# convert decimal coordinates into degrees, munutes and seconds
exiv_lat = (pyexiv2.Rational(lat_deg[0]*60+lat_deg[1],60),pyexiv2.Rational(lat_deg[2]*100,6000), pyexiv2.Rational(0, 1))
exiv_lng = (pyexiv2.Rational(lng_deg[0]*60+lng_deg[1],60),pyexiv2.Rational(lng_deg[2]*100,6000), pyexiv2.Rational(0, 1))
exiv_image = pyexiv2.ImageMetadata("{}/{}".format(self.download_dir, file_name))
exiv_image.read()
exif_keys = exiv_image.exif_keys
exiv_image["Exif.GPSInfo.GPSLatitude"] = exiv_lat
exiv_image["Exif.GPSInfo.GPSLatitudeRef"] = lat_deg[3]
exiv_image["Exif.GPSInfo.GPSLongitude"] = exiv_lng
exiv_image["Exif.GPSInfo.GPSLongitudeRef"] = lng_deg[3]
exiv_image["Exif.Image.GPSTag"] = 654
exiv_image["Exif.GPSInfo.GPSMapDatum"] = "WGS-84"
exiv_image["Exif.GPSInfo.GPSVersionID"] = '2 0 0 0'
exiv_image.write()
def load_images(self):
files = []
self.pictures = []
path = self.image_dir
for file in os.listdir(path):
if fnmatch.fnmatch(file, '*.jpg') or fnmatch.fnmatch(
file, '*.JPG'):
files.append(file)
files.sort()
last_trigger = 0.0
interval = 0
for f in files:
name = path + "/" + f
print name
exif = pyexiv2.ImageMetadata(name)
exif.read()
#print exif.exif_keys
strdate, strtime = str(exif['Exif.Image.DateTime'].value).split()
year, month, day = strdate.split('-')
formated = year + "/" + month + "/" + day + " " + strtime + " UTC"
result, unixtimestr = commands.getstatusoutput('date -d "' +
formated +
'" "+%s"')
unixtime = float(unixtimestr)
# print f + ": " + strdate + ", " + strtime + ", " + unixtimestr
if last_trigger > 0.0:
interval = unixtime - last_trigger
self.pictures.append((unixtime, interval, f))
last_trigger = unixtime
print "number of images = " + str(len(self.pictures))
def EXIV2Meta(img):
'''
Return a list of tuples of all the EXIF, IPTC and XMP metadata in a file.
Usage:
from picasa3meta import exiv2meta
metaData = exiv2meta.EXIV2Meta("/path/to/file.jpg")
for key,value in metaData:
print "%s : %s"%(key,value)
Exif keys will return the human_value if possible, otherwise the raw_value.
Iptc keys will return the raw_value first, if that fails, just value
Xmp keys may be dict objects. If it is a dict, return a comma separated
list of the values. Otherwise, try the raw_value first, then just value.
'''
try:
metadata = pyexiv2.ImageMetadata(img)
metadata.read()
except:
return zip(['error'], ['%s is not an image' % img])
else:
ret = []
for K in metadata.exif_keys:
try:
ret.append(metadata[K].human_value)
except:
ret.append(metadata[K].raw_value)
for K in metadata.iptc_keys:
try:
ret.append(metadata[K].raw_value[0])
except:
ret.append(metadata[K].value[0])
for K in metadata.xmp_keys:
if type(metadata[K].raw_value) == dict:
# if the xmp key is a dict, return it as a comma separated list.
nret = ""
for KK in metadata[K].raw_value:
if len(nret) > 1:
nret = nret + ","
nret = nret + metadata[K].raw_value[KK]
ret.append(nret)
else:
try:
ret.append(metadata[K].raw_value)
except:
ret.append(metadata[K].value)
# zip the keys and values into a list of tuples and return it
return zip(metadata.exif_keys + metadata.iptc_keys + metadata.xmp_keys,
ret)
def __getitem__(self, key):
if not hasattr(self, '_metadata'):
self._metadata = pyexiv2.ImageMetadata(self._fn)
self._metadata.read()
tag = self._metadata[key]
return tag.value
def _read_iptc_tags(filename, path):
"""
method to read IPTC tags
:param filename: filename of image
:param path: path to image
:return: [{'iptc_key': iptc key, 'tags': ['tag 1', 'tag 2']}] | False
"""
try:
url = os.path.join(path, filename)
meta = pyexiv2.ImageMetadata(os.path.join(url))
meta.read()
iptc_keys = meta.iptc_keys or []
image_data = []
if iptc_keys:
for key in iptc_keys:
tag = meta[key]
image_data.append({
'iptc_key': key,
'tags': tag.raw_value or []
})
# else:
# image_data.append({'iptc_key': '', 'tags': []})
return image_data
except (IOError, KeyError, Exception) as e:
print(f'An error occurred in read_iptc_tags: {e}')
return False
def list_jpg(directory, camid=None):
""" Search for all the jpg found in a folder and all the subfolders
Return a list of list containing the camid, the complete path of the
picture (string), and its DatetimeOriginal (datetime object from the Exif header)
[['camid', '/mypath/mydirectory/mypicture.jpg', 'datetime.datetime']]
"""
file_list = []
for root, subfolders, files in os.walk(directory):
file_list += [
os.path.join(root, filename) for filename in files
if filename.lower().endswith(".jpg")
]
files = []
# get DateTimeOriginal data from the images and sort the list by timestamp
for filepath in file_list:
metadata = pyexiv2.ImageMetadata(filepath)
metadata.read()
try:
t = metadata["Exif.Photo.DateTimeOriginal"].value
# print t
# print type(t)
# s = metadata["Exif.Photo.SubSecTimeOriginal"].value
files.append([camid, filepath, t])
except KeyError, e:
# if any of the required tags are not set the image is not added to the list
print("Skipping {0}: {1}".format(filename, e))
def set_gps_location(self, file_name, lat, lng, alt):
"""Adds GPS position as EXIF metadata
Keyword arguments:
file_name -- image file
lat -- latitude (as float)
lng -- longitude (as float)
"""
lat_deg = self.to_deg(lat, ["S", "N"])
lng_deg = self.to_deg(lng, ["W", "E"])
# convert decimal coordinates into degrees, munutes and seconds
exiv_lat = (pyexiv2.Rational(lat_deg[0] * 60 + lat_deg[1], 60),
pyexiv2.Rational(lat_deg[2] * 100,
6000), pyexiv2.Rational(0, 1))
exiv_lng = (pyexiv2.Rational(lng_deg[0] * 60 + lng_deg[1], 60),
pyexiv2.Rational(lng_deg[2] * 100,
6000), pyexiv2.Rational(0, 1))
metadata = pyexiv2.ImageMetadata(file_name)
metadata.read()
## exif_keys = metadata.exif_keys
metadata["Exif.GPSInfo.GPSLatitude"] = exiv_lat
metadata["Exif.GPSInfo.GPSLatitudeRef"] = lat_deg[3]
metadata["Exif.GPSInfo.GPSLongitude"] = exiv_lng
metadata["Exif.GPSInfo.GPSLongitudeRef"] = lng_deg[3]
metadata["Exif.GPSInfo.GPSAltitude"] = pyexiv2.Rational(alt, 1)
metadata["Exif.Image.GPSTag"] = 654
metadata["Exif.GPSInfo.GPSMapDatum"] = "WGS-84"
metadata["Exif.GPSInfo.GPSVersionID"] = '2 0 0 0'
metadata.write()
def read_metadata(self):
"""
Read EXIF or XMP data from file. Convert to Python dict.
"""
# Xmp.xmp.CreateDate
# XXX: We already know file exists 'cuz we found it.
img_md = pyexiv2.ImageMetadata("{}".format(self.src_fn_fq))
img_md.read()
metadata = {}
if (self.image_type == photo_rename.IMAGE_TYPE_PNG):
metadata_keys = [md_key for md_key in img_md.xmp_keys]
else:
metadata_keys = [md_key for md_key in img_md.exif_keys]
for exifkey in metadata_keys:
tag = img_md[exifkey].raw_value
#self.logger.debug(exifkey)
#self.logger.debug("{}: {}".format(exifkey, tag))
metadata[exifkey] = tag
if (len(metadata) == 0):
raise Exception("{0} has no EXIF data.".format(self.src_fn))
return metadata
def list_images(directory):
'''
Create a list of image tuples sorted by capture timestamp.
@param directory: directory with JPEG files
@return: a list of image tuples with time, directory, lat,long...
'''
file_list = []
for root, sub_folders, files in os.walk(directory):
file_list += [
os.path.join(root, filename) for filename in files
if filename.lower().endswith(".jpg")
]
files = []
# get GPS data from the images and sort the list by timestamp
for filepath in file_list:
metadata = pyexiv2.ImageMetadata(filepath)
metadata.read()
try:
t = metadata["Exif.Photo.DateTimeOriginal"].value
lat = metadata["Exif.GPSInfo.GPSLatitude"].value
latRef = metadata["Exif.GPSInfo.GPSLatitudeRef"].value
lon = metadata["Exif.GPSInfo.GPSLongitude"].value
lonRef = metadata["Exif.GPSInfo.GPSLongitudeRef"].value
direction = metadata["Exif.GPSInfo.GPSImgDirection"].value
dmslat = DMStoDD(lat[0], lat[1], lat[2], latRef)
dmslon = DMStoDD(lon[0], lon[1], lon[2], lonRef)
files.append(
(filepath, int(float(lat[0])), int(float(lat[1])),
float(lat[2]), latRef, int(float(lon[0])), int(float(lon[1])),
float(lon[2]), lonRef, float(direction)))
except KeyError, e:
# if any of the required tags are not set the image is not added to the list
print("Skipping {0}: {1}".format(filename, e))
def image_write(image_filename, text_to_print):
# function to write date/time stamp directly on top or bottom of images.
FOREGROUND = (255, 255, 255) # rgb settings for white text foreground
text_colour = "White"
font_size = 20
# centre text and compensate for graphics text being wider
x = int((image_width / 2) - (len(text_to_print) * font_size / 4))
if image_text_bottom:
y = (image_height - 50) # show text at bottom of image
else:
y = 10 # show text at top of image
TEXT = text_to_print
font_path = '/usr/share/fonts/truetype/freefont/FreeSansBold.ttf'
font = ImageFont.truetype(font_path, font_size, encoding='unic')
text = TEXT.decode('utf-8')
# Read exif data since ImageDraw does not save this metadata
metadata = pyexiv2.ImageMetadata(image_filename)
metadata.read()
img = Image.open(image_filename)
draw = ImageDraw.Draw(img)
# draw.text((x, y),"Sample Text",(r,g,b))
draw.text((x, y), text, FOREGROUND, font=font)
img.save(image_filename)
metadata.write() # Write previously saved exif data to image file
msgStr = " Image Saved - " + text_to_print
show_message("image_write ", msgStr)
return
def copy_photos(filename: str, source_folder: str, dest_folder: str):
try:
metadata = pyexiv2.ImageMetadata(source_folder + filename)
metadata.read()
tag = metadata['Exif.Image.DateTime']
creation_date = tag.value.date()
del metadata
del tag
folder_name = str(creation_date)
new_directory = dest_folder + folder_name + '/'
try:
if not os.path.exists(new_directory):
os.makedirs(new_directory)
else:
logger.info('folder ' + new_directory + ' already exists!')
except:
logger.info('folder ' + new_directory + ' could not be created!')
try:
if not os.path.isfile(new_directory + filename):
shutil.copy2(source_folder + filename, new_directory)
else:
logger.info('file ' + filename + ' already exists')
except:
logger.info('file ' + filename + ' could not be moved')
except:
logger.info('file ' + filename + ' could not be copied')
