コード例 #1
0
    def get_property_pages(self, files):

        # test file type
        if len(files) != 1: return
        file = files[0]
        if file.get_uri_scheme() != 'file': return

        # if mimetype corresponds to an image, read exif tags
        #if file.get_mime_type() in ('image/jpeg' 'image/png'):
        mimetype = file.get_mime_type().split('/')
        if mimetype[0] == "image":

            # create label and grid
            self.property_label = Gtk.Label('EXIF')
            self.property_label.show()
            self.grid = Gtk.Grid()
            self.grid.set_margin_start(10)
            self.grid.set_margin_end(10)
            self.grid.set_margin_top(5)
            self.grid.set_margin_bottom(5)
            self.grid.show()

            # display title
            self.dislayTag("<b>Tag</b>", "<b>Readable value</b>",
                           "<b>Raw value</b>", 0, 0)
            gtk_separator = Gtk.Separator(
                orientation=Gtk.Orientation.HORIZONTAL)
            self.grid.attach(gtk_separator, 0, 1, 3, 1)

            # read metadata from file
            filename = unquote(file.get_uri()[7:])
            self.tags = Metadata()
            self.tags.open_path(filename)

            # loop thru the tags
            index = 0
            for name in self.tags:
                interpreted = self.tags.get_tag_interpreted_string(name)[0:64]
                string_raw = self.tags.get_tag_string(name)[0:64]
                if interpreted == string_raw: string_raw = ""
                else: string_raw = "<i>" + string_raw + "</i>"
                name = "<b>" + name + "</b>"
                self.dislayTag(name, interpreted, string_raw, 0, index + 2)
                index = index + 1

            # declare main scrolled window
            self.window = Gtk.ScrolledWindow()
            self.window.add_with_viewport(self.grid)
            self.window.show_all()

            # return label and tab content
            return Nautilus.PropertyPage(name="NautilusPython::tags_info",
                                         label=self.property_label,
                                         page=self.window),
コード例 #2
0
 def get_preview_sizes(self, metadata: GExiv2.Metadata):
     previews = metadata.get_preview_properties()
     sizes_and_types = []
     for idx, preview in enumerate(previews):
         image = metadata.get_preview_image(preview)
         sizes_and_types.append(
             (image.get_width(), image.get_height(), image.get_extension()))
     self.preview_size_and_types = "; ".join([
         "{}x{} {}".format(width, height, ext[1:])
         for width, height, ext in sizes_and_types
     ])
コード例 #3
0
    def thumbnail_extract(self, metadata: GExiv2.Metadata, size_in_bytes) -> bool:
        thumbnail = metadata.get_exif_thumbnail()
        if not thumbnail:
            previews = metadata.get_preview_properties()
            if previews:
                # In every RAW file I've analyzed, the smallest preview is always first
                preview = previews[0]
                thumbnail = metadata.get_preview_image(preview).get_data()

        if thumbnail == self.exif_thumbnail_or_preview:
            self.minimum_exif_read_size_in_bytes_thumbnail = size_in_bytes
            return True
        return False
コード例 #4
0
def getMeta(path, args):
    m = Metadata(path)

    if args.print:
        print(
            'getMeta: {} exif_tags, {} iptc_tags, {} xmp_tags, path {}, dateFromDirname {}'
            .format(
                len(m.get_exif_tags()), len(m.get_iptc_tags()),
                len(m.get_xmp_tags()), path,
                dateFromDirname.strftime(DATE_FORMAT)
                if dateFromDirname else None))

        for t in m.get_tags():
            # if t != 'Exif.Photo.MakerNote': # avoid big binary? item
            if any(x in t for x in [
                    'Date', 'Image.Make', 'Model', 'Categories', 'GPS',
                    'Latitude', 'Longitude'
            ]):
                print('getMeta: {} -> {}'.format(t, m.get(t)))
            if any(x in t for x in [
                    'Tags', 'LastKeywordXMP', 'HierarchicalSubject',
                    'CatalogSets', 'Subject', 'Keywords'
            ]):
                print('getMeta: {} => [ {} ]'.format(
                    t, ', '.join(m.get_tag_multiple(t))))

    return m
