पायथन में, मैं एक छवि के लिए एक्सिफ डेटा कैसे पढ़ता हूं?

Question

मैं पीआईएल का उपयोग कर रहा हूं। मैं EXIF ​​डेटा को सामान के शब्दकोश में कैसे बदलूं?

Comments

यहां देखें उत्तर: stackoverflow.com/questions/765396/…

— डेविड वूल्वर

Tilloy.net/dev/pyexiv2/tutorial.html यह सबसे आसान और सबसे व्यापक है।

— कुमार दीपक

यहाँ अधिक हाल के प्रश्न: stackoverflow.com/questions/14009148/exif-reading-library

— एंटनी हैचकिंस

Answer 1

इसे इस्तेमाल करे:

import PIL.Image
img = PIL.Image.open('img.jpg')
exif_data = img._getexif()

यह आपको EXIF ​​संख्यात्मक टैग द्वारा अनुक्रमित एक शब्दकोश देना चाहिए। यदि आप वास्तविक EXIF ​​टैग नाम तार द्वारा अनुक्रमित शब्दकोश चाहते हैं, तो कुछ इस तरह आज़माएँ:

import PIL.ExifTags
exif = {
    PIL.ExifTags.TAGS[k]: v
    for k, v in img._getexif().items()
    if k in PIL.ExifTags.TAGS
}

Comments

कोई पायथन 3 विकल्प?

— संतोष कुमार

@ 2rs2ts: import ExifTags( PILउपसर्ग के बिना ) प्रयास करें ।

— फ्लोरियन ब्रूकर 22

पाइथन 3 के लिए पिलो का उपयोग करें। यह पीआईएल का एक कांटा है, जिसे अभी भी विकसित किया जा रहा है, और इसमें एक python3 संगत संस्करण है

— मेज़ल

क्या आप इस प्रश्न पर इसका परीक्षण कर सकते हैं, चित्र डाउनलोड कर सकते हैं और ImageDescription प्राप्त करने का प्रयास कर सकते हैं। stackoverflow.com/questions/22173902/…

— एजे

बस संदर्भ एक्सिफ

— Deus777

Answer 2

आप ExifRead मॉड्यूल का उपयोग भी कर सकते हैं :

import exifread
# Open image file for reading (binary mode)
f = open(path_name, 'rb')

# Return Exif tags
tags = exifread.process_file(f)

Comments

क्या आप इस प्रश्न पर इसका परीक्षण कर सकते हैं, चित्र डाउनलोड कर सकते हैं और ImageDescription प्राप्त करने का प्रयास कर सकते हैं। stackoverflow.com/questions/22173902/…

— एजे

@ दोनों छवियों के लिए केल्टन, खाली शब्द देता है। लेकिन मैंने अपनी तस्वीरों पर परीक्षण किया और यह ठीक काम करता है।

— tnq177

मुझे चित्रों के एक सेट के लिए एक खाली शब्दकोष भी प्राप्त है। क्या कोई टिप्पणी कर सकता है कि यह मामला क्यों है? किस प्रकार की छवियां exifread.process_file () के साथ काम करती हैं?

— मोम्चिल

Answer 3

मैं इसका उपयोग करता हूं:

import os,sys
from PIL import Image
from PIL.ExifTags import TAGS

for (k,v) in Image.open(sys.argv[1])._getexif().iteritems():
        print '%s = %s' % (TAGS.get(k), v)

या एक विशिष्ट क्षेत्र प्राप्त करने के लिए:

def get_field (exif,field) :
  for (k,v) in exif.iteritems():
     if TAGS.get(k) == field:
        return v

exif = image._getexif()
print get_field(exif,'ExposureTime')

Comments

बेहतर है, आप TAGS को उल्टा कर सकते हैं name2tagnum = dict((name, num) for num, name in TAGS.iteritems())और फिर कर सकते हैं name2tagnum['ExposureTime']।

— बेन

अजगर 3 के लिए, बदलने exif.iteritems()के लिएexif.items()

— SPRBRN

Answer 4

