def set_location(self, latitude, longitude):
"""Set latitude and longitude for a photo.
:param float latitude: Latitude of the file
:param float longitude: Longitude of the file
:returns: bool
"""
if (latitude is None or longitude is None):
return False
source = self.source
exif_metadata = pyexiv2.ImageMetadata(source)
exif_metadata.read()
exif_metadata['Exif.GPSInfo.GPSLatitude'] = geolocation.decimal_to_dms(
latitude, False) # noqa
exif_metadata['Exif.GPSInfo.GPSLatitudeRef'] = pyexiv2.ExifTag(
'Exif.GPSInfo.GPSLatitudeRef',
'N' if latitude >= 0 else 'S') # noqa
exif_metadata[
'Exif.GPSInfo.GPSLongitude'] = geolocation.decimal_to_dms(
longitude, False) # noqa
exif_metadata['Exif.GPSInfo.GPSLongitudeRef'] = pyexiv2.ExifTag(
'Exif.GPSInfo.GPSLongitudeRef',
'E' if longitude >= 0 else 'W') # noqa
exif_metadata.write()
self.reset_cache()
return True
def write_geo_tag(img_path, lat, lon, alt_abs, hdg=None, roll=None, pitch=None, yaw=None):
"""Writes geotags to an image
Arguments:
img_path {str} -- Path to image
lat {float} -- latitude, in decimal degrees
lon {float} -- longitude, in decimal degrees
alt_abs {float} -- absolute altitude, in metres
Keyword Arguments:
hdg {float} -- Heading, in degrees (default: {None})
roll {float} -- Roll, in degrees (default: {None})
pitch {float} -- Pitch, in degrees (default: {None})
yaw {float} -- Yaw, in degrees (default: {None})
Raises:
ValueError -- if image is not a JPEG or MPO
"""
# Only JPEG and MPO have metadata
img = Image.open(img_path)
if not (img.format == 'JPEG' or img.format == "MPO"):
raise ValueError('Image is not a JPEG or MPO')
img.close()
metadata = pyexiv2.ImageMetadata(img_path)
metadata.read()
# Add standard Exif Tags
tags = ['Exif.GPSInfo.GPSLatitude', 'Exif.GPSInfo.GPSLatitudeRef',
'Exif.GPSInfo.GPSLongitude', 'Exif.GPSInfo.GPSLongitudeRef',
'Exif.GPSInfo.GPSAltitude', 'Exif.GPSInfo.GPSAltitudeRef']
values = [coord_dec_to_dms(lat), _get_lat_ref(lat), coord_dec_to_dms(lon),
_get_lon_ref(lon), Fraction(int(alt_abs*1e7), int(1e7)),
_get_alt_ref(alt_abs)]
for (tag, value) in zip(tags, values):
metadata[tag] = pyexiv2.ExifTag(tag, value)
if hdg is not None:
tag = 'Exif.GPSInfo.GPSImgDirection'
metadata[tag] = pyexiv2.ExifTag(tag, Fraction(int(_check_angle(hdg) * 100), 100))
# Add roll, pitch, yaw as custom Xmp tags
tags = ['Xmp.Attitude.Roll', 'Xmp.Attitude.Pitch', 'Xmp.Attitude.Yaw']
values = [roll, pitch, yaw]
attitudes = [roll, pitch, yaw]
for (attitude, tag, value) in zip(attitudes, tags, values):
if attitude is not None:
metadata[tag] = pyexiv2.XmpTag(tag, str(_check_angle(value)))
metadata.write()
def license_image(image_path: str, lincense_type: str, author: str) -> bool:
try:
metadata = pyexiv2.ImageMetadata(image_path)
metadata.read()
copyright_key = 'Exif.Image.Copyright'
author_key = 'Exif.Image.Artist'
value = LICENSE_TYPES.get(lincense_type)
if value:
metadata[copyright_key] = pyexiv2.ExifTag(copyright_key, value)
metadata[author_key] = pyexiv2.ExifTag(author_key, author)
metadata.write()
return True
except Exception as ex:
print(ex.args)
return False
def writeMeta(self, pNewValue):
meta = self._getAllMeta()
self.exifKeys = self._getAllMetaKeys(meta)
if self._getExifKey_TimeCode() in self.exifKeys:
meta.writable = os.access(self.imagePath, os.W_OK)
meta[self._getExifKey_TimeCode()] = pyexiv2.ExifTag(self._getExifKey_TimeCode(), pNewValue)
meta.write()
def write_position(image_file, pos):
metadata = pyexiv2.ImageMetadata(image_file)
metadata.read()
key = 'Exif.Photo.UserComment'
value = 'position: %d,%d' % (pos[0], pos[1])
metadata[key] = pyexiv2.ExifTag(key, value)
metadata.write()
def put(hostname, id, flag):
try:
response = os.system("ping -c 1 " + hostname + " > /dev/null 2>&1") # -t 3 нужно ли?
if response != 0:
print("Host unreachable")
return 104
mail = str(id) + "@yandex.ru"
password = hashlib.md5(str(id) + "verysibirctfhardhardpass")
r = requests.post('http://' + hostname + ":" + str(PORT)+ "/login",
data={ 'mail' : mail, 'password': password.hexdigest() }
);
cookie = {'connect.sid': r.cookies['connect.sid']}
# Attach tags in photo
r = requests.get('http://api-fotki.yandex.ru/api/top/')
urls = re.findall(r'href="([^"]*_XL)"', r.text)
url = urls[random.randint(1,len(urls))]
page = requests.get(url)
with open('/tmp/image.jpg', 'wb') as test:
test.write(page.content)
metadata = pyexiv2.ImageMetadata('/tmp/image.jpg')
metadata.read()
key = 'Exif.Image.Artist'
metadata[key] = pyexiv2.ExifTag(key, flag)
metadata.write()
data = { 'descr': '', 'geo': flag }
files = { 'photo': ('112.jpg',
open('/tmp/image.jpg', 'r'),
'image/jpeg'
) }
r = requests.post('http://' + hostname + ":" + str(PORT)+ "/add",
cookies=cookie,
data=data,
files=files
);
if "added" not in r.text:
print "Can't add photo"
return 103
return 101
except:
print("Error happend")
return 102
def __write_md5_into_photo_exif(self):
if self.type == "photo":
try:
metadata = pyexiv2.ImageMetadata(self.fullpath)
metadata.read()
# write the md5 into UserComment of exif
if self.__is_md5(self.md5):
metadata['Exif.Photo.UserComment'] = pyexiv2.ExifTag(
'Exif.Photo.UserComment', self.md5)
metadata.write()
except:
pass
def convert(self):
in_datasets = self._find_in_datasets()
# map input structure to output
out_pr = sly.ProjectStructure(self.settings['res_names']['project'])
for ds_name, ds_path in in_datasets:
img_fnames = sly.ImportImgLister.list_images(ds_path)
for name_with_ext in img_fnames:
img_name, img_ext = osp.splitext(name_with_ext)
src_img_path = osp.join(ds_path, name_with_ext)
dt = {
'src_img_path': src_img_path,
'image_ext': img_ext,
}
out_pr.add_item(ds_name, img_name, dt)
logger.info(
'Found source dataset with raw images: "{}", {} sample(s).'.
format(ds_name, len(img_fnames)))
out_pr_fs = sly.ProjectFS(self.out_dir, out_pr)
out_pr_fs.make_dirs()
res_meta = sly.ProjectMeta() # empty
res_meta.to_dir(out_pr_fs.project_path)
progress = sly.progress_counter_import(out_pr.name, out_pr.image_cnt)
for sample_info in out_pr_fs:
sample_data = sample_info.ia_data
src_img_path = sample_data['src_img_path']
sly.copy_file(src_img_path, sample_info.img_path) # img is ready
image = Image.open(sample_info.img_path)
exif_data = pyexiv2.metadata.ImageMetadata(sample_info.img_path)
exif_data.read()
if exif_data.get_orientation() != 1:
logger.debug('Image with flip/rot EXIF',
extra={
'orientation': exif_data.get_orientation(),
'image_path': sample_info.img_path
})
image = sly.image_transpose_exif(image)
image.save(sample_info.img_path)
exif_data['Exif.Image.Orientation'] = pyexiv2.ExifTag(
'Exif.Image.Orientation', 1)
exif_data.modified = True
exif_data.write()
imsize_wh = image.size
ann = sly.Annotation.new_with_objects(imsize_wh, [])
sly.json_dump(ann.pack(), sample_info.ann_path) # ann is ready
progress.iter_done_report()
def set_position(self, coords):
lat, lon = coords
frac_lat = Image._dec_to_sex(abs(float(lat)))
sign_lat = 'S' if lat < 0 else 'N'
frac_lon = Image._dec_to_sex(abs(float(lon)))
sign_lon = 'W' if lon < 0 else 'E'
k = 'Exif.GPSInfo.GPSLatitudeRef'
self._metadata[k] = pyexiv2.ExifTag(k, sign_lat)
k = 'Exif.GPSInfo.GPSLatitude'
self._metadata[k] = pyexiv2.ExifTag(k, frac_lat)
k = 'Exif.GPSInfo.GPSLongitudeRef'
self._metadata[k] = pyexiv2.ExifTag(k, sign_lon)
k = 'Exif.GPSInfo.GPSLongitude'
self._metadata[k] = pyexiv2.ExifTag(k, frac_lon)
# Commit
self._metadata.write()
print 'Position of {} is now {} - {}'.format( \
self._fullpath, coords[0], coords[1])
def set_datetime(self, new_datetime):
"""
Update EXIF/XMP tags as needed and write metadata.
"""
# TODO: Timezone?
xmp_datetime = new_datetime.strftime('%Y-%m-%dT%H:%M:%S')
exif_datetime = new_datetime.strftime('%Y:%m:%d %H:%M:%S')
logger.debug("XMP: {} : EXIF: {}".format(xmp_datetime, exif_datetime))
# Shotwell will use Xmp.xmp.CreateDate if set, so it must be updated.
if 'Xmp.xmp.CreateDate' in self['metadata'].keys():
self.img_md['Xmp.xmp.CreateDate'] = pyexiv2.XmpTag(
'Xmp.xmp.CreateDate', new_datetime)
if 'Exif.Photo.DateTimeOriginal' in self['metadata'].keys():
self.img_md['Exif.Photo.DateTimeOriginal'] = pyexiv2.ExifTag(
'Exif.Photo.DateTimeOriginal', new_datetime)
self.img_md['Exif.Image.DateTime'] = pyexiv2.ExifTag(
'Exif.Image.DateTime', new_datetime)
try:
self.img_md.write()
except Exception as e:
logger.error(e)
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 image_cap():
cap = cv2.VideoCapture(0) #zero is first webcam attatched
filename = '' #redefines the filename as an open string
if cap.isOpened(): #checks if webcam is up and running
ret, frame = cap.read() #capture single frame from the webcam to read
else:
ret = False
if ret:
'''GPS Exif Tag Description: A pointer to the GPS Info IFD. The interoperability
structure of the GPS Info IFD, like that of Exif IFD, has no image data
Blah
Need to install pyexiv package
pyexiv2 is a module that allows your python scripts to read and write data
embedded in image files
'''
date = datetime.datetime.utcnow().strftime(
'%Y-%m-%d-%H-%M-%S') #sets date to be current date/time in UTC
filename = 'GrainImage_%s.png' % date #writes filename with UTC date & time
path = "/home/pi/Grover_control_scripts/" # path file name to save to new directory on pi
cv2.imwrite(
os.path.join(path, filename), frame
) #writes the frame to the designated path with the desired filename
#print(filename) #sanity check to make sure filename is storing properly
metadata = pyexiv2.ImageMetadata(
'/home/pi/Grover_control_scripts/' +
filename) #calls for the metadata off of the image
metadata.read() #reads the metadata
metadata.modified = True #checks to see if the metadata can be modified
metadata.writable = os.access(
'/home/pi/Grover_control_scripts/' + filename, os.W_OK
) #makes sure the file in the defined path is readable for metadata
key = 'Exif.Image.ImageDescription' #reference for saving the gps data in the exif tag
lat = (vehicle.location.global_frame.lat
) #sets lat to be the rover's latitude from dronekit
lon = (vehicle.location.global_frame.lon
) #sets Lon to be the rover's Longitude from dronekit
alt = (vehicle.location.global_frame.alt
) #sets Alt to be the rover's Altitude from dronekit
value = '(%s, %s, %s)' % (
lat, lon, alt
) #takes Lat, Lon, and Alt and sets it to be the exif tag value
metadata[key] = pyexiv2.ExifTag(
key, value) #sets the key and value to the exif tag
metadata.write() #writes the new tag to the metadata
cap.release() #relases the camera function
def copy_metadata(self, src_file, dest_file):
self.log('Copying exif data.', 2)
#Get Source metadata
srcmeta = pyexiv2.ImageMetadata(src_file)
srcmeta.read()
#Get Destination metadata
destmeta = pyexiv2.ImageMetadata(dest_file)
destmeta.read()
#Fix Orientation
key = 'Exif.Image.Orientation'
value = 1
srcmeta[key] = pyexiv2.ExifTag(key, value)
#Copy it
srcmeta.copy(destmeta)
destmeta.write()
def setProperty(type, property, photo, folderPath):
metadata = pyexiv2.ImageMetadata(photo)
metadata.read()
metadata.modified = True
metadata.writable = os.access(photo, os.W_OK)
if type == "comment":
key = 'Exif.Photo.UserComment'
elif type == "people":
key = 'Exif.Image.ImageID'
elif type == "location":
key = 'Exif.Image.SecurityClassification'
elif type == "tags":
key = 'Exif.Photo.CameraOwnerName'
elif type == "favorite":
key = 'Exif.Photo.BodySerialNumber'
metadata[key] = pyexiv2.ExifTag(key, property)
metadata.write()
if (os.path.exists(folderPath + "search.json")):
editJson(photo, folderPath, type, property)
def main():
cap = cv2.VideoCapture(0) #zero is first webcam attatched
filename = ''
if cap.isOpened(): #checks if webcam is up and running
ret, frame = cap.read() #capture single frame from the webcam to read
#cv2.imshow('frame',frame)
else:
ret = False
if ret:
'''GPS Exif Tag Description: A pointer to the GPS Info IFD. The interoperability
structure of the GPS Info IFD, like that of Exif IFD, has no image data
Need to install pyexiv package
pyexiv2 is a module that allows your python scripts to read and write data
embedded in image files
'''
#%m_%d_%Y - month_day_year
#filename = "GrainImage_.png" #+ str(now) + ".png"
filename = 'GrainImage_%s.png' % datetime.datetime.utcnow().strftime(
'%Y-%m-%d-%H-%M-%S') #writes filename with UTC date & time
#path = 'C:/Users/Courtney/Documents/Github/Grover_control_scripts'
#cv2.imwrite(os.path.join(path, filename), frame)
print(
filename) #sanity check to make sure filename is storing properly
cv2.imwrite(filename, frame) #writes the frame to an image file
#filename+=new_filename
metadata = pyexiv2.ImageMetadata(
filename) #calls for the metadata off of the image
metadata.read() #reads the metadata
key = 'Exif.Image.GPSTag' #reference for saving the gps data in the exif tag
alue = [
int(vehicle.location.global_frame.lat),
int(vehicle.location.global_frame.lon),
int(vehicle.location.global_frame.alt)
] #takes the gps data from dronekit
metadata[key] = pyexiv2.ExifTag(
key, value) #writes the key and value to the exif tag
cap.release() #relases the camera function
def set_date_taken(self, time):
"""Set the date/time a photo was taken.
:param datetime time: datetime object of when the photo was taken
:returns: bool
"""
if (time is None):
return False
source = self.source
exif_metadata = pyexiv2.ImageMetadata(source)
exif_metadata.read()
# Writing exif with pyexiv2 differs if the key already exists so we
# handle both cases here.
for key in ['Exif.Photo.DateTimeOriginal', 'Exif.Image.DateTime']:
if (key in exif_metadata):
exif_metadata[key].value = time
else:
exif_metadata[key] = pyexiv2.ExifTag(key, time)
exif_metadata.write()
return True
def __init__(self, conf, photoname, album):
# Parameters storage
self.conf = conf
self.originalname = photoname
self.originalpath = album['path']
self.albumid = album['id']
self.albumname = album['name']
# if star in file name, photo is starred
if ('star' in self.originalname) or ('cover' in self.originalname):
self.star = 1
# Compute Photo ID
self.id = str(int(time.time()))
# not precise enough
length = len(self.id)
if length < 14:
missing_char = 14 - length
r = random.random()
r = str(r)
# last missing_char char
filler = r[-missing_char:]
self.id = self.id + filler
assert len(self.id) == 14, "id {} is not 14 character long: {}".format(
self.id, str(len(self.id)))
# Compute file storage url
m = hashlib.md5()
m.update(self.id.encode('utf-8'))
crypted = m.hexdigest()
ext = os.path.splitext(photoname)[1]
self.url = ''.join([crypted, ext]).lower()
self.thumbUrl = self.url
# src and dest fullpath
self.srcfullpath = os.path.join(self.originalpath, self.originalname)
self.destfullpath = os.path.join(self.conf["lycheepath"], "uploads",
"big", self.url)
# Generate file checksum
self.__generateHash()
# thumbnails already in place (see makeThumbnail)
# Auto file some properties
self.type = mimetypes.guess_type(self.originalname, False)[0]
self.size = decimal.Decimal(os.path.getsize(
self.srcfullpath)).quantize(decimal.Decimal('.01'),
rounding=decimal.ROUND_05UP)
self.size = str(self.size / 1024) + " KB"
# Default date
takedate = datetime.date.today().isoformat()
taketime = datetime.datetime.now().strftime('%H:%M:%S')
self._str_datetime = takedate + " " + taketime
# Exif Data Parsing
self.exif = ExifData()
try:
metadata = pyexiv2.ImageMetadata(self.srcfullpath)
metadata.read()
if "Exif.Photo.PixelXDimension" in metadata.exif_keys:
w = metadata['Exif.Photo.PixelXDimension'].value
h = metadata['Exif.Photo.PixelYDimension'].value
else:
img = Image.open(self.srcfullpath)
w, h = img.size
metadata['Exif.Photo.PixelXDimension'] = pyexiv2.ExifTag(
'Exif.Photo.PixelXDimension', w)
metadata['Exif.Photo.PixelYDimension'] = pyexiv2.ExifTag(
'Exif.Photo.PixelYDimension', h)
metadata.write()
self.width = float(w)
self.height = float(h)
# exifinfo = img.info['exif']
# logger.debug(exifinfo)
if "Exif.Image.Orientation" in metadata.exif_keys:
self.exif.orientation = metadata[
'Exif.Image.Orientation'].value
if "Exif.Image.Make" in metadata.exif_keys:
self.exif.make = metadata['Exif.Image.Make'].value
if "Exif.Photo.MaxApertureValue" in metadata.exif_keys:
aperture = math.sqrt(
2)**metadata['Exif.Photo.MaxApertureValue'].value
try:
aperture = decimal.Decimal(aperture).quantize(
decimal.Decimal('.1'), rounding=decimal.ROUND_05UP)
except Exception as e:
logger.debug(
"aperture only a few digit after comma: {}".format(
aperture))
logger.debug(e)
self.exif.aperture = aperture
if "Exif.Photo.FocalLength" in metadata.exif_keys:
focal = metadata['Exif.Photo.FocalLength'].value * 1.0
self.exif.focal = decimal.Decimal(focal).quantize(
decimal.Decimal('0.1'), rounding=decimal.ROUND_05UP)
if "Exif.Photo.ISOSpeedRatings" in metadata.exif_keys:
self.exif.iso = metadata['Exif.Photo.ISOSpeedRatings'].value
if "Exif.Image.Model" in metadata.exif_keys:
self.exif.model = metadata['Exif.Image.Model'].value
if "Exif.Photo.ExposureTime" in metadata.exif_keys:
self.exif.exposure = metadata['Exif.Photo.ExposureTime'].value
if "Exif.Photo.ExposureTime" in metadata.exif_keys:
s = metadata['Exif.Photo.ExposureTime'].value
numer = s.numerator
denom = s.denominator
if denom / numer >= 1:
s = Fraction(
int(
decimal.Decimal(
s.numerator / s.numerator).quantize(
decimal.Decimal('1'),
rounding=decimal.ROUND_HALF_EVEN)),
int(
decimal.Decimal(
s.denominator / s.numerator).quantize(
decimal.Decimal('1'),
rounding=decimal.ROUND_HALF_EVEN)))
else:
s *= 1.0
s = int(s)
self.exif.shutter = str(s)
if "Exif.Photo.DateTimeOriginal" in metadata.exif_keys:
try:
self.exif.takedate = metadata[
'Exif.Photo.DateTimeOriginal'].raw_value.split(" ")[0]
except Exception as e:
logger.warn('invalid takedate: ' + str(
metadata['Exif.Photo.DateTimeOriginal'].raw_value) +
' for ' + self.srcfullpath)
if "Exif.Photo.DateTimeOriginal" in metadata.exif_keys:
try:
self.exif.taketime = metadata[
'Exif.Photo.DateTimeOriginal'].raw_value.split(" ")[1]
except Exception as e:
logger.warn('invalid taketime: ' + str(
metadata['Exif.Photo.DateTimeOriginal'].raw_value) +
' for ' + self.srcfullpath)
if "Exif.Photo.DateTime" in metadata.exif_keys and self.exif.takedate is None:
try:
self.exif.takedate = metadata[
'Exif.Photo.DateTime'].raw_value.split(" ")[0]
except Exception as e:
logger.warn(
'DT invalid takedate: ' +
str(metadata['Exif.Photo.DateTime'].raw_value) +
' for ' + self.srcfullpath)
if "Exif.Photo.DateTime" in metadata.exif_keys and self.exif.taketime is None:
try:
self.exif.taketime = metadata[
'Exif.Photo.DateTime'].raw_value.split(" ")[1]
except Exception as e:
logger.warn(
'DT invalid taketime: ' +
str(metadata['Exif.Photo.DateTime'].raw_value) +
' for ' + self.srcfullpath)
if "Iptc.Application2.ObjectName" in metadata.iptc_keys:
self.title = metadata[
'Iptc.Application2.ObjectName'].raw_value or self.originalname
if "Xmp.xmp.Rating" in metadata.xmp_keys:
self.star = int(metadata['Xmp.xmp.Rating'].raw_value) or 0
if "Iptc.Application2.Caption" in metadata.iptc_keys:
self.description = metadata[
'Iptc.Application2.Caption'].raw_value or ""
if "Iptc.Application2.Keywords" in metadata.iptc_keys:
tags = metadata['Iptc.Application2.Keywords'].value or {""}
self.tags = ','.join(tags)
# compute shutter speed
if not (self.exif.shutter) and self.exif.exposure:
if self.exif.exposure < 1:
e = str(Fraction(self.exif.exposure).limit_denominator())
else:
e = decimal.Decimal(self.exif.exposure).quantize(
decimal.Decimal('0.01'), rounding=decimal.ROUND_05UP)
self.exif.shutter = e
if self.exif.shutter:
self.exif.shutter = str(self.exif.shutter) + " s"
else:
self.exif.shutter = ""
if self.exif.exposure:
self.exif.exposure = str(self.exif.exposure) + " s"
else:
self.exif.exposure = ""
if self.exif.focal:
self.exif.focal = str(self.exif.focal) + " mm"
else:
self.exif.focal = ""
if self.exif.aperture:
self.exif.aperture = 'F' + str(self.exif.aperture)
else:
self.exif.aperture = ""
# compute takedate / taketime
if self.exif.takedate:
takedate = self.exif.takedate.replace(':', '-')
self.exif.takedate = takedate
taketime = '00:00:00'
if self.exif.taketime:
taketime = self.exif.taketime
# add mesurement units
self._str_datetime = takedate + " " + taketime
except IOError as e:
logger.debug('ioerror (corrupted ?): ' + self.srcfullpath)
raise e
def utm_to_latlon(self, _file, _photo, idx):
gcp = self.gcps[idx]
kwargs = {
'epsg': self.epsg,
'file': _file,
'x': gcp.x + self.utm_east_offset,
'y': gcp.y + self.utm_north_offset,
'z': gcp.z
}
latlon = system.run_and_return(
'echo {x} {y} {z} '.format(**kwargs),
'gdaltransform -s_srs \"EPSG:{epsg}\" '
'-t_srs \"EPSG:4326\"'.format(**kwargs)).split()
# Example: 83d18'16.285"W
# Example: 41d2'11.789"N
# Example: 0.998
if len(latlon) == 3:
lon_str, lat_str, alt_str = latlon
elif len(latlon) == 2:
lon_str, lat_str = latlon
alt_str = ''
else:
log.ODM_ERROR('Something went wrong %s' % latlon)
lat_frac = self.coord_to_fractions(latlon[1], ['N', 'S'])
lon_frac = self.coord_to_fractions(latlon[0], ['E', 'W'])
# read image metadata
metadata = pyexiv2.ImageMetadata(_photo.path_file)
metadata.read()
# set values
# GPS latitude
key = 'Exif.GPSInfo.GPSLatitude'
value = lat_frac[0].split(' ')
log.ODM_DEBUG('lat_frac: %s %s %s' % (value[0], value[1], value[2]))
metadata[key] = pyexiv2.ExifTag(
key, [Fraction(value[0]),
Fraction(value[1]),
Fraction(value[2])])
key = 'Exif.GPSInfo.GPSLatitudeRef'
value = lat_frac[1]
metadata[key] = pyexiv2.ExifTag(key, value)
# GPS longitude
key = 'Exif.GPSInfo.GPSLongitude'
value = lon_frac[0].split(' ')
metadata[key] = pyexiv2.ExifTag(
key, [Fraction(value[0]),
Fraction(value[1]),
Fraction(value[2])])
key = 'Exif.GPSInfo.GPSLongitudeRef'
value = lon_frac[1]
metadata[key] = pyexiv2.ExifTag(key, value)
# GPS altitude
altitude = abs(int(float(latlon[2]) * 100))
key = 'Exif.GPSInfo.GPSAltitude'
value = Fraction(altitude, 1)
metadata[key] = pyexiv2.ExifTag(key, value)
if latlon[2] >= 0:
altref = '0'
else:
altref = '1'
key = 'Exif.GPSInfo.GPSAltitudeRef'
metadata[key] = pyexiv2.ExifTag(key, altref)
# write values
metadata.write()
def setDatetimeExif(filepath, timestamp):
metadata = pyexiv2.ImageMetadata(filepath)
metadata.read()
key = 'Exif.Photo.DateTimeOriginal'
metadata[key] = pyexiv2.ExifTag(key, timestamp)
metadata.write()
def EverythingUseageCheck(p_fileEntry, p_testfilelist, f_outpath=g_outpath):
#the file you load better have all this metadata in it.
f_picID = p_testfilelist[p_fileEntry]
f_filename = getGoogleDrivePicture(f_picID, f_outpath)
f_metadata = pyexiv2.ImageMetadata(f_filename)
f_metadata.read()
print(f_metadata.exif_keys)
#-------------Title--------------------------------------
key1 = 'Exif.Image.XPTitle'
f_keywords1 = f_metadata[key1]
f_dirtyString1 = pyexiv2.utils.undefined_to_string(f_keywords1.value)
print("titleUseageCheck() f_dirtyString1: \t\t", f_dirtyString1)
f_cleanThing1 = MetadataManagerL0.dirtyStr2cleanStr(f_dirtyString1)
print("titleUseageCheck() Title\t\t", f_cleanThing1)
# -------------Tags--------------------------------------
key2 = 'Exif.Image.XPTitle'
f_keywords2 = f_metadata[key2]
f_dirtyString2 = pyexiv2.utils.undefined_to_string(f_keywords2.value)
print("titleUseageCheck() f_dirtyString2: \t\t", f_dirtyString2)
f_cleanThing2 = MetadataManagerL0.dirtyStr2cleanList(f_dirtyString2)
print("titleUseageCheck() Tags\t\t", f_cleanThing2)
# -------------Artist--------------------------------------
key3 = 'Exif.Image.XPAuthor'
f_keywords3 = f_metadata[key3]
f_dirtyString3 = pyexiv2.utils.undefined_to_string(f_keywords3.value)
print("titleUseageCheck() f_dirtyString3: \t\t", f_dirtyString3)
f_cleanThing3 = MetadataManagerL0.dirtyStr2cleanList(f_dirtyString3)
print("titleUseageCheck() Artist\t\t", f_cleanThing3)
# -------------Description--------------------------------------
key4 = 'Exif.Image.XPComment'
f_keywords4 = f_metadata[key4]
f_dirtyString4 = pyexiv2.utils.undefined_to_string(f_keywords4.value)
print("titleUseageCheck() f_dirtyString4: \t\t", f_dirtyString4)
f_cleanThing4 = MetadataManagerL0.dirtyStr2cleanStr(f_dirtyString4)
print("titleUseageCheck() Description\t\t", f_cleanThing4)
# -------------Rating--------------------------------------
key5 = 'Exif.Image.Rating'
f_keywords5 = f_metadata[key5]
print("titleUseageCheck() f_keywords5: \t\t", f_keywords5)
print("titleUseageCheck() f_keywords5.value: \t\t", f_keywords5.value)
#f_metadata.__delitem__('Exif.Image.Rating')
#f_metadata.__delitem__('Exif.Image.RatingPercent')
#f_metadata.write()
#f_metadata.read()
#print(f_metadata.exif_keys)
# ------------Source URL-----------------------------------
key6 = 'Exif.Image.ImageHistory'
value6 = "modified by file tagger"
f_metadata[key6] = pyexiv2.ExifTag(key6, value6)
f_metadata.write()
f_metadata.read()
print(f_metadata.exif_keys)
f_keywords6 = f_metadata[key6]
print("titleUseageCheck() f_keywords6: \t\t", f_keywords6)
print("titleUseageCheck() f_keywords6.value: \t\t", f_keywords6.value)
print("titleUseageCheck() type(f_keywords6.value): \t\t",
type(f_keywords6.value))
# ------------Original Date--------------------------------
key7 = 'Exif.Photo.DateTimeOriginal'
f_keywords7 = f_metadata[key7]
print("titleUseageCheck() f_keywords7: \t\t", f_keywords7)
print("titleUseageCheck() f_keywords7.value: \t\t", f_keywords7.value)
print("titleUseageCheck() type(f_keywords7.value): \t\t",
type(f_keywords7.value))
#f_dirtyTagString = pyexiv2.utils.undefined_to_string(f_keywords.value)
#print("titleUseageCheck() f_dirtyTagString\t\t", f_dirtyTagString)
#f_cleanTagList = MetadataManager.dirtyStr2cleanList(f_dirtyTagString)
#print("titleUseageCheck() f_cleanTagList\t\t", f_cleanTagList)
#f_dirtyTagString2 = MetadataManager.cleanList2dirtyStr(f_cleanTagList)
#print("titleUseageCheck() f_dirtyTagString2\t\t", f_dirtyTagString2)
os.remove(f_filename)
return
'''
Edit pictures EXIF metadata. Add titles and tags by reading excel files contains file names, titles and tags columns.
'''
import pyexiv2
import pandas as pd
#### insert TITLES ####
import pyexiv2
data = pd.read_excel('<xlsx file name>','fixed') # Enter excel file name
for i in range(len(data['file_name'])):
metadata = pyexiv2.ImageMetadata('<Pictures folder location>'+data['file_name'][i]) # Enter pictures folder path
metadata.read()
key = 'Exif.Image.ImageDescription'
value = data['long description'][i]
metadata[key] = pyexiv2.ExifTag(key, value)
metadata.write()
#### insert TAGS ####
import pyexiv2
data = pd.read_excel('<xlsx file name>','fixed') # Enter excel file name
for i in range(len(data['file_name'])):
metadata = pyexiv2.ImageMetadata('<Pictures folder location>'+data['file_name'][i]) # Enter pictures folder path
metadata.read()
metadata['Exif.Image.XPKeywords']=pyexiv2.utils.string_to_undefined(data['TAGS'][i].encode('utf-16'))
metadata.write()