コード例 #5
0
 def assign_photo_attributes(self, metadata: GExiv2.Metadata) -> None:
     # I don't know how GExiv2 gets these values:
     self.width = metadata.get_pixel_width()
     self.height = metadata.get_pixel_height()
     try:
         self.orientation = metadata.get_tag_string('Exif.Image.Orientation')
     except KeyError:
         pass
     if metadata.has_tag('Exif.Image.Make') and metadata.has_tag('Exif.Image.Model'):
         self.model = '{} {}'.format(
             metadata.get_tag_string('Exif.Image.Make').strip(),
             metadata.get_tag_string('Exif.Image.Model').strip()
         )
     self.has_gps = metadata.get_gps_info()[0]
     self.iso = metadata.get_iso_speed()
     self.datetime = photo_date_time(metadata)
コード例 #6
0
    def extract_thumbnail(self, metadata: GExiv2.Metadata) -> None:
        # not all files have an exif preview, but all CR2 & CR3 seem to
        exif_thumbnail = metadata.get_exif_thumbnail()
        self.process_exif_thumbnail(thumbnail=exif_thumbnail)

        previews = metadata.get_preview_properties()
        self.no_previews = len(previews)

        for idx, preview in enumerate(previews):
            image = metadata.get_preview_image(preview)
            if image.get_width() >= 160 and image.get_height() >= 120:
                preview_thumbnail = metadata.get_preview_image(preview).get_data()
                if self.has_exif_thumbnail:
                    self.exif_thumbnail_and_preview_identical = preview_thumbnail == exif_thumbnail
                else:
                    self.exif_thumbnail_or_preview = preview_thumbnail
                self.preview_source = PreviewSource(idx).name.replace('_', ' ').capitalize()
                self.preview_width = image.get_width()
                self.preview_height = image.get_height()
                self.preview_extension = image.get_extension()
                return
コード例 #7
0
def metadata_comp_table(files):
    # Extract tags for each file
    tags = {}
    for f in files:
        exif = Metadata()
        exif.open_path(f)
        tags[f] = {(x, exif[x]) for x in exif.get_tags()}
    # Compute common tags intersecting all sets
    commontags = tags[files[0]]
    for f in tags:
        commontags = commontags.intersection(tags[f])
    # Delete common tags for each entry
    for f in tags:
        tags[f] = tags[f] - commontags
    # Print results
    head = ["Tag"] + [os.path.basename(x) for x in files]
    tab = []
    alluniquetags = set()
    for f in tags:
        alluniquetags |= ({x[0] for x in tags[f]})
    for t in alluniquetags:
        aux = [t]
        for f in files:
            if t in [x[0] for x in tags[f]]:
                aux.append(dict(tags[f])[t][:200])
            else:
                aux.append("-")
        tab.append(aux)
    t = tt.Texttable()
    t.header(head)
    t.add_rows(tab, header=False)
    t.set_deco(t.HEADER)
    t.set_chars(['-', '|', '+', '-'])
    maxw = len(max(alluniquetags, key=len)) if alluniquetags else 5
    arrw = [maxw] + [25] * len(files)
    t.set_cols_width(arrw)
    print()
    print(t.draw())
    print("\n(Unique fields only. Common EXIF tags have been omitted)")
    print()
コード例 #8
0
ファイル: jpegdupes.py プロジェクト: jesjimher/imgdupes
def metadata_comp_table(files):
    # Extract tags for each file
    tags={}
    for f in files:
        exif=Metadata()
        exif.open_path(f)
        tags[f]={(x,exif[x]) for x in exif.get_tags()}
    # Compute common tags intersecting all sets
    commontags=tags[files[0]]
    for f in tags:
        commontags=commontags.intersection(tags[f])
    # Delete common tags for each entry
    for f in tags:
        tags[f]=tags[f]-commontags
    # Print results
    head=["Tag"]+[os.path.basename(x) for x in files]
    tab=[]
    alluniquetags=set()
    for f in tags:
        alluniquetags|=({x[0] for x in tags[f]})
    for t in alluniquetags:
        aux=[t]
        for f in files:
            if t in [x[0] for x in tags[f]]:
                aux.append(dict(tags[f])[t][:200])
            else:
                aux.append("-")
        tab.append(aux)
    t=tt.Texttable()
    t.header(head)
    t.add_rows(tab,header=False)
    t.set_deco(t.HEADER)
    t.set_chars(['-','|','+','-'])
    maxw=len(max(alluniquetags,key=len)) if alluniquetags else 5
    arrw=[maxw]+[25]*len(files)
    t.set_cols_width(arrw)
    print()
    print(t.draw())
    print("\n(Unique fields only. Common EXIF tags have been omitted)")
    print()