Python3.x और शुरू करने के लिए Pillow==6.0.0, Imageऑब्जेक्ट अब एक ऐसा getexif()तरीका प्रदान करते हैं जो रिटर्न करता है <class 'PIL.Image.Exif'>या Noneयदि छवि में कोई EXIF ​​डेटा नहीं है।

से तकिया 6.0.0 रिलीज नोट्स :

getexif()जोड़ा गया है, जो एक Exifउदाहरण देता है । मान प्राप्त किया जा सकता है और एक शब्दकोश की तरह सेट किया जा सकता है। JPEG, PNG या WEBP को सहेजते समय, उदाहरण exifको आउटपुट इमेज में किसी भी बदलाव को शामिल करने के लिए एक तर्क के रूप में पारित किया जा सकता है ।

Exifउत्पादन केवल एक करने के लिए casted किया जा सकता है dict, ताकि EXIF डेटा फिर एक के नियमित कुंजी-मान जोड़ों के रूप में पहुँचा जा सकता है dict। कुंजियाँ 16-बिट पूर्णांक हैं जिन्हें ExifTags.TAGSमॉड्यूल का उपयोग करके उनके स्ट्रिंग नामों में मैप किया जा सकता है ।

from PIL import Image, ExifTags

img = Image.open("sample.jpg")
img_exif = img.getexif()
print(type(img_exif))
# <class 'PIL.Image.Exif'>

if img_exif is None:
    print("Sorry, image has no exif data.")
else:
    img_exif_dict = dict(img_exif)
    print(img_exif_dict)
    # { ... 42035: 'FUJIFILM', 42036: 'XF23mmF2 R WR', 42037: '75A14188' ... }
    for key, val in img_exif_dict.items():
        if key in ExifTags.TAGS:
            print(f"{ExifTags.TAGS[key]}:{repr(val)}")
            # ExifVersion:b'0230'
            # ...
            # FocalLength:(2300, 100)
            # ColorSpace:1
            # FocalLengthIn35mmFilm:35
            # ...
            # Model:'X-T2'
            # Make:'FUJIFILM'
            # ...
            # DateTime:'2019:12:01 21:30:07'
            # ...

पायथन 3.6.8 के साथ परीक्षण किया गया और Pillow==6.0.0।

Comments

यह मेरे लिए काम नहीं करता है, मैं बाइनरी में .info पद्धति का उपयोग करके केवल एक्सिफ डेटा देख सकता हूं

— जीएम

Answer 5

import sys
import PIL
import PIL.Image as PILimage
from PIL import ImageDraw, ImageFont, ImageEnhance
from PIL.ExifTags import TAGS, GPSTAGS



class Worker(object):
    def __init__(self, img):
        self.img = img
        self.exif_data = self.get_exif_data()
        self.lat = self.get_lat()
        self.lon = self.get_lon()
        self.date =self.get_date_time()
        super(Worker, self).__init__()

    @staticmethod
    def get_if_exist(data, key):
        if key in data:
            return data[key]
        return None

    @staticmethod
    def convert_to_degress(value):
        """Helper function to convert the GPS coordinates
        stored in the EXIF to degress in float format"""
        d0 = value[0][0]
        d1 = value[0][1]
        d = float(d0) / float(d1)
        m0 = value[1][0]
        m1 = value[1][1]
        m = float(m0) / float(m1)

        s0 = value[2][0]
        s1 = value[2][1]
        s = float(s0) / float(s1)

        return d + (m / 60.0) + (s / 3600.0)

    def get_exif_data(self):
        """Returns a dictionary from the exif data of an PIL Image item. Also
        converts the GPS Tags"""
        exif_data = {}
        info = self.img._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_lat(self):
        """Returns the latitude and longitude, if available, from the 
        provided exif_data (obtained through get_exif_data above)"""
        # print(exif_data)
        if 'GPSInfo' in self.exif_data:
            gps_info = self.exif_data["GPSInfo"]
            gps_latitude = self.get_if_exist(gps_info, "GPSLatitude")
            gps_latitude_ref = self.get_if_exist(gps_info, 'GPSLatitudeRef')
            if gps_latitude and gps_latitude_ref:
                lat = self.convert_to_degress(gps_latitude)
                if gps_latitude_ref != "N":
                    lat = 0 - lat
                lat = str(f"{lat:.{5}f}")
                return lat
        else:
            return None

    def get_lon(self):
        """Returns the latitude and longitude, if available, from the 
        provided exif_data (obtained through get_exif_data above)"""
        # print(exif_data)
        if 'GPSInfo' in self.exif_data:
            gps_info = self.exif_data["GPSInfo"]
            gps_longitude = self.get_if_exist(gps_info, 'GPSLongitude')
            gps_longitude_ref = self.get_if_exist(gps_info, 'GPSLongitudeRef')
            if gps_longitude and gps_longitude_ref:
                lon = self.convert_to_degress(gps_longitude)
                if gps_longitude_ref != "E":
                    lon = 0 - lon
                lon = str(f"{lon:.{5}f}")
                return lon
        else:
            return None

    def get_date_time(self):
        if 'DateTime' in self.exif_data:
            date_and_time = self.exif_data['DateTime']
            return date_and_time 

