def save_image(market_item, image_data):
if not MarketItemImage.validate_image(image_data):
return False
image = MarketItemImage(item=market_item)
try:
with BytesIO() as data:
data.write(image_data.read())
data.seek(0)
ext = image_data.name.split('.')[-1]
if ext.lower() in ['jpg', 'jpeg']:
with BytesIO() as output:
ef = JpegFile(data, "posted_file")
ef.dump(output)
image.original_metadata = output.getvalue()
ef.remove_metadata(paranoid=True)
with BytesIO() as sanitised:
ef.writeFd(sanitised)
sanitised.seek(0)
image._set_thumbnail(image_data.name, sanitised)
else:
image._set_thumbnail(image_data.name, data)
image.original = image_data
image.save()
except Exception as ex:
_logger.exception(ex)
return False
def create_image(self, buffer, create_alpha=True):
self.extension = self.extension or '.tif'
self.no_data_value = None
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
if FORMATS[self.extension] == 'TIFF':
self.buffer = buffer
img0 = self.read_tiff(buffer, create_alpha)
else:
imagefiledata = cv.CreateMatHeader(1, len(buffer), cv.CV_8UC1)
cv.SetData(imagefiledata, buffer, len(buffer))
img0 = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_UNCHANGED)
if FORMATS[self.extension] == 'JPEG':
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img0
def read(self, extension=None, quality=None):
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
try:
if FORMATS[extension] == 'JPEG':
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
except KeyError:
# default is JPEG so
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
try:
if FORMATS[extension] == 'WEBP':
options = [cv2.IMWRITE_WEBP_QUALITY, quality]
except KeyError:
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
success, buf = cv2.imencode(extension, self.image, options or [])
data = buf.tostring()
if FORMATS[extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif') and self.exif != None:
img = JpegFile.fromString(data)
img._segments.insert(0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def create_image(self, buffer, create_alpha=True):
self.extension = self.extension or '.tif'
self.no_data_value = None
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
if FORMATS[self.extension] == 'TIFF':
self.buffer = buffer
img = self.read_tiff(buffer, create_alpha)
else:
img = cv2.imdecode(np.frombuffer(buffer, np.uint8), -1)
if FORMATS[self.extension] == 'JPEG':
self.exif = None
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img
def main():
hours, files = parse_args()
delta = timedelta(hours=hours)
for fname in files:
try:
jf = JpegFile.fromFile(fname)
except (IOError, JpegFile.InvalidFile):
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error reading %s:" % fname, value
return 1
exif = jf.get_exif()
if exif:
primary = exif.get_primary()
if exif is None or primary is None:
print >> sys.stderr, "%s has no EXIF tag, skipping" % fname
continue
adjust_time(primary, delta)
try:
jf.writeFile(fname)
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error saving %s:" % fname, value
return 1
return 0
def get_timestamp(self, image_path):
jpeg = JpegFile.fromFile(image_path.path)
exif = jpeg.exif.get_primary()
# 2014:04:23 16:07:06\x00
if exif[306]:
return datetime.strptime(exif[306], "%Y:%m:%d %H:%M:%S")
# Sigh. From some stupid camera. Hopefully there's some
# information in the filename.
match = date_expression.search(image_path.basename())
if match is not None:
data = match.group(0)
year = "%Y"
size = 4
offset = 0
if len(data) == 6:
year = "%y"
size = 2
offset = 2000
if 2014 <= int(data[:size]) + offset <= 2100:
# 2101 could be January 21st I guess
return datetime.strptime(data, year + "%m%d")
elif 2014 <= int(data[-size:]) + offset <= 2100:
return datetime.strptime(data, "%m%d" + year)
return None
def process(self, path):
img_dir = os.path.join(path, 'raw')
# Silence Wand logger
(logging.getLogger("wand").setLevel(logging.ERROR))
logger.info("Rotating images in {0}".format(img_dir))
with futures.ProcessPoolExecutor() as executor:
for imgpath in os.listdir(img_dir):
try:
img = JpegFile.fromFile(os.path.join(img_dir, imgpath))
if img.exif.primary.Orientation == [8]:
rotation = (self.config['autorotate']['left'].get(int))
elif img.exif.primary.Orientation == [6]:
rotation = (
self.config['autorotate']['right'].get(int))
elif img.exif.primary.Orientation == [1]:
# Already rotated, so we skip it
continue
else:
raise Exception(
"Invalid value for orientation: {0}".format(
img.exif.primary.Orientation))
except Exception as exc:
logger.warn(
"Cannot determine rotation for image {0}!".format(
imgpath))
logger.exception(exc)
continue
if self.config['rotate_inverse'].get(bool):
rotation *= -1
logger.debug("Orientation for \"{0}\" is {1}".format(
imgpath, rotation))
executor.submit(rotate_image,
os.path.join(img_dir, imgpath),
rotation=rotation)
def create_image(self, buffer, create_alpha=True):
self.extension = self.extension or '.tif'
self.no_data_value = None
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
if FORMATS[self.extension] == 'TIFF':
self.buffer = buffer
img0 = self.read_tiff(buffer, create_alpha)
else:
imagefiledata = cv.CreateMatHeader(1, len(buffer), cv.CV_8UC1)
cv.SetData(imagefiledata, buffer, len(buffer))
img0 = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_UNCHANGED)
if FORMATS[self.extension] == 'JPEG':
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img0
def setgps(ctx, filename, lat, lon):
"""
Set GPS location for the image file.
"""
from pexif import JpegFile
try:
ef = JpegFile.fromFile(filename)
ef.set_geo(float(lat), float(lon))
except IOError:
type, value, traceback = sys.exc_info()
print("Error opening file:", value)
raise invoke.Exit(1)
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print("Error opening file:", value)
raise invoke.Exit(2)
try:
ef.writeFile(filename)
except IOError:
type, value, traceback = sys.exc_info()
print("Error saving file:", value)
raise invoke.Exit(3)
def tag_photo(self, filename):
location_str = self.redis.lindex('location', -1)
telemetry_str = self.redis.lindex('telemetry', -1)
location = json.loads(location_str) if location_str else None
telemetry = json.loads(telemetry_str) if telemetry_str else None
if not (location or telemetry):
return
try:
jpeg = JpegFile.fromFile(filename)
attr = jpeg.get_exif(create=True).get_primary(create=True)
if location:
self.log.info('tag %s (lat=%f, lon=%f, alt=%f)', filename,
location['lat'], location['lon'], location['alt'])
jpeg.set_geo(location['lat'], location['lon'])
attr.GPS.GPSAltitudeRef = '\x00' # Above sea level
attr.GPS.GPSAltitude = [Rational(int(location['alt']), 1)]
if telemetry:
attr.ExtendedEXIF.UserComment = telemetry_str
jpeg.writeFile(filename)
except (IOError, JpegFile.InvalidFile):
self.log.exception('Error tagging photo: %s', filename)
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
self.extension = extension or self.extension
try:
if FORMATS[self.extension] == 'JPEG':
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
except KeyError:
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
if FORMATS[self.extension] == 'TIFF':
channels = cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
success, numpy_data = cv2.imencode(self.extension, numpy.asarray(self.image), options or [])
if success:
data = numpy_data.tostring()
else:
raise Exception("Failed to encode image")
if FORMATS[self.extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def check_folder(folder):
for root, sub_folders, files in os.walk(folder):
print('* ' + root)
for sub_folder in sub_folders:
check_folder(sub_folder)
if len(files):
folder_name_date = get_date_from_path(root)
if folder_name_date is None:
print(' Invalid folder path name. Skipping')
continue
for filename in files:
if filename.lower().endswith('.jpg'):
file_path = os.path.join(root, filename)
try:
pexif_file = JpegFile.fromFile(file_path)
exif = get_exif_info(pexif_file)
if file_needs_date_fix(exif):
print(' image: ' + file_path)
print(' FIX TO DATE = ' + folder_name_date.strftime("%Y/%m/%d"))
fix_file_date(pexif_file, file_path, exif, folder_name_date)
except (JpegFile.InvalidFile, AttributeError):
type, value, traceback = sys.exc_info()
print >> sys.stdout, "Error opening file:" + file_path + " -> ", value
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
self.extension = extension or self.extension
try:
if FORMATS[self.extension] == 'JPEG':
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
except KeyError:
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
if FORMATS[self.extension] == 'TIFF':
channels = cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
success, numpy_data = cv2.imencode(self.extension, numpy.asarray(self.image), options or [])
if success:
data = numpy_data.tostring()
else:
raise Exception("Failed to encode image")
if FORMATS[self.extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def save_image(market_item, image_data):
if not MarketItemImage.validate_image(image_data):
return False
image = MarketItemImage(item=market_item)
try:
with BytesIO() as data:
data.write(image_data.read())
data.seek(0)
ext = image_data.name.split('.')[-1]
if ext.lower() in ['jpg', 'jpeg']:
with BytesIO() as output:
ef = JpegFile(data, "posted_file")
ef.dump(output)
image.original_metadata = output.getvalue()
ef.remove_metadata(paranoid=True)
with BytesIO() as sanitised:
ef.writeFd(sanitised)
sanitised.seek(0)
image._set_thumbnail(image_data.name, sanitised)
else:
image._set_thumbnail(image_data.name, data)
image.original = image_data
image.save()
except Exception as ex:
_logger.exception(ex)
return False
def main():
try:
#If a JSON file already exists, let's load the existing location data
positionList=[]
if os.path.isfile(jsonfilename):
with open(jsonfilename) as f:
jsonList = json.load(f)
for item in jsonList:
lat = item['lat']
lng = item['lng']
positionList.append((lat, lng))
else:
#Otherwise we'll sart with an empty list
jsonList = []
except:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error:", value
print positionList
for dirname, dirnames, filenames in os.walk(searchPath):
for subdirname in dirnames:
print "FOUND DIRECTORY: ", os.path.join(dirname, subdirname)
for filename in filenames:
if any(filename.endswith(ext) for ext in included_extenstions):
image = os.path.join(dirname, filename)
print "FOUND FILE: ", image
alreadyInList = False
try:
ef = JpegFile.fromFile(image)
for position in positionList:
myDistance = haversine(position[0], position[1], lat, lng)
if myDistance < distanceKM:
alreadyInList = True
pass
if not alreadyInList:
print "new location"
jsonList.append({"lat": lat, "lng": lng, "DateTimeOriginal": ef.exif.primary.ExtendedEXIF.DateTimeOriginal, "file": image})
positionList.append(ef.get_geo())
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except JpegFile.NoSection:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error get GPS info:", value
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error:", value
with open(jsonfilename, 'w') as outfile:
json.dump(jsonList, outfile)
def _post_process_image(self, filename, position):
"""
Performs post processing on an image (mainly adding EXIF tags).
@param filename Image filename to process
@param position Location where the frame was captured
"""
exif = JpegFile.fromFile(filename)
exif.set_geo(float(position[0]), float(position[1]))
exif.writeFile(filename)
def __init__(self, path, photo_fs):
self.id = md5(path.encode('utf-8')).hexdigest()
self.path = path
with photo_fs.open(path, 'r') as fd:
try:
image = JpegFile.fromFd(fd)
self.timestamp = datetime.strptime(image.exif.primary.DateTime, TIME_FORMAT)
self.location = image.get_geo()
except:
pass
def _post_process_image(self, filename, position):
"""
Performs post processing on an image (mainly adding EXIF tags).
@param filename Image filename to process
@param position Location where the frame was captured
"""
exif = JpegFile.fromFile(filename)
exif.set_geo(float(position[0]), float(position[1]))
exif.writeFile(filename)
def getGPSinFolder(path, directory, outputFileName):
global IndextoPath
global PathIndex
tmpPathIndex = PathIndex
tmpPath = path + '\\' + directory + '\\'
print "Enter folder:", tmpPath
listfile = os.listdir(tmpPath)
# loop over the input images
for imagePath in listfile:
# load the image, convert it to grayscale, and compute the
# focus measure of the image using the Variance of Laplacian
# method
imagefile = tmpPath + '\\' + imagePath
# To check if this is a folder, if yes, handle all files under this folder
if os.path.isdir(imagefile):
getGPSinFolder(tmpPath, imagePath, outputFileName)
continue
try:
ef = JpegFile.fromFile(imagefile)
a = ef.get_geo1()
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value, imagePath
continue
except JpegFile.NoSection:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error get GPS info:", value, imagePath
continue
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value, imagePath
continue
except AttributeError:
print >> sys.stderr, "No GPS infor", imagefile
continue
# Add the index to head of filename, ex: 1_DSC_0001, 2_DSC_0009
if directory != '.':
tmpImagePath = directory + ':' + imagePath # Write directory name + filename of picture
else:
tmpImagePath = imagePath #Just write the filename of picture
wirtePostion2Kml(outputFileName, a, tmpImagePath)
print "Exit folder:", tmpPath
def rotate_image(path, rotation):
with wand.image.Image(filename=path) as img:
logger.debug("Rotating image \'{0}\' by {1} degrees".format(
path, rotation))
if img.height > img.width:
logger.info("Image already rotated, skipping...")
else:
img.rotate(rotation)
img.save(filename=path)
# Update EXIF orientation
img = JpegFile.fromFile(path)
if not img.exif.primary.Orientation == [1]:
logger.debug("Updating EXIF information for image '{0}'".format(path))
img.exif.primary.Orientation = [1]
img.writeFile(path)
def rotate_image(path, rotation):
with wand.image.Image(filename=path) as img:
logger.debug("Rotating image \'{0}\' by {1} degrees"
.format(path, rotation))
if img.height > img.width:
logger.info("Image already rotated, skipping...")
else:
img.rotate(rotation)
img.save(filename=path)
# Update EXIF orientation
img = JpegFile.fromFile(path)
if not img.exif.primary.Orientation == [1]:
logger.debug("Updating EXIF information for image '{0}'".format(path))
img.exif.primary.Orientation = [1]
img.writeFile(path)
def set_coordinates(**kwargs):
try:
ef = JpegFile.fromFile(kwargs['filename'])
ef.set_geo(float(kwargs['lat']), float(kwargs['lon']))
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
try:
ef.writeFile(filename)
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error saving file:", value
def set_exif(long,lat,filename):
try:
ef = JpegFile.fromFile(filename)
ef.set_geo(lat, long)
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
try:
ef.writeFile(filename)
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error saving file:", value
def calculateDistance(x, radius):
mypath = "images/"
arr = []
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
for f in onlyfiles:
# pexif package used to extract geo data from image
lf = JpegFile.fromFile("images/" + f)
ef = lf.get_geo()
lat = abs(ef[1] - x[0])
long = abs(ef[0] - x[1])
# here dist is in meters
dist = pow(10, 5) * math.sqrt(pow(lat, 2) + pow(long, 2))
if (dist < radius):
print f
arr.append(f)
# returning a list of images names
return arr
def get_image_coordinates(path): try: ef = JpegFile.fromFile(path) return ef.get_geo() except IOError: type, value, traceback = sys.exc_info() print "Skipping", path, "- reason: error opening file" return except JpegFile.NoSection: type, value, traceback = sys.exc_info() print "Skipping", path, "- reason: no GPS info" return except JpegFile.InvalidFile: type, value, traceback = sys.exc_info() print "Skipping", path, "- reason: error opening file" return
def tag(impath, kml):
coords = kml.Document.Placemark.getchildren()[1].getchildren()
print "Found {} coordinates".format(len(coords) / 2)
idx = 1 # Skip <altitudeMode>
last_time = datetime.min # Time of last assigned location
kml_date_str = "%Y-%m-%dT%H:%M:%SZ"
exif_date_str = "%Y:%m:%d %H:%M:%S"
for root, dirs, files in walk(impath):
for ifile in sorted(
files,
reverse=True): # Sort files in order of most recently taken
if ifile.lower().endswith(".jpg"):
filepath = path.join(root, ifile)
image = JpegFile.fromFile(path.join(root, ifile))
time_taken = image.get_exif().get_primary(
).ExtendedEXIF.DateTimeDigitized
time_taken = datetime.strptime(str(time_taken), exif_date_str)
print "{} taken {}".format(ifile, time_taken)
for i in range(idx, len(coords), 2):
coord_time = datetime.strptime(str(
coords[i]), kml_date_str) # GPS log time
# Note: <= as there can be duplicated coordinate time stamps within 1 second
if abs(coord_time - time_taken) <= abs(last_time -
time_taken):
last_time = coord_time # New coordinate is closer in time
else:
# Take previous time and coordinates
coord_time = datetime.strptime(str(coords[i - 2]),
kml_date_str)
coord = coords[i - 1].text.split(
" ") # Longitude, Latitude, Altitude
image.set_geo(float(coord[1]), float(coord[0]))
image.writeFile(filepath)
last_time = coord_time
idx = i
print "Assigning location {} from {} image taken at {}. Delta time {}".format(
coord, coord_time, time_taken,
abs(coord_time - time_taken))
break
def test_pexif( input_file_name, output_file_name, args ):
"""
Tests Exif manipulation and JPEG I/O using pexif.
Takes 3 arguments:
input_file_name - Path of input JPEG file.
output_file_name - Path of output JPEG file.
args - Dictionary of arguments provided to the test. This
is unused.
Returns nothing.
"""
from pexif import JpegFile
ef = JpegFile.fromFile( input_file_name )
ef.set_geo( 1.234567, -9.876543 )
ef.writeFile( output_file_name )
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
# Check if we should write a JPEG. If we are allowing defaulting to jpeg
# and if the alpha channel is all white (opaque).
channels = None
if getattr(self.context.request, 'default_to_jpeg', True):
channels = cv2.split(numpy.asarray(self.image))
if len(channels) > 3 and numpy.all(channels[3] == 255):
extension = '.jpg'
try:
if FORMATS[extension] == 'JPEG':
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
except KeyError:
# default is JPEG so
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
if FORMATS[extension] == 'TIFF':
channels = channels or cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
data = cv.EncodeImage(extension, self.image, options
or []).tostring()
if FORMATS[
extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(
0, ExifSegment(self.exif_marker, None, self.exif,
'rw'))
data = img.writeString()
return data
def img_callbak(self,data):
global lat,lon,save_every_second
if not lat is None and not lon is None:
print(lat,lon)
try:
# cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
np_arr = np.fromstring(data.data, np.uint8)
cv_image = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
except CvBridgeError as e:
print(e)
try:
cv2.imwrite(filename='/tmp/%08d.jpg'%self.counter, img=cv_image)
ef = JpegFile.fromFile('/tmp/%08d.jpg'%self.counter)
ef.set_geo(lat,lon)
if self.counter == 0 and (not self.ref_lat) and (not self.ref_lon):
self.ref_lat = lat
self.ref_lon = lon
self.reflla.write(str(lat) + "," + str(lon))
x, y, z = geo.topocentric_from_lla(lat, lon, 0,
self.ref_lat, self.ref_lon, 0)
self.f.write(str(data.header.stamp.to_sec()) + ',' + str(x) + "," + str(y) + ',' + str(z) + '\n')
self.lla.write('%08d.jpg'%self.counter+','+str(lat)+','+str(lon)+',')
self.lla.flush()
if save_every_second==True:
lat = None
lon = None
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
try:
ef.writeFile('/tmp/%08d.jpg'%self.counter)
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error saving file:", value
self.counter=self.counter+1
def create_image(self, buffer):
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
img = cv2.imdecode(np.frombuffer(buffer, np.uint8), -1)
if FORMATS[self.extension] == 'JPEG':
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img
def get_all_image_points(filename_format, first=0, last=None):
"""
Gets all GPS points for a given set of images.
Each point is a dict of {image_id, lat, lon, image_filename}
@param filename_format Filename format for images
@param first Index of image at start of range
@param last Index of iimage at end of range
@returns List of GPS points maintaining image order
"""
points = list()
# If no end index was defined just continue the loop until we get an error
if last is None:
last = sys.maxint
print 'Getting points from images with format: %s' % filename_format
print '\t(first index = %d, last index = %d)' % (first, last)
for frame_no in xrange(first, last):
filename = filename_format % frame_no
# Try to open the image, if it fails assume this is the end of a range
try:
exif = JpegFile.fromFile(filename)
except IOError:
break
gps_pos = exif.get_geo()
point = dict()
point['index'] = frame_no
point['image_filename'] = filename
point['lat'] = gps_pos[0]
point['lon'] = gps_pos[1]
points.append(point)
return points
def check_and_rotate(filepath):
print "Now checking file: %s" % filepath
try:
img = JpegFile.fromFile(filepath)
orientation = img.exif.primary.Orientation[0]
if orientation != 1:
print "Orientation value is: %d, switching to 1" % orientation
img.exif.primary.Orientation = [1]
img.writeFile(filepath)
print "Saved new orientation"
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except AttributeError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Could not get orientation attribute:", value
def check_and_rotate(filepath): print "Now checking file: %s" % filepath try: img = JpegFile.fromFile(filepath) orientation = img.exif.primary.Orientation[0] if orientation != 1: print "Orientation value is: %d, switching to 1" % orientation img.exif.primary.Orientation = [1] img.writeFile(filepath) print "Saved new orientation" except IOError: type, value, traceback = sys.exc_info() print >> sys.stderr, "Error opening file:", value except JpegFile.InvalidFile: type, value, traceback = sys.exc_info() print >> sys.stderr, "Error opening file:", value except AttributeError: type, value, traceback = sys.exc_info() print >> sys.stderr, "Could not get orientation attribute:", value
def test_camera(self):
from vanguard import camera
c = camera.Camera(self.config)
c.redis.rpush('location', '{"lat": 22, "lon": 33, "alt": 44}')
c.redis.rpush('telemetry', '{"int_temp": 22, "ext_temp": 33}')
c.on_interval()
self.assertEqual(c.redis.llen('photos'), 1)
photo = c.redis.lindex('photos', -1)
self.assertEqual(photo, '/tmp/photos/00000.jpeg')
jpeg = JpegFile.fromFile(photo)
lat, lon = jpeg.get_geo()
self.assertEqual(lat, 22.0)
self.assertEqual(lon, 33.0)
self.assertEqual(jpeg.exif.primary.GPS.GPSAltitudeRef, ['\x00'])
self.assertEqual(jpeg.exif.primary.GPS.GPSAltitude[0].as_tuple(), (44, 1))
telemetry = json.loads(''.join(jpeg.exif.primary.ExtendedEXIF.UserComment))
self.assertEqual(telemetry['int_temp'], 22)
self.assertEqual(telemetry['ext_temp'], 33)
def set_gps(filename, lat, lon):
try:
#print (filename)
ef = JpegFile.fromFile(filename)
ef.set_geo(float(lat), float(lon))
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error opening file:", value
try:
fname = os.path.basename(filename)
#ef.writeFile('E:\\Projects\\Python\\pexif\\output\\SRIKAKULAM\\'+fname)
dir_output = sys.argv[4]
ef.writeFile(dir_output + fname)
print(fname, 'Done')
except IOError:
type, value, traceback = sys.exc_info()
print >> sys.stderr, "Error saving file:", value
def process(self, path):
img_dir = os.path.join(path, 'raw')
# Silence Wand logger
(logging.getLogger("wand")
.setLevel(logging.ERROR))
logger.info("Rotating images in {0}".format(img_dir))
with futures.ProcessPoolExecutor() as executor:
for imgpath in os.listdir(img_dir):
try:
img = JpegFile.fromFile(os.path.join(img_dir, imgpath))
if img.exif.primary.Orientation == [8]:
rotation = (self.config['autorotate']
['left'].get(int))
elif img.exif.primary.Orientation == [6]:
rotation = (self.config['autorotate']
['right'].get(int))
elif img.exif.primary.Orientation == [1]:
# Already rotated, so we skip it
continue
else:
raise Exception("Invalid value for orientation: {0}"
.format(img.exif.primary.Orientation))
except Exception as exc:
logger.warn("Cannot determine rotation for image {0}!"
.format(imgpath))
logger.exception(exc)
continue
if self.config['rotate_inverse'].get(bool):
rotation *= -1
logger.debug("Orientation for \"{0}\" is {1}"
.format(imgpath, rotation))
executor.submit(
rotate_image,
os.path.join(img_dir, imgpath),
rotation=rotation
)
#!/usr/bin/env python
from pexif import JpegFile
import sys
usage = """Usage: dump_timestamp.py filename.jpg"""
if len(sys.argv) != 2:
print(usage, file=sys.stderr)
sys.exit(1)
try:
ef = JpegFile.fromFile(sys.argv[1])
exif = ef.get_exif()
if exif:
primary = exif.get_primary()
print("Primary DateTime :", primary.DateTime)
print("Extended DateTimeOriginal :", primary.ExtendedEXIF.DateTimeOriginal)
print("Extended DateTimeDigitized:", primary.ExtendedEXIF.DateTimeDigitized)
except IOError:
type, value, traceback = sys.exc_info()
print("Error opening file:", value, file=sys.stderr)
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print("Error opening file:", value, file=sys.stderr)
tracks = []
directions = []
for line in trackf.readlines():
ls = line.split(";")
if line != "DONE" and ls[1] and ls[2]:
t = ls[0]
lon = ls[1]
lat = ls[2]
d = ls[3]
tracks.append({'t': float(t), 'lat': float(lat), 'lon': float(lon)})
elif line != "DONE" and ls[13]:
t = ls[0]
directions.append({'t': float(t), 'direction': float(ls[13])})
for fn in glob.glob("*.jpg"):
print("do " + fn)
ef = JpegFile.fromFile(fn, mode="rw")
primary = ef.get_exif(create=True).get_primary()
dt = datetime.strptime(primary.DateTime,
"%Y:%m:%d %H:%M:%S") #python 3 .timestamp()
t = time.mktime(dt.timetuple())
dirty = False
trp = None
drp = None
for tr in tracks:
if trp is not None and t >= trp['t'] and t <= tr[
't'] and tr['t'] - trp['t'] < 20:
gps = primary.GPS
lat = ipol(trp, tr, t, 'lat')
lon = ipol(trp, tr, t, 'lon')
ef.set_geo(lat, lon)
# sys.exit(1) # try: # ef = JpegFile.fromFile(sys.argv[1]) # primary = ef.get_exif().get_primary() # print "Primary DateTime :", primary.DateTime # print "Extended DateTimeOriginal :", primary.ExtendedEXIF.DateTimeOriginal # print "Extended DateTimeDigitized:", primary.ExtendedEXIF.DateTimeDigitized # except IOError: # type, value, traceback = sys.exc_info() # print >> sys.stderr, "Error opening file:", value # except JpegFile.InvalidFile: # type, value, traceback = sys.exc_info() # print >> sys.stderr, "Error opening file:", value FILE_NAME = 'WechatIMG2080.jpeg' TIME = '2019:01:21 12:17:36' dsc_pic = JpegFile.fromFile(FILE_NAME) # dsc_pic.exif.primary.DateTime = src_pic.exif.primary.DateTime # dsc_pic.exif.primary.ExtendedEXIF.DateTimeOriginal = src_pic.exif.primary.ExtendedEXIF.DateTimeOriginal # dsc_pic.exif.primary.ExtendedEXIF.DateTimeDigitized = src_pic.exif.primary.ExtendedEXIF.DateTimeDigitized # dt =src_pic.exif.primary.DateTime # dto = src_pic.exif.primary.ExtendedEXIF.DateTimeOriginal # dtd = src_pic.exif.primary.ExtendedEXIF.DateTimeDigitized dsc_pic.exif.primary.DateTime = TIME dsc_pic.exif.primary.ExtendedEXIF.DateTimeOriginal = TIME dsc_pic.exif.primary.ExtendedEXIF.DateTimeDigitized = TIME dsc_pic.writeFile(FILE_NAME)
def post(self, program=None, code=None, report=None, dataset=None):
headers = {}
params = {
'file_image': self.request.POST['file'],
'indexed_program': program.upper(),
'indexed_project_code': code,
'indexed_project_id': self.request.POST['project-id'],
'indexed_dataset_code': report,
'indexed_dataset_id': self.request.POST['dataset-id'],
'indexed_parent_code': report,
'unindexed_data_collectors': self.request.POST['data-collectors'],
'unindexed_last_modified_date':
self.request.POST['last_modified_date']
}
if self.request.get('subproject'):
params['indexed_subproject_code'] = report
params['indexed_subproject_id'] = self.request.POST[
'subproject-id']
params['indexed_dataset_code'] = dataset
params['indexed_parent_code'] = dataset
if self.request.get('special'):
logging.debug('FILE RECEIVED')
params['file_file'] = params.pop('file_image')
params['indexed_type'] = 'FILE'
if self.request.POST['file'].filename.lower().endswith(
tuple(['.jpg', '.jpeg'])):
image = JpegFile.fromString(params['file_file'].file.read())
try:
lat, lng = image.get_geo()
params['unindexed_latlng'] = str(lat) + ',' + str(lng)
logging.debug('FILE HAS GPS')
except:
logging.debug('FILE HAS NO GPS')
params['file_file'].file.seek(0)
else:
if self.request.POST['file'].filename.endswith(
tuple(['.kml', '.kmz'])):
logging.debug('KML RECEIVED')
params['file_kml'] = params.pop('file_image')
params['indexed_type'] = 'KML'
kml_type = 'PROJECT'
if params['file_kml'].filename.startswith('ACCESS-'):
kml_type = 'ACCESS'
ext = params['file_kml'].filename.split('.')[-1]
params['file_kml'].filename = kml_type + '-' + code + '-'
params['file_kml'].filename += self.request.get('kml')
params['file_kml'].filename += '.' + ext
query = APIData.query()
query = query.filter(APIData.indexed_data == 'TYPE->PROJECT')
query = query.filter(APIData.indexed_data == 'CODE->' + code)
query = query.filter(APIData.indexed_data == 'HAS_KML->1')
project = query.get(keys_only=True)
logging.debug('PROJECT QUERIED AND HAS KML')
logging.debug(project)
if not project:
params = {}
params['indexed_has_kml'] = '1'
update_api_data(self.request.POST['project-id'], params,
self.user, 'application/json')
elif self.request.POST['file'].filename.lower().endswith(
tuple(['.jpg', '.jpeg'])):
logging.debug('IMAGE RECEIVED')
try:
image = JpegFile.fromString(
params['file_image'].file.read())
except Exception as e:
logging.debug(e)
params['file_image'].file.seek(0)
try:
image = JpegFile.fromString(
StringIO(params['file_image'].file.read()).read())
except Exception as e:
logging.debug('Using StringIO')
traceback.print_exc()
self.response.set_status(500)
self.response.write('Image has invalid metadata')
return
try:
lat, lng = image.get_geo()
except Exception as e:
logging.debug('Image does not a have GPS data')
traceback.print_exc()
self.response.set_status(500)
self.response.write('Image does not a have GPS data')
return
params['unindexed_latlng'] = str(lat) + ',' + str(lng)
params['unindexed_date'] = ''
if image.exif.primary.GPS[0x7]:
logging.debug(image.exif.primary.GPS[0x7])
gps_time = ''
for a in image.exif.primary.GPS[0x7]:
if a.num < 10:
gps_time += '0' + str(a.num)
else:
gps_time += str(a.num)
gps_time += ':'
gps_time = gps_time[:-1]
logging.debug(gps_time)
params['unindexed_date'] = image.exif.primary.GPS[
0x1d] + ' ' + gps_time
logging.debug(params['unindexed_date'])
else:
try:
params[
'unindexed_date'] = image.exif.primary.ExtendedEXIF.DateTimeOriginal
except:
params['unindexed_date'] = datetime.datetime.now(
).strftime('%Y:%m:%d %H:%M:%S')
params['file_image'].file.seek(0)
params['indexed_type'] = 'IMAGE'
query = APIData.query()
query = query.filter(APIData.indexed_data == 'TYPE->PROJECT')
query = query.filter(APIData.indexed_data == 'CODE->' + code)
query = query.filter(APIData.indexed_data == 'HAS_IMAGE->1')
project = query.get(keys_only=True)
logging.debug('PROJECT QUERIED AND HAS IMAGE')
logging.debug(project)
if not project:
params = {}
params['indexed_has_image'] = '1'
update_api_data(self.request.POST['project-id'], params,
self.user, 'application/json')
else:
self.response.set_status(500)
self.response.write('File is invalid')
return
headers['Authorization'] = API_KEY
headers['Content-Type'] = 'multipart/form-data'
logging.debug(params)
write_to_api(params, self.user, headers['Content-Type'])
"""
Set GPS location for the image file.
"""
import sys
from pexif import JpegFile
filename = sys.argv[1]
lat = sys.argv[2]
lon = sys.argv[3]
try:
ef = JpegFile.fromFile(filename)
ef.set_geo(float(lat), float(lon))
except IOError:
type, value, traceback = sys.exc_info()
print("Error opening file:", value)
raise IOError("Error opening file")
except JpegFile.InvalidFile:
type, value, traceback = sys.exc_info()
print("Error opening file:", value)
raise IOError("Invalid file")
try:
ef.writeFile(filename)
except IOError:
type, value, traceback = sys.exc_info()
print("Error saving file:", value)
import json
import sys
import urllib2
from pexif import JpegFile
TIME_FORMAT = '%Y:%m:%d %H:%M:%S'
obj = {}
with open(sys.argv[1]) as f:
obj = json.loads(f.read())
for photo in obj['response']['photos']['items']:
date = datetime.datetime.fromtimestamp(photo['createdAt'])
loc = (photo['venue']['location']['lat'], photo['venue']['location']['lng'])
print photo['venue']['name']
url = "%soriginal%s" % (photo['prefix'], photo['suffix'])
req = urllib2.Request(url)
handler = urllib2.urlopen(req)
ef = JpegFile.fromString(handler.read())
exif = ef.get_exif()
primary = exif.get_primary()
ef.set_geo(loc[0], loc[1])
primary.DateTime = date.strftime(TIME_FORMAT)
ef.writeFile('photos/%s.jpg' % photo['id'])
from pexif import JpegFile
from time import sleep
camera = picamera.PiCamera()
vehicle = dronekit.connect('/dev/ttyACM0', wait_ready=False, baud=115200)
#camera.start_preview()
f = open('image/image.txt', 'a')
i = 0
while True:
latitude = vehicle.location.global_frame.lat
longtitude = vehicle.location.global_frame.lon
sleep(1)
filename = '%s.jpg' % i
camera.capture('image/'+filename)
ef = JpegFile.fromFile('image/'+filename)
ef.set_geo(float(latitude), float(longtitude))
ef.writeFile('image/'+filename)
str = '%s,%s\t'%(latitude, longtitude)
f.write(str)
f.write(filename)
f.write('\n')
print (latitude, longtitude)
i+=1
f.close()
#camera.stop_preview()