コード例 #9
0
ファイル: indexer.py プロジェクト: pwrozycki/homesite
    def get_image_aspect_ratio(cls, file_phys_path):
        metadata = Metadata()
        metadata.open_path(file_phys_path)
        aspect_ratio = metadata.get_pixel_width() / metadata.get_pixel_height()

        # sideways rotation -> 90 or 270 degrees aspect ratio should be inverted
        if metadata.get_tag_long('Exif.Image.Orientation') in (6, 8):
            aspect_ratio = 1 / aspect_ratio

        return aspect_ratio
コード例 #10
0
  def get_property_pages(self, files):
    # default map size and zoom factor
    sizeMap = "512x512"
    zoomMap = "7"
  
    # test file type
    file = files[0]
    if len(files) != 1: return
    if file.get_uri_scheme() != 'file': return

    # if mimetype corresponds to JPG image, read data and populate tab
    mimetype = file.get_mime_type().split('/')
    if mimetype[0] in ('image'):
    
      # create tab
      self.tab = Gtk.Label('GPS')
      self.tab.show()

      # create grid
      self.grid = Gtk.Grid()
      self.grid.set_margin_start(10)
      self.grid.set_margin_end(10)
      self.grid.set_margin_top(5)
      self.grid.set_margin_bottom(5)
      self.grid.show()

      # create main scrolled window
      self.window = Gtk.ScrolledWindow()
      self.window.add_with_viewport(self.grid)
      self.window.show_all()

      # read metadata from file
      filename = unquote(file.get_uri()[7:])
      self.tags = Metadata()
      self.tags.open_path(filename)

      # get signed GPS position
      latitude  = self.tags.get_gps_latitude()
      longitude = self.tags.get_gps_longitude()
      altitude  = self.tags.get_gps_altitude()

      # if no GPS data, return
      if latitude == 0 and longitude == 0 and altitude == 0: return

      # trunk GPS data to 6 digits
      parts = str(latitude).split(".")
      strLatitude = parts[0] + "." + parts[1][:6]
      parts = str(longitude).split(".")
      strLongitude = parts[0] + "." + parts[1][:6]
      strAltitude = str(altitude)

      # generate GPS position
      strPosition = strLatitude + ',' + strLongitude

      # generate Google Maps links
      urlMaps = 'https://www.google.com/maps/place/' + strPosition + '/@' + strPosition + ',' + zoomMap + 'z/'
      urlJpeg = 'https://maps.googleapis.com/maps/api/staticmap?maptype=hybrid&zoom=' + zoomMap + '&size=' + sizeMap
      urlJpeg += '&center=' + strPosition + '&markers=' + strPosition + '&key=' + apikey
      
      # generate cache folder, and create if needed
      dirHomeCache = os.environ['HOME'] + '/.cache'
      dirGeotagCache = os.getenv('XDG_CACHE_HOME', dirHomeCache) + '/geotag'
      if not os.path.exists(dirGeotagCache): os.makedirs(dirGeotagCache)

      # generate cache file names
      fileMap = dirGeotagCache + '/map_' + strLatitude + '_' + strLongitude + '_' + sizeMap + '_' + zoomMap + '.png'
      fileDesc = dirGeotagCache + '/map_' + strLatitude + '_' + strLongitude + '.txt'

      # if description is not in the cache, retrieve it from Nominatim
      if not os.path.exists(fileDesc):
        # retrieve place description
        geolocator = Nominatim(user_agent="nautilus-exif-geotag")
        location = geolocator.reverse(strPosition)
        strDescription = location.address

        # write description to cache
        file = codecs.open(fileDesc, "w", "utf-8")
        file.write(strDescription)
        file.close()

      # if map is not in the cache, retrieve it from Google Maps
      if not os.path.exists(fileMap): urllib.request.urlretrieve(urlJpeg, fileMap)

      # retrieve description from cache
      file = codecs.open(fileDesc, "r", "utf-8")
      strDescription = file.read()
      file.close()

      # dislay GPS data
      self.DisplayText("<b>latitude</b>", 0, 0, 1, 1, "right")
      self.DisplayText(strLatitude, 1, 0, 1, 1, "left")
      self.DisplayText("<b>longitude</b>", 0, 1, 1, 1, "right")
      self.DisplayText(strLongitude, 1, 1, 1, 1, "left")
      self.DisplayText("<b>altitude</b>", 0, 2, 1, 1, "right")
      self.DisplayText(strAltitude, 1, 2, 1, 1, "left")

      # dislay address
      value = re.compile(',').sub('\n', strDescription)
      self.DisplayText("<b>address</b>", 2, 0, 1, 3, "right")
      self.DisplayText("<a href='" + urlMaps + "'>" + value + "</a>", 3, 0, 1, 5, "left")

      # dislay gmaps image
      self.DisplayImage(fileMap, 0, 5, 4, 1)

      # return label and tab content
      return Nautilus.PropertyPage( name="NautilusPython::geotag_info", label=self.tab, page=self.window ),