if __name__ == '__main__':
    try:
        img = PILimage.open(sys.argv[1])
        image = Worker(img)
        lat = image.lat
        lon = image.lon
        date = image.date
        print(date, lat, lon)

    except Exception as e:
        print(e)

Answer 6

मैंने पाया है कि ._getexifअधिक अजगर संस्करणों में काम नहीं करता है, इसके अलावा, यह एक संरक्षित वर्ग है और यदि संभव हो तो इसका उपयोग करने से बचना चाहिए। डिबगर के आसपास खुदाई करने के बाद यह वही है जो मैंने एक छवि के लिए EXIF ​​डेटा प्राप्त करने का सबसे अच्छा तरीका पाया:

from PIL import Image

def get_exif(path):
    return Image.open(path).info['parsed_exif']

यह एक छवि के सभी EXIF ​​डेटा का एक शब्दकोश देता है।

नोट: Python3.x के लिए PIL के बजाय तकिया का उपयोग करें

Comments

info['parsed_exif']पिलो 6.0 या नए की आवश्यकता है। info['exif']5.4 में उपलब्ध है, लेकिन यह एक कच्चा बाइटस्ट्रिंग है।

— .स्मिन्द

info['parsed_exif']संस्करण 7.0.0 में कोई भी नहीं है; केवल info['exif']।

— ZF007

Answer 7

यहाँ वह है जिसे पढ़ना थोड़ा आसान हो सकता है। आशा है कि यह उपयोगी है।

from PIL import Image
from PIL import ExifTags

exifData = {}
img = Image.open(picture.jpg)
exifDataRaw = img._getexif()
for tag, value in exifDataRaw.items():
    decodedTag = ExifTags.TAGS.get(tag, tag)
    exifData[decodedTag] = value

Answer 8

मैं आमतौर पर JPG फ़ाइलों में सूचनाओं को सेट करने के लिए pyexiv2 का उपयोग करता हूं, लेकिन जब मैं एक स्क्रिप्ट QGIS स्क्रिप्ट क्रैश में लाइब्रेरी आयात करता हूं।

मुझे लाइब्रेरी एक्सफ़ का उपयोग करके एक समाधान मिला:

https://pypi.org/project/exif/

यह उपयोग करना इतना आसान है, और Qgis I डॉन के साथ, कोई समस्या नहीं है।

इस कोड में मैं जीपीएस निर्देशांक को स्क्रीन के स्नैपशॉट में सम्मिलित करता हूं:

from exif import Image
with open(file_name, 'rb') as image_file:
    my_image = Image(image_file)

my_image.make = "Python"
my_image.gps_latitude_ref=exif_lat_ref
my_image.gps_latitude=exif_lat
my_image.gps_longitude_ref= exif_lon_ref
my_image.gps_longitude= exif_lon

with open(file_name, 'wb') as new_image_file:
    new_image_file.write(my_image.get_file())