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 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 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 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 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()