コード例 #11
0
def metadata_summary(path):
    exif = Metadata()
    exif.open_path(path)
    taglist = exif.get_tags()

    # Date
    date = []
    if 'Exif.Photo.DateTimeOriginal' in taglist:
        date.append(exif['Exif.Photo.DateTimeOriginal'])
    if 'Xmp.exif.DateTimeOriginal' in taglist:
        date.append(exif['Xmp.exif.DateTimeOriginal'])
    #date.append(time.ctime(os.path.getmtime(path)))
    if len(date) > 0:
        date = time.strftime("%d/%m/%Y %H:%M:%S",
                             time.strptime(date[0], "%Y:%m:%d %H:%M:%S"))
    else:
        date = ""

    # Orientation
    ori = exif.get('Exif.Image.Orientation', "?")

    # Tags
    tags = []
    if 'Iptc.Application2.Keywords' in taglist:
        tags.append(exif['Iptc.Application2.Keywords'])
    if 'Xmp.dc.subject' in taglist:
        tags += exif['Xmp.dc.subject'].split(",")
    if 'Xmp.digiKam.TagsList' in taglist:
        tags += exif['Xmp.digiKam.TagsList'].split(",")
    if 'Xmp.MicrosoftPhoto.LastKeywordXMP' in taglist:
        tags += exif['Xmp.MicrosoftPhoto.LastKeywordXMP'].split(",")
    tags = [x.strip() for x in tags]
    tags = list(set(tags))
    tags.sort()

    # Title
    aux = []
    title = ""
    if 'Iptc.Application2.Caption' in taglist:
        aux.append(exif['Iptc.Application2.Caption'])
    if 'Xmp.dc.title' in taglist:
        aux.append(exif['Xmp.dc.title'])
    if 'Iptc.Application2.Headline' in taglist:
        aux.append(exif['Iptc.Application2.Headline'])
    if len(aux) > 0:
        title = aux[0]

    # Software
    aux = []
    soft = ""
    if 'Exif.Image.Software' in taglist:
        aux.append(exif['Exif.Image.Software'])
    if 'Iptc.Application2.Program' in taglist:
        aux.append(exif['Iptc.Application2.Program'])
    if len(aux) > 0:
        soft = list(set(aux))[0]

    # Shorten title and soft
    if len(title) > 13:
        title = title[:10] + "..."
    if len(soft) > 15:
        soft = soft[:12] + "..."

    dinfo = {
        "date": date,
        "orientation": ori,
        "tags": tags,
        "title": title,
        "software": soft
    }

    return dinfo
コード例 #12
0
def photo_date_time(
    metadata: GExiv2.Metadata,
    full_file_name: Optional[str] = None,
    file_type: Optional[FileType] = None,
) -> Union[datetime.datetime, Any]:
    """
    Returns in python datetime format the date and time the image was
    recorded.

    Tries these tags, in order:
    Exif.Photo.DateTimeOriginal
    Exif.Image.DateTimeOriginal
    Exif.Image.DateTime

    :return: metadata value, or None if value is not present.
    """

    # GExiv2.Metadata used to provide get_date_time(), but as of version
    # 0.10.09 it appears to have been removed!

    # In any case, get_date_time() seems to have tried only one key, Exif.Photo.DateTimeOriginal
    # Try other keys too, and with a more flexible datetime parser.
    # For example some or maybe all Android 6.0 DNG files use Exif.Image.DateTimeOriginal

    do_log = full_file_name is not None and file_type is not None

    for tag in ('Exif.Photo.DateTimeOriginal', 'Exif.Image.DateTimeOriginal',
                'Exif.Image.DateTime'):
        try:
            dt_string = metadata.get_tag_string(tag)
        except Exception:
            pass
        else:
            if dt_string is None:
                continue

            # ignore all zero values, e.g. '0000:00:00 00:00:00'
            try:
                digits = int(''.join(c for c in dt_string if c.isdigit()))
            except ValueError:
                if do_log:
                    logging.warning(
                        'Unexpected malformed date time metadata value %s for photo %s',
                        dt_string, full_file_name)
            else:
                if not digits:
                    if do_log:
                        logging.debug(
                            'Ignoring date time metadata value %s for photo %s',
                            dt_string, full_file_name)
                else:
                    try:
                        return datetime.datetime.strptime(
                            dt_string, "%Y:%m:%d %H:%M:%S")
                    except (ValueError, OverflowError):
                        if do_log:
                            logging.debug(
                                'Error parsing date time metadata %s for photo %s; attempting '
                                'flexible approach', dt_string, full_file_name)
                        try:
                            dtr, fs = flexible_date_time_parser(
                                dt_string.strip())
                            if do_log:
                                logging.debug(
                                    "Extracted photo time %s using flexible approach",
                                    dtr.strftime(fs))
                            return dtr
                        except AssertionError:
                            if do_log:
                                logging.warning(
                                    "Error extracting date time metadata '%s' for %s %s",
                                    dt_string, file_type, full_file_name)
                        except (ValueError, OverflowError):
                            if do_log:
                                logging.warning(
                                    "Error parsing date time metadata '%s' for %s %s",
                                    dt_string, file_type, full_file_name)
                        except Exception:
                            if do_log:
                                logging.error(
                                    "Unknown error parsing date time metadata '%s' for %s %s",
                                    dt_string, file_type, full_file_name)
    return None
