def rotate_upright(img): ret = {} info = img._getexif() for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "Orientation": orientation = value #print "before:" + str(value) if orientation is 6: img = img.rotate(-90) elif orientation is 8: img = img.rotate(90) print type(img) print orientation elif orientation is 3: img = img.rotate(180) elif orientation is 2: img = img.transpose(Image.FLIP_LEFT_RIGHT) elif orientation is 5: img = img.rotate(-90).transpose(Image.FLIP_LEFT_RIGHT) elif orientation is 7: img = img.rotate(90).transpose(Image.FLIP_LEFT_RIGHT) elif orientation is 4: img = img.rotate(180).transpose(Image.FLIP_LEFT_RIGHT) print type(img) ret = {} info = img._getexif() for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "Orientation": orientation = value print "before:" + str(value) return img
def attributes(self, node): attr = VMap() vfile = node.open() img = Image.open(vfile) info = img._getexif() vfile.close() for tag, values in info.items(): if tag in self.dateTimeTags: try: decoded = str(TAGS.get(tag, tag)) try: dt = strptime(values, "%Y:%m:%d %H:%M:%S") except ValueError: try: dt = strptime(values[:-6], "%Y-%m-%dT%H:%M:%S") except ValueError: dt = strptime(values.rstrip(' '), "%a %b %d %H:%M:%S") vt = vtime(dt.tm_year, dt.tm_mon, dt.tm_mday, dt.tm_hour, dt.tm_min, dt.tm_sec, 0) vt.thisown = False attr[decoded] = Variant(vt) except Exception as e: attr[decoded] = Variant(str(values)) else: decoded = str(TAGS.get(tag, tag)) if isinstance(values, tuple): vl = VList() for value in values: vl.push_back(Variant(value)) attr[decoded] = vl else: attr[decoded] = Variant(values) return attr
def get_exif_data(image_path, exif_include_keys=EXIF_INCLUDE_KEYS): """ Returns all the image's exif data as a dict. """ image_file = pil.open(image_path) try: raw_exif_data = image_file._getexif() except AttributeError: raw_exif_data = None if not raw_exif_data: return None exif_data = {} for key, value in raw_exif_data.items(): decoded_key = TAGS.get(key, key) if decoded_key in exif_include_keys: if decoded_key == "DateTimeOriginal": try: value = datetime.strptime(value, "%Y:%m:%d %H:%M:%S") except ValueError: value = datetime.now() exif_data[decoded_key] = value return exif_data [{TAGS.get(key, key): value}for key, value in raw_exif_data.items()]
def get_exif(file,field): img = Image.open(file) exif = img._getexif() exif_data = [] for id, value in exif.items(): if TAGS.get(id) == field: tag = TAGS.get(id, id),value exif_data.extend(tag) return exif_data
def __init__(self, imageName, crs): QDialog.__init__(self) self.ui_exif_info = Ui_Exif2() self.ui_exif_info.setupUi(self) self.FocalLength = None img = Image.open(imageName) if hasattr(img,'_getexif'): raw = img._getexif() else: QMessageBox.warning(QMainWindow(),"Error","Image has no EXIF") return sizePicture = img.size self.diag = sqrt(sizePicture[0]**2+sizePicture[1]**2) if raw != None and any(raw): dict = None for (k,v) in raw.iteritems(): if TAGS.get(k) == 'GPSInfo': dict = v if TAGS.get(k) == 'FocalLength': self.FocalLength = v text = '' if dict != None: Nord = dict[2][0][0]+dict[2][1][0]/float(dict[2][1][1])/60.0 Est = dict[4][0][0]+dict[4][1][0]/float(dict[4][1][1])/60.0 crsTarget = QgsCoordinateReferenceSystem(crs.postgisSrid()) crsSource = QgsCoordinateReferenceSystem(4326) xform = QgsCoordinateTransform(crsSource, crsTarget) LocalPos = xform.transform(QgsPoint(Est,Nord)) text += 'Nord: ' + str(LocalPos[0]) text += '\nEst: ' +str(LocalPos[1]) text += '\n\n' text += '============================\n' text += 'Raw EXIF data:' for (k,v) in raw.iteritems(): test = True if isinstance(v, (int, long, float, complex, bool)): text += "\n " + str(TAGS.get(k)) + ": " + str(v) else: for c in str(v): if isinstance(c, str) and c not in string.ascii_letters and c not in string.digits and c not in string.whitespace and c not in('.',',','(',')',':'): test = False if test: text += "\n " + str(TAGS.get(k)) + ": " + str(v) self.ui_exif_info.textBrowser.setText(text) else: raise IOError self.ui_exif_info.pushButton.clicked.connect(self.getFocal)
def get_exif_data(filename): fileinfo = {} try: img = Image.open(filename) if hasattr( img, '_getexif' ): exifinfo = img._getexif() print exifinfo if exifinfo != None: fileinfo = dict([(TAGS.get(key,key), str(value).decode('utf-8', 'ignore')) for key, value in exifinfo.items() if type(TAGS.get(key,key)) is str]) except IOError: logging.error(filename) return fileinfo
def get_exif(file): img = Image.open(file) df=np.array(Image.open(file)) exif = img._getexif() exif_data = [] for id, value in exif.items(): #print 'ID',TAGS.get(id),'\n' ID = TAGS.get(id) tag = TAGS.get(id, id),value #print 'Tag',tag,'\n' if ID == 'GPSInfo': exif_data.extend(tag) return exif_data
def get_exif_data(fname): """Get embedded EXIF data from image file.""" fileinfo = {} try: img = Image.open(fname) if hasattr( img, '_getexif' ): exifinfo = img._getexif() print exifinfo if exifinfo != None: fileinfo = dict([(TAGS.get(key,key),value) for key, value in exifinfo.items() if type(TAGS.get(key,key)) is str]) except IOError: logging.error(fname) return fileinfo
def _get_exifgps(i): ret = {} info = i._getexif() if info: for tag, values in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": lat, lon, altitude, gps_data = _extract_gpsinfo(values) # try: # iptc = IptcImagePlugin.getiptcinfo(i) # ret['caption'] = iptc[(2,120)] # ret['copyright'] = iptc[(2,116)] # ret['keywords'] = iptc[(2,25)] # except: # ret['headline'] = None # ret['caption'] = None # ret['copyright'] = None # ret['keywords'] = [] ret['latitude'] = lat ret['longitude'] = lon ret['altitude'] = altitude ret[decoded] = gps_data return ret
def testForExif(imgFileName): try: print "[+] Testing for exif Metadata" exifData = {} imgFile = Image.open(imgFileName) info = imgFile._getexif() if info: for (tag, value) in info.items(): decoded = TAGS.get(tag, tag) exifData[decoded] = value exifGPS = exifData['GPSInfo'] if exifGPS: print '[*] ' + str(imgFileName) + ' contains GPS MetaData' else: print '[-] NO GPS data found' else: print '[-] NO data found' except Exception, e: print "[-] Error : " + str(e)
def get_exif(self): """ Get EXIF tags for JPEG images. Fails for non-JPEG images. :returns: EXIF tags. :rtype: dict(str -> str) :raise ValueError: Not a JPEG image. """ # Check that it's really an image. if self.mime_subtype != "jpeg": raise ValueError("Not a JPEG image") # Lazy import. global PIL_TAGS if PIL_TAGS is None: from PIL.ExifTags import TAGS as PIL_TAGS # Load in PIL. img = self.to_pil() # Extract the EXIF tags. exif = {} try: info = img.tag.tags except AttributeError: info = img._getexif() if info: for tag, value in info.items(): decoded = PIL_TAGS.get(tag, tag) exif[decoded] = value # Return the EXIF tags. return exif
def show_geodata_for_image(imageSrc, imageFilePath): """ Searches for GPS data in the image and shows it if found and valid. """ exitData = {} try: imageFile = Image.open(imageFilePath) info = imageFile._getexif() except: return if info: for (tag, value) in info.items(): decoded = TAGS.get(tag, tag) if decoded == 'GPSInfo': gpsData = {} for t in value: decodedGps = GPSTAGS.get(t, t) gpsData[decodedGps] = value[t] if 'GPSLatitude' in gpsData and 'GPSLatitudeRef' in gpsData and 'GPSLongitude' in gpsData and 'GPSLongitudeRef' in gpsData: latitude = convert_to_degrees(gpsData['GPSLatitude']) if gpsData['GPSLatitudeRef'] != 'N': latitude = 0 - latitude longitude = convert_to_degrees(gpsData['GPSLongitude']) if gpsData['GPSLongitude'] != 'E': longitude = 0 - longitude if latitude !=0 and longitude != 0: print 'GPS data for %s: latitude=%f%s, longitude=%f%s' % (imageSrc, latitude, gpsData['GPSLatitudeRef'], longitude, gpsData['GPSLongitudeRef']) break
def extract(self, filepath): fd = Image.open(filepath) exif = fd._getexif() # raw exif gps = {} # raw undecoded gps results = {} if exif: for (k, v) in exif.items(): results[TAGS.get(k, k)] = v if exif and ExifExtract.GPSINFO in exif: for t in exif[ExifExtract.GPSINFO]: sub_decoded = GPSTAGS.get(t, t) gps[sub_decoded] = exif[ExifExtract.GPSINFO][t] if 'GPSLatitude' in gps and 'GPSLatitudeRef' in gps and 'GPSLongitude' in gps and 'GPSLongitudeRef' in gps: lat_deg = self._to_degrees(gps['GPSLatitude']) if 'N' is not gps['GPSLatitudeRef']: lat_deg *= -1 lng_deg = self._to_degrees(gps['GPSLongitude']) if 'E' is not gps['GPSLongitudeRef']: lng_deg *= -1 results['GPS'] = { 'longitude': lng_deg, 'latitude': lat_deg } return results
def rotate(img): try: exif = img._getexif() except: return img if not exif or not exif.items: return img for tag, value in exif.items(): decoded = TAGS.get(tag, tag) if decoded == 'Orientation': if value == 1: return img elif value == 2: return img.transpose(Image.FLIP_LEFT_RIGHT) elif value == 3: return img.transpose(Image.ROTATE_180) elif value == 4: return img.transpose(Image.FLIP_TOP_BOTTOM) elif value == 5: return img.transpose(Image.ROTATE_90).transpose(Image.FLIP_LEFT_RIGHT) elif value == 6: return img.transpose(Image.ROTATE_270) elif value == 7: return img.transpose(Image.ROTATE_270).transpose(Image.FLIP_LEFT_RIGHT) elif value == 8: return img.transpose(Image.ROTATE_90) else: return img return img
def getExif(filename): """Returns EXIF data from a file -- currently, creation date and orientation Args: filename""" exif = {} i = Image.open(filename) info = i._getexif() if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) exif[decoded] = value try: exif['DateTimeOriginal'] dtime = exif['DateTimeOriginal'] except KeyError: print "Caution: No EXIF datetime data" dtime = None except: #Any other error print "Error in reading EXIF date stamp" dtime = None try: exif['Orientation'] orient = exif['Orientation'] except KeyError: print "Caution: No EXIF orientation data" orient = 1 except: #Any other error print "Error in reading EXIF orientation information" orient = 1 return dtime, orient else: return None, None
def handle(self, *args, **options): for photo_id in options['photo_id']: try: img=PhotoImages.objects.get(id=photo_id) except PhotoAlbums.DoesNotExist: self.stdout.write('Not find PhotoImage for ID:"%s"'%photo_id) else: self.stdout.write('Get EXIF data (%s) for photo( album:%s, path:%s, filename:%s)'%(options['tags'],img.album.tag, img.path, img.filename)) full_path=os.path.join(img.album.base_path, img.path, img.filename) if os.path.exists(full_path): photo=Image.open(full_path) # Получаем Exif try: exif = photo._getexif() except: exif = None self.stdout.write('Error getting EXIF Data') if exif != None: for tag, value in exif.items(): decoded = TAGS.get(tag, tag) if options['taglist']: self.stdout.write('%s'%decoded) else: if isinstance(decoded,str): if ('all' in options['tags']) or (decoded.lower() in options['tags']) or (decoded in options['tags']): self.stdout.write('%s = %s'%(decoded,value)) else: self.stdout.write('Image file not found!')
def get_exif_data(filename): """Return a dict with the raw EXIF data.""" logger = logging.getLogger(__name__) if PIL.PILLOW_VERSION == '3.0.0': warnings.warn('Pillow 3.0.0 is broken with EXIF data, consider using ' 'another version if you want to use EXIF data.') img = PILImage.open(filename) try: exif = img._getexif() or {} except ZeroDivisionError: logger.warning('Failed to read EXIF data.') return None data = {TAGS.get(tag, tag): value for tag, value in exif.items()} if 'GPSInfo' in data: try: data['GPSInfo'] = {GPSTAGS.get(tag, tag): value for tag, value in data['GPSInfo'].items()} except AttributeError: logger = logging.getLogger(__name__) logger.info('Failed to get GPS Info') del data['GPSInfo'] return data
def remove_exif_orientation(file_path): ext = os.path.splitext(file_path)[1].lower() if ext == '.jpg' or ext == '.jpeg': img = Image.open(file_path) exif = img._getexif() if not exif: return orientation = 1 for (k, v) in exif.items(): if TAGS.get(k) == 'Orientation': orientation = v if orientation is 6: img = img.rotate(-90) elif orientation is 8: img = img.rotate(90) elif orientation is 3: img = img.rotate(180) elif orientation is 2: img = img.transpose(Image.FLIP_LEFT_RIGHT) elif orientation is 5: img = img.rotate(-90).transpose(Image.FLIP_LEFT_RIGHT) elif orientation is 7: img = img.rotate(90).transpose(Image.FLIP_LEFT_RIGHT) elif orientation is 4: img = img.rotate(180).transpose(Image.FLIP_LEFT_RIGHT) img.save(file_path)
def testForExif(imgFileName): try: exifData = {} imgFile = Image.open(imgFileName) info = imgFile._getexif() if info: for (tag,value) in info.items(): decoded = TAGS.get(tag,tag) exifData[decoded] = value exifGPS = exifData["GPSInfo"] if exifGPS: print("[*] {0} contains GPS MetaData".format(imgFileName)) return exifGPS else: return None except Exception,e: print("ERROR: ",e) return None
def __call__(self, data, **metadata): try: img = Image.open(cStringIO.StringIO(data)) except IOError: return None parts = [ ("Format", str(img.format_description)), ("Size", "%s x %s px" % img.size), ("Mode", str(img.mode)), ] for i in sorted(img.info.keys()): if i != "exif": parts.append( (str(i), str(img.info[i])) ) if hasattr(img, "_getexif"): ex = img._getexif() if ex: for i in sorted(ex.keys()): tag = TAGS.get(i, i) parts.append( (str(tag), str(ex[i])) ) fmt = format_dict(ODict(parts)) return "%s image" % img.format, fmt
def get_exif_header(image): """Returns a dictionary from the exif header of an PIL Image. Also converts the GPS Tags. Args: image: """ try: info = image._getexif() except: raise gserror.EmptyExifHeaderError('could not found the exif header') if not info: raise gserror.EmptyExifHeaderError('empty exif header') exif_header = {} for tag, value in info.items(): tag_id = TAGS.get(tag, tag) if tag_id == __EXIF_GPS_INFO: gps_info = {} for t in value: gps_tag_id = GPSTAGS.get(t, t) gps_info[gps_tag_id] = value[t] exif_header[tag_id] = gps_info else: exif_header[tag_id] = value return exif_header
def __call__(self, hdrs, content, limit): try: img = Image.open(cStringIO.StringIO(content)) except IOError: return None parts = [ ("Format", str(img.format_description)), ("Size", "%s x %s px"%img.size), ("Mode", str(img.mode)), ] for i in sorted(img.info.keys()): if i != "exif": parts.append( (str(i), str(img.info[i])) ) if hasattr(img, "_getexif"): ex = img._getexif() if ex: for i in sorted(ex.keys()): tag = TAGS.get(i, i) parts.append( (str(tag), str(ex[i])) ) clean = [] for i in parts: clean.append([utils.cleanBin(i[0]), utils.cleanBin(i[1])]) fmt = common.format_keyvals( clean, key = "header", val = "text" ) return "%s image"%img.format, fmt
def printExif(image): exifAttrs = set(["Model", "Make", "ExifImageWidth", "ExifImageHeight", "FocalLength"]) exif = {} info = image._getexif() if info: for attr, value in info.items(): decodedAttr = TAGS.get(attr, attr) if decodedAttr in exifAttrs: exif[decodedAttr] = value if 'FocalLength' in exif: exif['FocalLength'] = float(exif['FocalLength'][0])/float(exif['FocalLength'][1]) outputString = "" if ('Make' in exif): outputString += exif['Make'] outputString += "," if ('Model' in exif): outputString += exif['Model'] outputString += "," if ('FocalLength' in exif): outputString += str(exif['FocalLength']) outputString += "," outputString += str(exif['ExifImageWidth']) + "," + str(exif['ExifImageHeight']) print(outputString)
def get_tiff_tags(self): tifftags = self.image.tag.tags decoded = {} for a, b in tifftags.items(): val = TAGS.get(a,b) decoded[val] = b return decoded
def _get_exif_data(self, image): """Returns a dictionary from the exif data of an PIL Image item. Also converts the GPS Tags""" exif_data = {} try: info = image._getexif() except AttributeError: return exif_data except IndexError: return exif_data if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for t in value: sub_decoded = GPSTAGS.get(t, t) gps_data[sub_decoded] = value[t] exif_data[decoded] = gps_data else: exif_data[decoded] = value return exif_data
def get_exif(i): ret = {} info = i._getexif() for tag, value in info.items(): decoded = TAGS.get(tag, tag) ret[decoded] = value return ret
def get_exif_data(image): """Return a dict from the exif data of a PIL Image and convert the GPS tags. """ exif_data = {} info = image._getexif() if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for gps_tag in value: sub_decoded = GPSTAGS.get(gps_tag, gps_tag) gps_data[sub_decoded] = value[gps_tag] exif_data[decoded] = gps_data else: exif_data[decoded] = value return exif_data
def ImageToPixmap(fn): try: im = Image.open(fn) except: return None exif = {} try: info = im._getexif() except: info = None if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) exif[decoded] = value date = '' if 'DateTimeOriginal' in exif: # Date example: 2011:02:26 16:29:49 try: date2 = exif['DateTimeOriginal'] t = time.strptime(date2,"%Y:%m:%d %H:%M:%S") date = time2str(t) except: pass if 'Orientation' in exif: if exif['Orientation'] == 6: im = im.rotate(-90) elif exif['Orientation'] == 3: im = im.rotate(180) elif exif['Orientation'] == 8: im = im.rotate(90) data = im.convert('RGBA').tostring('raw', 'BGRA') image = QtGui.QImage(data, im.size[0], im.size[1], QtGui.QImage.Format_ARGB32) w,h = im.size size = str(w) + 'x' + str(h) return ((data, QtGui.QPixmap(image)), date+' '+size)
def get_GPS(file): """ 指定した画像のEXIFデータからGPS_infoを取り出す lat: 緯度 -90<=lat<=90, float, 小数点以下6桁 lon: 経度 -180<=lon<=180, float, 小数点以下6桁 """ im = Image.open(file) # Exif データを取得 # 存在しなければそのまま終了 空の辞書を返す try: exif = im._getexif() except AttributeError: return {} # タグIDそのままでは人が読めないのでデコードして、テーブルに格納する exif_table = {} for tag_id, value in exif.items(): tag = TAGS.get(tag_id, tag_id) exif_table[tag] = value # 緯度latの読み取り。Nを正、Sを負として処理する。 lat_dir = exif_table['GPSInfo'][1] lat = exif_table['GPSInfo'][2] if lat_dir[0] == "S": sgn = -1 else: sgn = 1 lat = sgn * (float(lat[0][0]) + float(lat[1][0]) / 60.0 + float(lat[2][0]) / 100.0 / 3600.0) lat = float("{:.6f}".format(lat)) # 経度lonの読み取り。Eを正、Wを負として処理する。 lon_dir = exif_table['GPSInfo'][3] lon = exif_table['GPSInfo'][4] if lon_dir[0] == "W": sgn = -1 else: sgn = 1 lon = sgn * (float(lon[0][0]) + float(lon[1][0]) / 60.0 + float(lon[2][0]) / 100.0 / 3600.0) lon = float("{:.6f}".format(lon)) return lat, lon
def parse_exif(exif): exifData = {} if exif: for (tag, value) in exif.items(): if value: decoded_tag = TAGS.get(tag, tag) if decoded_tag != 'GPSInfo': exifData[decoded_tag] = value else: for (key, val) in GPSTAGS.items(): if key in exif[tag]: exifData[val] = exif[tag][key] # Note: GPS Latitude and Longitude are represented in true rational64u format if 'GPSLatitude' in exifData.keys() and 'GPSLongitude' in exifData.keys(): parse_coordinates(exifData) parse_location(exifData) return exifData
def get_exif_of_image(self, file): im = Image.open(file) try: exif = im._getexif() except AttributeError: return {} if exif == None: return {} exif_table = {} for tag_id, value in exif.items(): tag = TAGS.get(tag_id, tag_id) exif_table[tag] = value return exif_table
def get_date_from_exif(file): im = Image.open(file) exif = im._getexif() exif_table = {} for tag_id, value in exif.items(): tag = TAGS.get(tag_id, tag_id) exif_table[tag] = value date_time = exif_table.get("DateTimeOriginal") # 'yyyy:mm:dd hh:mm:ss'というフォーマットなので # split(" ")により" "で分割し、最初の要素(日付に関する部分)のみ取得 date = date_time.split(" ")[0] # ディレクトリ作成用にフォーマットを'yyyy:mm:dd'から'yyyy-mm-dd'に変更 date = "-".join(date.split(":")) return date
def get_exif_data(image): exif_data = {} info = image._getexif() if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for gps_tag in value: sub_decoded = GPSTAGS.get(gps_tag, gps_tag) gps_data[sub_decoded] = value[gps_tag] exif_data[decoded] = gps_data else: exif_data[decoded] = value return exif_data
def get_exif_data(filename): """Get embedded EXIF data from image file. Source: <a href="http://www.endlesslycurious.com/2011/05/11/extracting-image-">http://www.endlesslycurious.com/2011/05/11/extract...</a> exif-data-with-python/ """ ret = {} try: img = Image.open(filename) if hasattr( img, '_getexif' ): exifinfo = img._getexif() if exifinfo != None: for tag, value in exifinfo.items(): decoded = TAGS.get(tag, tag) ret[decoded] = value except IOError: print ('IOERROR ' + filename) return ret
def get_exif_of_image(file): """Get EXIF of an image if exists. 指定した画像のEXIFデータを取り出す関数 @return exif_table Exif データを格納した辞書 """ im = Image.open(file) # Exif データを取得 # 存在しなければそのまま終了 空の辞書を返す try: exif = im._getexif() except AttributeError: return [] # タグIDそのままでは人が読めないのでデコードして # テーブルに格納する exif_table = {} for tag_id, value in exif.items(): tag = TAGS.get(tag_id, tag_id) exif_table[tag] = value data_requried = [ "Model", "LensModel", "ExposureTime", "FNumber", "ISOSpeedRatings", "Orientation" ] exif_data = {} for id in data_requried: try: if id == "Model" or id == "LensModel": exif_data[id] = exif_table[id] elif id == "ExposureTime": exif_data[id] = str(exif_table["ExposureTime"][0]) + "/" + str( exif_table["ExposureTime"][1]) elif id == "FNumber": exif_data[id] = "F" + str( exif_table["FNumber"][0] / exif_table["FNumber"][1]) elif id == "ISOSpeedRatings": exif_data[id] = "ISO " + str(exif_table["ISOSpeedRatings"]) #縦横判別情報も一緒に取り出しておく elif id == "Orientation": exif_data[id] = exif_table["Orientation"] except KeyError: pass return exif_data
def exif(self): exif_data = cache.get(self.exif_cache_key()) if exif_data is None: data = {} try: photo = Image.open(self.file) info = photo._getexif() for tag, value in info.items(): decoded = TAGS.get(tag, tag) data[decoded] = value cache.set(self.exif_cache_key(), data) exif_data = data except: exif_data = None return exif_data
def ExactImageMetadata(self, path): # path to the image or video imagename = path # read the image data using PIL image = Image.open(imagename) # extract EXIF data exifdata = image.getexif() #print(exifdata) # iterating over all EXIF data fields for tag_id in exifdata: # get the tag name, instead of human unreadable tag id tag = TAGS.get(tag_id, tag_id) data = exifdata.get(tag_id) # decode bytes if isinstance(data, bytes): data = data.decode() print(f"{tag:25}: {data}")
def update_exif(self): exif_data = {} self.data.open() with pImage.open(self.data) as img: if hasattr(img, '_getexif'): info = img.getexif() if not info: return {} for tag, value in info.items(): decoded = TAGS.get(tag, tag) exif_data[decoded] = value # Process some data for easy rendering in template exif_data['Camera'] = exif_data.get('Model', '') if exif_data.get( 'Make', '' ) not in exif_data['Camera']: # Work around for Canon exif_data['Camera'] = "{0} {1}".format( exif_data['Make'].title(), exif_data['Model']) if 'FNumber' in exif_data: exif_data['Aperture'] = str( exif_data['FNumber'].numerator / exif_data['FNumber'].denominator) if 'ExposureTime' in exif_data: exif_data['Exposure'] = "{0}/{1}".format( exif_data['ExposureTime'].numerator, exif_data['ExposureTime'].denominator) img.close() self.exif_camera = exif_data.get('Camera') self.exif_lens = exif_data.get('LensModel') self.exif_focal_length = exif_data.get('FocalLengthIn35mmFilm') self.exif_aperture = exif_data.get('Aperture') self.exif_exposure = exif_data.get('Exposure') self.exif_iso = exif_data.get('ISOSpeedRatings') self.exif_date_taken = None original_exif = exif_data.get('DateTimeOriginal') if original_exif: try: # EXIF is not timezone aware, but Django requires a timezone, so the best we can do is assume UTC date_taken = datetime.strptime(original_exif, "%Y:%m:%d %H:%M:%S") self.exif_date_taken = timezone.make_aware( date_taken, pytz.timezone('UTC')) except ValueError: # Fall back to file modification time pass
def testForExif(imgFileName): try: exifData = {} imgFile = Image.open(imgFileName) print("GetExif()") info = imgFile._getexif() if info: for (tag, value) in info.items(): decoded = TAGS.get(tag, tag) exifData[decoded] = value exifGPS = exifData['GPSInfo'] if exifGPS: print("[*] " + imgFileName + ' contains GPS MetaData') else: print("[-] No MetaData found for these images") except: pass
def open_exif(self, img): exif = img._getexif() ret = {} gps = {} for tag, value in exif.items(): decoded = TAGS.get(tag, tag) ret[decoded] = value # Getting GPS lat, long if decoded == "GPSInfo": gps_data = {} for t in value: sub_decoded = GPSTAGS.get(t, t) gps_data[sub_decoded] = value[t] gps[decoded] = gps_data return ret, gps
def get_exif(image_file_path): exif_table = {} image = Image.open(image_file_path) info = image.getexif() for tag, value in info.items(): decoded = TAGS.get(tag, tag) exif_table[decoded] = value gps_info = {} for key in exif_table['GPSInfo']: decode = GPSTAGS.get(key, key) gps_info[decode] = exif_table['GPSInfo'][key] if gps_info: return gps_info else: return "No GPS data found!"
def get_exif_data(self): exif_data = {} info = self.image._getexif() if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for t in value: sub_decoded = GPSTAGS.get(t, t) gps_data[sub_decoded] = value[t] exif_data[decoded] = gps_data else: exif_data[decoded] = value self.exif_data = exif_data return exif_data
def get_image_tags(file_path): u""" Получить тэги изображения (EXIF) """ img = Image.open(file_path) if not hasattr(img, '_getexif'): return {} info = img._getexif() if not info: return {} res = {} for tag, value in info.items(): decoded = TAGS.get(tag, tag) res[decoded] = value return res
def _get_pair(self, scene, map_path, img_path): uav_pil_img = Image.open(img_path) exifdata = uav_pil_img.getexif() for tag_id in exifdata: tag = TAGS.get(tag_id, tag_id) if re.match(r'.*GPS.*', str(tag)): info = exifdata.get(tag_id) lat = info[2] lon = info[4] break uav_img_arr = np.array(uav_pil_img) uav_loc = decimal_gps(lon, lat) map_img_arr = cv.imread(map_path) map_img_arr = cv.cvtColor(map_img_arr, cv.COLOR_BGR2RGB) map_geo = self._map_geo.loc[scene, ['left', 'top', 'right', 'bottom']].values return uav_img_arr, uav_loc, map_img_arr, map_geo
def get_gps_data(i): info = i._getexif() exif_data = {} lat = np.nan lon = np.nan alt = np.nan for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for t in value: sub_decoded = GPSTAGS.get(t, t) gps_data[sub_decoded] = value[t] lat, lon, alt = latlon_from_gps_data(gps_data) return lat, lon, alt
def parseExif(self): img = Image.open(self.fp) ret = {} if hasattr(img, '_getexif'): exifinfo = img._getexif() if exifinfo != None: for tag, value in exifinfo.items(): decoded = TAGS.get(tag, tag) if isinstance(value, type("123")): try: value = value.decode() except: value = "" ret[decoded] = value self.exif = ret return ret return {}
def get_exif(filename): exif = Image.open(filename)._getexif() #print(type(exif)) if exif is not None: exif_copy = exif.copy() for key, value in exif_copy.items(): name = TAGS.get(key, key) exif[name] = exif.pop(key) new_exif = {} if 'GPSInfo' in exif: for key in exif['GPSInfo'].keys(): name = GPSTAGS.get(key, key) new_exif[name] = exif['GPSInfo'][key] return new_exif
def testForExif(imgFileName): try: exifData = {} imgFile = Image.open(imgFileName) info = imgFile._getexif() if info: for (tag, value) in info.items(): decoded = TAGS.get(tag, tag) exifData[decoded] = value exifGPS = exifData['GPSInfo'] if exifGPS: print '[*] ' + imgFileName + ' contains GPS meta data' except: pass
def get_exif_data(self): exif_data = {} with open(self.filepath, 'rb') as infile: tags = exifread.process_file(infile) for tag, value in tags.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for t in value: sub_decoded = GPSTAGS.get(t, t) gps_data[sub_decoded] = value[t] exif_data[decoded] = gps_data else: exif_data[decoded] = str(value) # self._exif_data = exif_data return exif_data
def writeLists(D): outfile = open(D + "list.txt", 'w') for f in os.listdir(D): if f.endswith(".jpg"): img = Image.open(D + f) exif_data = {} info = img._getexif() for tag, value in info.items(): decoded = TAGS.get(tag, tag) exif_data[decoded] = value nominator = exif_data["ExposureTime"][1] / exif_data[ "ExposureTime"][0] outfile.write(f + "\t" + str(nominator) + "\n") outfile.close()
def identify_tags(self, infile: str) -> dict: """Read infile, return dict with relevant tags.""" _tags = {} logging.debug(f"identify_tags: {infile}") with Image.open(infile) as im: exifdata = im.getexif() for tag_id in exifdata: # get the tag name, instead of human unreadable tag id tag = TAGS.get(tag_id, tag_id) data = exifdata.get(tag_id) if tag == "DateTime": _tags[tag] = data logging.debug(f"Tag: {tag} - data: {data}") logging.debug(f"Return tags: {_tags}") return _tags
def get_exif_data(fn): """Returns a dictionary from the exif data of an PIL Image item. Also converts the GPS Tags""" exif_data = {} i = Image.open(fn) info = i._getexif() if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for t in value: sub_decoded = GPSTAGS.get(t, t) gps_data[sub_decoded] = value[t] exif_data[decoded] = gps_data else: exif_data[decoded] = value return exif_data
def get_exif_data(image): #get exif data from the image exif_data = {} info = image._getexif() if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) if decoded == "GPSInfo": gps_data = {} for t in value: sub_decoded = GPSTAGS.get(t, t) gps_data[sub_decoded] = value[t] exif_data[decoded] = gps_data else: exif_data[decoded] = value return exif_data
def retrieveExifData(self, file): exifDictionary = {} fileHandle = None try: fileHandle = Image.open(file, "r") exifInfo = fileHandle._getexif() for tag, value in exifInfo.items(): retrieved = TAGS.get(tag, tag) exifDictionary[retrieved] = value utility.logStringToFile(self.validFilesOutputFile, 'a', str('FileName: ' + str(file) + '\n')) except Exception as e: utility.logStringToFile(self.invalidFilesOutputFile, 'a', str('FileName: ' + str(file) + '\n')) return exifDictionary
def _extract_exif(self): ret = {} # ipdb.set_trace() i = PIL.Image.open(self.image_path) info = i._getexif() for tag, value in info.items(): decoded = EXIFTAGS.get(tag, tag) ret[decoded] = value with open(self.image_path, 'rb') as fimg: exif = exifread.process_file(fimg, details=False) serializable = dict([key, value.printable] for key, value in exif.items()) self.exif_json = serializable # ipdb.set_trace() if 'EXIF DateTimeOriginal' in exif.keys(): tst_str = exif['EXIF DateTimeOriginal'].values try: tst_dt = datetime.strptime(tst_str, "%Y:%m:%d %H:%M:%S") except: tst_dt = datetime.strptime(tst_str, "%Y-%m-%d %H:%M:%S") # ipdb.set_trace() self.exif_timestamp = tst_dt else: self.exif_timestamp = None if 'GPS GPSLongitude' in exif.keys(): self.exif_gps_lon = util.convert_to_degrees( exif['GPS GPSLongitude'].values) # Check for correct positive/negative degrees if exif['GPS GPSLongitudeRef'].values != 'E': self.exif_gps_lon = -self.exif_gps_lon else: self.exif_gps_lon = None if 'GPS GPSLatitude' in exif.keys(): self.exif_gps_lat = util.convert_to_degrees( exif['GPS GPSLatitude'].values) # Check for correct positive/negative degrees if exif['GPS GPSLatitudeRef'].values != 'N': self.exif_gps_lat = -self.exif_gps_lat else: self.exif_gps_lat = None
def process_image(file): rfname = os.path.join(temp_dir, str(uuid.uuid4()) + os.path.splitext(file.name)[1]) try: f = open(rfname, 'wb') fname = str(uuid.uuid4()) + os.path.splitext(file.name)[-1].lower() small = '%s.small%s' % os.path.splitext(fname) while True: data = file.file.read(8192) f.write(data) if not data: break f.close() img = Image.open(rfname) img.thumbnail((500, 500)) try: exif = img._getexif() if exif: exif = {TAGS.get(k): v for k, v in exif.items()} if 'Orientation' in exif: orientation = exif['Orientation'] if orientation == 6: img = img.rotate(-90) elif orientation == 8: img = img.rotate(90) elif orientation == 3: img = img.rotate(180) except: pass r = fname fname = os.path.join(dest_dir, fname) small = os.path.join(dest_dir, small) img.save(fname) img.thumbnail((120, 120)) img.save(small) img.close() finally: if os.path.isfile(rfname): os.unlink(rfname) return { 'image': 'tmp/' + r, 'small': 'tmp/' + os.path.basename(small), }
def image_view(request): if request.method == 'POST': form = ImageForm(request.POST, request.FILES) if form.is_valid(): form.save() print(form.cleaned_data) image_table = db.image_image filename = str(form.cleaned_data['image']) image_id = image_table.find_one( {'image': 'images' + '/' + filename})['id'] path = 'media/images/' + filename size = os.path.getsize(path) / (1024 * 1024) image = Image.open(path) exifdata = image.getexif() metadata = {"name": filename, 'id': image_id, 'size': int(size)} for tag_id in exifdata: # get the tag name, instead of human unreadable tag id tag = TAGS.get(tag_id, tag_id) data = exifdata.get(tag_id) # decode bytes if isinstance(data, bytes): data = data.decode() print(f"{tag}: {data}") try: metadata.update({tag: float(str(data))}) except: metadata.update({tag: str(data)}) metacollection = db.metacollection result = metacollection.insert_one(metadata) print('One post: {0}'.format(result.inserted_id)) data = { 'success': True, 'message': 'Upload and metadata extraction succesful', 'form': ImageForm() } return render(request, 'upload.html', data) else: form = ImageForm() data = {'form': form, 'success': False} return render(request, 'upload.html', data)
def get_exif(imgFileName): pp = pprint.PrettyPrinter(indent=4) try: exifData = {} imgFile = Image.open(imgFileName) info = imgFile._getexif() if info: for (tag, value) in info.items(): decoded = TAGS.get(tag, tag) exifData[decoded] = value for key, value in exifData.iteritems(): if key == 'GPSInfo': print Style.BRIGHT + Fore.GREEN + "GPS Info:" + Style.RESET_ALL pp.pprint(value) if key == 'Manufacturer': print Style.BRIGHT + Fore.GREEN + "Manufacturer:" + Style.RESET_ALL print value if key == 'Model': print Style.BRIGHT + Fore.GREEN + "Model:" + Style.RESET_ALL print value if key == 'Make': print Style.BRIGHT + Fore.GREEN + "Make:" + Style.RESET_ALL print value if key == 'Software': print Style.BRIGHT + Fore.GREEN + "Software:" + Style.RESET_ALL print value if key == 'DateTimeOriginal': print Style.BRIGHT + Fore.GREEN + "Date Created:" + Style.RESET_ALL print value if key == 'Creating Application': print Style.BRIGHT + Fore.GREEN + "Creating Application:" + Style.RESET_ALL print value else: pass except: pass
def get_exif_data(image): """Returns a dictionary from the exif data of an PIL Image item. Also converts the GPS Tags""" try: info = image._getexif() except AttributeError: return {} if not info: return {} exif_data = {TAGS.get(tag, tag): value for tag, value in info.items()} def is_fraction(val): return isinstance(val, tuple) and len(val) == 2 and isinstance(val[0], int) and isinstance(val[1], int) def frac_to_dec(frac): return float(frac[0]) / float(frac[1]) if "GPSInfo" in exif_data: gpsinfo = {GPSTAGS.get(t, t): v for t, v in exif_data["GPSInfo"].items()} for tag, value in gpsinfo.items(): if is_fraction(value): gpsinfo[tag] = frac_to_dec(value) elif all(is_fraction(x) for x in value): gpsinfo[tag] = tuple(map(frac_to_dec, value)) exif_data["GPSInfo"] = gpsinfo return exif_data
def get_exif_data(image): """ Returns a dictionary from the exif data of an PIL Image item. Also converts the GPS Tags https://gist.github.com/valgur/2fbed04680864fab1bfc """ info = image._getexif() if not info: return {} exif_data = {TAGS.get(tag, tag): value for tag, value in info.items()} def is_fraction(val): return isinstance(val, tuple) and len(val) == 2 and isinstance( val[0], int) and isinstance(val[1], int) def frac_to_dec(frac): return float(frac[0]) / float(frac[1]) if 'GPSInfo' in exif_data: gpsinfo = {GPSTAGS.get(t, t): v for t, v in exif_data['GPSInfo'].items()} for tag, value in gpsinfo.items(): if is_fraction(value): gpsinfo[tag] = frac_to_dec(value) elif all(is_fraction(x) for x in value): gpsinfo[tag] = tuple(map(frac_to_dec, value)) exif_data['GPSInfo'] = gpsinfo return exif_data