コード例 #13
0
ファイル: get_exif.py プロジェクト: subaquatic/photo-nuke
def get_exiv2(path):
	exif = {}
	for tag in m.get_tags(m(path)):
		exif[tag] = m.get(m(path), tag)
コード例 #14
0
class TagsPropertyPage(GObject.GObject, Nautilus.PropertyPageProvider):
    def __init__(self):
        pass

    # --------------------
    #   Display one tag
    # --------------------
    def dislayTag(self, name, interpreted, raw_value, x, y):

        # check if third column is needed
        width = 1
        if raw_value == "": width = 2

        # dislay name
        gtk_label = Gtk.Label()
        gtk_label.set_markup(name)
        gtk_label.set_alignment(1.0, 0)
        gtk_label.set_padding(10, 2)
        gtk_label.show()
        self.grid.attach(gtk_label, x, y, 1, 1)

        # dislay interpreted string
        gtk_label = Gtk.Label()
        gtk_label.set_markup(interpreted)
        gtk_label.set_alignment(0.0, 0)
        gtk_label.set_padding(10, 2)
        gtk_label.show()
        self.grid.attach(gtk_label, x + 1, y, width, 1)

        # if different, dislay raw string
        if raw_value != "":
            gtk_label = Gtk.Label()
            gtk_label.set_markup(raw_value)
            gtk_label.set_alignment(0.0, 0)
            gtk_label.set_padding(10, 2)
            gtk_label.show()
            self.grid.attach(gtk_label, x + 2, y, 1, 1)

        return

    # -------------------------
    #   Display property tab
    # -------------------------
    def get_property_pages(self, files):

        # test file type
        if len(files) != 1: return
        file = files[0]
        if file.get_uri_scheme() != 'file': return

        # if mimetype corresponds to an image, read exif tags
        #if file.get_mime_type() in ('image/jpeg' 'image/png'):
        mimetype = file.get_mime_type().split('/')
        if mimetype[0] == "image":

            # create label and grid
            self.property_label = Gtk.Label('EXIF')
            self.property_label.show()
            self.grid = Gtk.Grid()
            self.grid.set_margin_start(10)
            self.grid.set_margin_end(10)
            self.grid.set_margin_top(5)
            self.grid.set_margin_bottom(5)
            self.grid.show()

            # display title
            self.dislayTag("<b>Tag</b>", "<b>Readable value</b>",
                           "<b>Raw value</b>", 0, 0)
            gtk_separator = Gtk.Separator(
                orientation=Gtk.Orientation.HORIZONTAL)
            self.grid.attach(gtk_separator, 0, 1, 3, 1)

            # read metadata from file
            filename = unquote(file.get_uri()[7:])
            self.tags = Metadata()
            self.tags.open_path(filename)

            # loop thru the tags
            index = 0
            for name in self.tags:
                interpreted = self.tags.get_tag_interpreted_string(name)[0:64]
                string_raw = self.tags.get_tag_string(name)[0:64]
                if interpreted == string_raw: string_raw = ""
                else: string_raw = "<i>" + string_raw + "</i>"
                name = "<b>" + name + "</b>"
                self.dislayTag(name, interpreted, string_raw, 0, index + 2)
                index = index + 1

            # declare main scrolled window
            self.window = Gtk.ScrolledWindow()
            self.window.add_with_viewport(self.grid)
            self.window.show_all()

            # return label and tab content
            return Nautilus.PropertyPage(name="NautilusPython::tags_info",
                                         label=self.property_label,
                                         page=self.window),
コード例 #15
0
class ExifColumnExtension(GObject.GObject, Nautilus.ColumnProvider,
                          Nautilus.InfoProvider):
    def __init__(self):
        pass

    # -----------------------------
    #   List of available columns
    # -----------------------------
    def get_columns(self):
        return (
            Nautilus.Column(name="NautilusPython::ExifWidth",
                            attribute="exif_width",
                            label=" Width ",
                            description="Image width"),
            Nautilus.Column(name="NautilusPython::ExifHeight",
                            attribute="exif_height",
                            label=" Height ",
                            description="Image height"),
            Nautilus.Column(name="NautilusPython::ExifAperture",
                            attribute="exif_apert",
                            label="Aperture",
                            description="Aperture"),
            Nautilus.Column(name="NautilusPython::ExifFocal",
                            attribute="exif_focal",
                            label="Focal",
                            description="Focal length (35mm)"),
            Nautilus.Column(name="NautilusPython::ExifCity",
                            attribute="exif_city",
                            label="City",
                            description="City"),
            Nautilus.Column(name="NautilusPython::ExifCountry",
                            attribute="exif_country",
                            label="Country",
                            description="Country"),
            Nautilus.Column(name="NautilusPython::ExifGPS",
                            attribute="exif_gps",
                            label="GPS",
                            description="GPS"),
            Nautilus.Column(name="NautilusPython::ExifMaker",
                            attribute="exif_maker",
                            label="Manufacturer",
                            description="Camera manufacturer"),
            Nautilus.Column(name="NautilusPython::ExifModel",
                            attribute="exif_model",
                            label="Model",
                            description="Camera model"),
        )

    # ------------------------
    #   Retrieve file values
    # ------------------------
    def update_file_info(self, file):
        # test file type
        if file.get_uri_scheme() != 'file': return

        # read data only if image file
        mimetype = file.get_mime_type().split('/')
        if mimetype[0] == "image":

            # format filename
            filename = unquote(file.get_uri()[7:])

            # get metadata
            self.tags = Metadata()
            self.tags.open_path(filename)

            # image width
            tag_value = ""
            if self.tags.has_tag('Exif.Photo.PixelXDimension'):
                tag_value = self.tags.get_tag_string(
                    'Exif.Photo.PixelXDimension')
            if tag_value == "" and self.tags.has_tag('Exif.Image.ImageWidth'):
                tag_value = self.tags.get_tag_string('Exif.Image.ImageWidth')
            file.add_string_attribute('exif_width', tag_value)

            # image height
            tag_value = ""
            if self.tags.has_tag('Exif.Photo.PixelYDimension'):
                tag_value = self.tags.get_tag_string(
                    'Exif.Photo.PixelYDimension')
            if tag_value == "" and self.tags.has_tag('Exif.Image.ImageLength'):
                tag_value = self.tags.get_tag_string('Exif.Image.ImageLength')
            file.add_string_attribute('exif_height', tag_value)

            # camera manufacturer
            tag_value = ""
            if self.tags.has_tag('Xmp.VendorInfo.Manufacturer'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.VendorInfo.Manufacturer')
            if tag_value == "" and self.tags.has_tag('Exif.Image.Make'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Image.Make')
            file.add_string_attribute('exif_maker', tag_value)

            # camera model
            tag_value = ""
            if self.tags.has_tag('Xmp.VendorInfo.Model'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.VendorInfo.Model')
            if tag_value == "" and self.tags.has_tag('Exif.Image.Model'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Image.Model')
            file.add_string_attribute('exif_model', tag_value)

            # camera focal length
            tag_value = ""
            if self.tags.has_tag('Xmp.Exif.FocalLengthIn35mmFormat'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.Exif.FocalLengthIn35mmFormat')
            if tag_value == "" and self.tags.has_tag(
                    'Exif.Photo.FocalLengthIn35mmFilm'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.FocalLengthIn35mmFilm')
            if tag_value == "" and self.tags.has_tag('Exif.Photo.FocalLength'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.FocalLength')
            file.add_string_attribute('exif_focal', tag_value)

            # camera aperture
            tag_value = ""
            if self.tags.has_tag('Xmp.Exif.ApertureValue'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.Exif.ApertureValue')
            if tag_value == "" and self.tags.has_tag(
                    'Exif.Photo.ApertureValue'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.ApertureValue')
            if tag_value == "" and self.tags.has_tag('Exif.Photo.FNumber'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.FNumber')
            file.add_string_attribute('exif_apert', tag_value)

            # city tag
            tag_value = ""
            if self.tags.has_tag('Xmp.City'):
                tag_value = self.tags.get_tag_interpreted_string('Xmp.City')
            if tag_value == "" and self.tags.has_tag('Xmp.photoshop.City'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.photoshop.City')
            if tag_value == "" and self.tags.has_tag('Iptc.City'):
                tag_value = self.tags.get_tag_interpreted_string('Iptc.City')
            file.add_string_attribute('exif_city', tag_value)

            # country tag
            tag_value = ""
            if self.tags.has_tag('Xmp.CountryName'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.CountryName')
            if tag_value == "" and self.tags.has_tag('Xmp.photoshop.Country'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.photoshop.Country')
            file.add_string_attribute('exif_country', tag_value)

            # GPS tag
            tag_value = "no"
            if self.tags.has_tag('Xmp.Exif.GPSLatitude'): tag_value = "yes"
            if tag_value == "no" and self.tags.has_tag(
                    'Xmp.LocationDetails.GPSLatitude'):
                tag_value = "yes"
            if tag_value == "no" and self.tags.has_tag(
                    'Exif.GPSInfo.GPSLatitude'):
                tag_value = "yes"
            file.add_string_attribute('exif_gps', tag_value)

        # else, file is not an image
        else:
            file.add_string_attribute('exif_maker', "")
            file.add_string_attribute('exif_model', "")
            file.add_string_attribute('exif_focal', "")
            file.add_string_attribute('exif_city', "")
            file.add_string_attribute('exif_country', "")
            file.add_string_attribute('exif_gps', "")
コード例 #16
0
    def update_file_info(self, file):
        # test file type
        if file.get_uri_scheme() != 'file': return

        # read data only if image file
        mimetype = file.get_mime_type().split('/')
        if mimetype[0] == "image":

            # format filename
            filename = unquote(file.get_uri()[7:])

            # get metadata
            self.tags = Metadata()
            self.tags.open_path(filename)

            # image width
            tag_value = ""
            if self.tags.has_tag('Exif.Photo.PixelXDimension'):
                tag_value = self.tags.get_tag_string(
                    'Exif.Photo.PixelXDimension')
            if tag_value == "" and self.tags.has_tag('Exif.Image.ImageWidth'):
                tag_value = self.tags.get_tag_string('Exif.Image.ImageWidth')
            file.add_string_attribute('exif_width', tag_value)

            # image height
            tag_value = ""
            if self.tags.has_tag('Exif.Photo.PixelYDimension'):
                tag_value = self.tags.get_tag_string(
                    'Exif.Photo.PixelYDimension')
            if tag_value == "" and self.tags.has_tag('Exif.Image.ImageLength'):
                tag_value = self.tags.get_tag_string('Exif.Image.ImageLength')
            file.add_string_attribute('exif_height', tag_value)

            # camera manufacturer
            tag_value = ""
            if self.tags.has_tag('Xmp.VendorInfo.Manufacturer'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.VendorInfo.Manufacturer')
            if tag_value == "" and self.tags.has_tag('Exif.Image.Make'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Image.Make')
            file.add_string_attribute('exif_maker', tag_value)

            # camera model
            tag_value = ""
            if self.tags.has_tag('Xmp.VendorInfo.Model'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.VendorInfo.Model')
            if tag_value == "" and self.tags.has_tag('Exif.Image.Model'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Image.Model')
            file.add_string_attribute('exif_model', tag_value)

            # camera focal length
            tag_value = ""
            if self.tags.has_tag('Xmp.Exif.FocalLengthIn35mmFormat'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.Exif.FocalLengthIn35mmFormat')
            if tag_value == "" and self.tags.has_tag(
                    'Exif.Photo.FocalLengthIn35mmFilm'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.FocalLengthIn35mmFilm')
            if tag_value == "" and self.tags.has_tag('Exif.Photo.FocalLength'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.FocalLength')
            file.add_string_attribute('exif_focal', tag_value)

            # camera aperture
            tag_value = ""
            if self.tags.has_tag('Xmp.Exif.ApertureValue'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.Exif.ApertureValue')
            if tag_value == "" and self.tags.has_tag(
                    'Exif.Photo.ApertureValue'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.ApertureValue')
            if tag_value == "" and self.tags.has_tag('Exif.Photo.FNumber'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Exif.Photo.FNumber')
            file.add_string_attribute('exif_apert', tag_value)

            # city tag
            tag_value = ""
            if self.tags.has_tag('Xmp.City'):
                tag_value = self.tags.get_tag_interpreted_string('Xmp.City')
            if tag_value == "" and self.tags.has_tag('Xmp.photoshop.City'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.photoshop.City')
            if tag_value == "" and self.tags.has_tag('Iptc.City'):
                tag_value = self.tags.get_tag_interpreted_string('Iptc.City')
            file.add_string_attribute('exif_city', tag_value)

            # country tag
            tag_value = ""
            if self.tags.has_tag('Xmp.CountryName'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.CountryName')
            if tag_value == "" and self.tags.has_tag('Xmp.photoshop.Country'):
                tag_value = self.tags.get_tag_interpreted_string(
                    'Xmp.photoshop.Country')
            file.add_string_attribute('exif_country', tag_value)

            # GPS tag
            tag_value = "no"
            if self.tags.has_tag('Xmp.Exif.GPSLatitude'): tag_value = "yes"
            if tag_value == "no" and self.tags.has_tag(
                    'Xmp.LocationDetails.GPSLatitude'):
                tag_value = "yes"
            if tag_value == "no" and self.tags.has_tag(
                    'Exif.GPSInfo.GPSLatitude'):
                tag_value = "yes"
            file.add_string_attribute('exif_gps', tag_value)

        # else, file is not an image
        else:
            file.add_string_attribute('exif_maker', "")
            file.add_string_attribute('exif_model', "")
            file.add_string_attribute('exif_focal', "")
            file.add_string_attribute('exif_city', "")
            file.add_string_attribute('exif_country', "")
            file.add_string_attribute('exif_gps', "")
コード例 #17
0
ファイル: jpegdupes.py プロジェクト: jesjimher/imgdupes
def metadata_summary(path):
    exif=Metadata()
    exif.open_path(path)
    taglist=exif.get_tags()

    # Date
    date=[]
    if 'Exif.Photo.DateTimeOriginal' in taglist:
        date.append(exif['Exif.Photo.DateTimeOriginal'])
    if 'Xmp.exif.DateTimeOriginal' in taglist:
        date.append(exif['Xmp.exif.DateTimeOriginal'])
    #date.append(time.ctime(os.path.getmtime(path)))
    if len(date)>0:
        date=time.strftime("%d/%m/%Y %H:%M:%S",time.strptime(date[0],"%Y:%m:%d %H:%M:%S"))
    else:
        date=""

    # Orientation
    ori=exif.get('Exif.Image.Orientation',"?")

    # Tags
    tags=[]
    if 'Iptc.Application2.Keywords' in taglist:
        tags.append(exif['Iptc.Application2.Keywords'])
    if 'Xmp.dc.subject' in taglist:
        tags+=exif['Xmp.dc.subject'].split(",")
    if 'Xmp.digiKam.TagsList' in taglist:
        tags+=exif['Xmp.digiKam.TagsList'].split(",")
    if 'Xmp.MicrosoftPhoto.LastKeywordXMP' in taglist:
        tags+=exif['Xmp.MicrosoftPhoto.LastKeywordXMP'].split(",")
    tags=[x.strip() for x in tags]
    tags=list(set(tags))
    tags.sort()

    # Title
    aux=[]
    title=""
    if 'Iptc.Application2.Caption' in taglist:
        aux.append(exif['Iptc.Application2.Caption'])
    if 'Xmp.dc.title' in taglist:
        aux.append(exif['Xmp.dc.title'])
    if 'Iptc.Application2.Headline' in taglist:
        aux.append(exif['Iptc.Application2.Headline'])
    if len(aux)>0:
        title=aux[0]

    # Software
    aux=[]
    soft=""
    if 'Exif.Image.Software' in taglist:
        aux.append(exif['Exif.Image.Software'])
    if 'Iptc.Application2.Program' in taglist:
        aux.append(exif['Iptc.Application2.Program'])
    if len(aux)>0:
        soft=list(set(aux))[0]

    # Shorten title and soft
    if len(title)>13:
        title=title[:10]+"..."
    if len(soft)>15:
        soft=soft[:12]+"..."

    dinfo={"date":date,"orientation":ori,"tags":tags,"title":title,"software":soft}

    return dinfo