Python EXIF.process_file方法代码示例

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
	def EXIF(self):
		try:
			return EXIF.process_file(open(self.image.path, 'rb'))
		except:
			 try:
				 return EXIF.process_file(open(self.image.path, 'rb'), details=False)
			 except:
				 return {}

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
def exif_to_human(image):
    fields = (
        ('Image Make', _('Camera manifacture')),
        ('Image Model', _('Camera model')),
        ('EXIF DateTimeDigitized', _('Digitized time')),
        ('EXIF DateTimeOriginal', _('Taken time')),
        ('Image Software', _('Image software')),
        ('EXIF ColorSpace', _('Color space')),
        ('EXIF FocalLength', _('Focal length')),
        ('EXIF FocalLengthIn35mmFilm', _('Forcal length(in 35mm)')),
        ('EXIF ISOSpeedRatings', _('ISO speed')),
        ('EXIF MaxApertureValue', _('Max aperture')),
        ('EXIF ExposureMode', _('Exposure mode')),
        ('EXIF ExposureProgram', _('Exposure program')),
        ('EXIF ExposureTime', _('Exposure time')),
        ('EXIF Flash', _('Flash')),
        ('EXIF LightSource', _('Light source')),
        ('EXIF DigitalZoomRatio', _('Digital zoom ratio')),
        ('EXIF ExifImageLength', _('Image length')),
        ('EXIF ExifImageWidth', _('Image width')),
        ('EXIF WhiteBalance', _('White balance')),
        ('EXIF Sharpness', _('Sharpness')),
        ('EXIF Contrast', _('Contrast')),
    )
    exif = []
    tags = EXIF.process_file(image, strict=True, stop_tag='JPEGThumbnail')
    for f in fields:
        if tags.has_key(f[0]):
            exif.append((f[1], str(tags[f[0]])))
    image.close()
    return exif

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
    def post(self):
        # 画像データの取得
        image = self.request.get("image")
        # EXIFの解析
        sio = StringIO.StringIO(image)
        tags = EXIF.process_file(sio)
        
        # 画像の日付
        if tags.get('Image DateTime') != None:
            st = time.strptime(tags['Image DateTime'].values, '%Y:%m:%d %H:%M:%S')
            imgDateTime = datetime.datetime(*st[0:6])
        else:
            imgDateTime = None
        # 緯度
        if tags.get('GPS GPSLatitude') != None:
            lat = self.__getDegree(tags['GPS GPSLatitude'].values)
        else:
            lat = 0.0
        # 軽度
        if tags.get('GPS GPSLongitude') != None:
            lon = self.__getDegree(tags['GPS GPSLongitude'].values)
        else:
            lon = 0.0

        # データの保存
        pictData = PictureData(picture     = image,
                               geo         = "%f, %f" % (lat, lon),
                               imgdatetime = imgDateTime)
        PictureCtrls.set(pictData)

        self.redirect('/')

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
def buildDateFolders(path = "", destination='', copy = True):
    files = fetchFiles(path)
    print("Processing files into dated folders for {0}".format(path))
    for eachFile in files:
        with open(eachFile.path, 'rb') as fh:
            tags = EXIF.process_file(fh, stop_tag="EXIF DateTimeOriginal")
            try:
                dateTaken = tags["EXIF DateTimeOriginal"].values
            except:
                dateTaken = None
        if dateTaken:
            try:
                destYearDir = "{0}\\{1}".format(destination, dateTaken.split(":")[0])
                destMonthDir = '{0}\\{1}'.format(destYearDir, dateTaken.split(":")[1])
                destMonthDay = '{0}\\{1}'.format(destMonthDir, dateTaken.split(":")[2].split(" ")[0])
                if not os.path.isdir(destYearDir):
                    os.mkdir(destYearDir)
                if not os.path.isdir(destMonthDir):
                    os.mkdir(destMonthDir)
                if not os.path.isdir(destMonthDay):
                    os.mkdir(destMonthDay)

                if copy:
                    if not os.path.isfile(os.path.join(eachFile.name, destMonthDay)):
                        print("Copying %s" % eachFile.name)
                        shutil.copy(eachFile.path, destMonthDay)
                else:
                    if not os.path.isfile(os.path.join(eachFile.name, destMonthDay)):
                        print("Moving %s from %s to %s" % (eachFile.name, eachFile.path, destMonthDay))
                        shutil.move(eachFile.path, destMonthDay)
            except:
                pass
    print('FINISHED MOVING FILES TO DATE FOLDERS')

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
def get_exif_data(filename):
    """Returns a dict of EXIF data for the given image file."""
    assert os.path.exists(filename), 'File not found: %s' % filename
    infile = open(filename, 'rb')
    exifdata = EXIF.process_file(infile)
    infile.close()
    return exifdata

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
    def _load_fdl_one(self, filename, file_data_list, movies):
        fn = fs_enc(filename)
        basename, extension = os.path.splitext(filename)
        with open(filename) as file:
            tags = EXIF.process_file(file, stop_tag="Image DateTime", details=False)
            if "Image DateTime" in tags:
                dt = datetime.datetime.strptime(str(tags["Image DateTime"]), "%Y:%m:%d %H:%M:%S")
            else:
                dt = modification_date(fn)

            # Set album time to the time of the oldest photo in the album
            if dt < self.album_datetime:
                self.album_datetime = dt

            print u"%s: %s" % (filename, dt)

            file_size = os.path.getsize(fn)
            if file_size < MAX_SIZE:
                checksum = md5_for_file(file)
            else:
                checksum = md5_for_string(fn + str(file_size))
            file_data = {"filename": filename, "datetime": dt, "checksum": checksum}
            file_data_list.append(file_data)

            # Maintain a set of all movies to filter out thumbnail
            # images below.
            if extension.lower() in (".mov", ".mpg", ".mpeg"):
                movies.add(basename)

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
    def processEXIF(self):
        if hasattr(self, 'photoBody'):
            input = self.photoBody.getInputStream()
        else:
            input = file(self.file, 'r')

        data = input.read()
        input.close()
        stream = cStringIO.StringIO(data)
        try:
            exif = EXIF.process_file(stream)

            # First try DateTimeOriginal, falling back to DateTime
            takenString = str(exif.get('EXIF DateTimeOriginal',
                              exif['Image DateTime']))

            timestamp = time.mktime(time.strptime(takenString,
                                                  "%Y:%m:%d %H:%M:%S"))
            self.dateTaken = datetime.fromtimestamp(timestamp)
            if self.dateTaken.tzinfo is None:
                self.dateTaken = self.dateTaken.replace(tzinfo=self.itsView.tzinfo.default)

            self.exif = {}
            for (key, value) in exif.iteritems():
                if isinstance(value, EXIF.IFD_Tag):
                    self.exif[key] = unicode(value.printable)
                else:
                    self.exif[key] = unicode(value)

        except Exception, e:
            logger.debug("Couldn't process EXIF of Photo %s (%s)" % \
                (self.itsPath, e))

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
 def _parse_and_add_exif(self):
   import EXIF
   tags                    = EXIF.process_file(open(self.image.path,'rb'))
   self.make               = smart_unicode(tags.get('Image Make', '')).strip()
   self.model              = smart_unicode(tags.get('Image Model', '')).strip()
   self.date_raw           = smart_unicode(tags.get('EXIF DateTimeOriginal', '')).strip()
   self.width              = smart_unicode(tags.get('EXIF ExifImageWidth', '')).strip()
   self.height             = smart_unicode(tags.get('EXIF ExifImageHeight', '')).strip()
   self.orientation        = smart_unicode(tags.get('Image Orientation', '')).strip()
   self.resolution_unit    = smart_unicode(tags.get('Image ResolutionUnit', '')).strip()
   self.x_resolution       = smart_unicode(tags.get('Image XResolution', '')).strip()
   self.y_resolution       = smart_unicode(tags.get('Image YResolution', '')).strip()
   self.software           = smart_unicode(tags.get('Image Software', '')).strip()
   self.exposure_time      = smart_unicode(tags.get('EXIF ExposureTime', '')).strip()
   self.exposure_bias      = smart_unicode(tags.get('EXIF ExposureBiasValue', '')).strip() 
   self.exposure_program   = smart_unicode(tags.get('EXIF ExposureProgram', '')).strip() 
   self.flash              = smart_unicode(tags.get('EXIF Flash', '')).strip() 
   self.f_number           = smart_unicode(tags.get('EXIF FNumber', '')).strip() 
   self.aperture           = smart_unicode(tags.get('EXIF MaxApertureValue', '')).strip() 
   self.metering_mode      = smart_unicode(tags.get('EXIF MeteringMode', '')).strip() 
   self.focal_length       = smart_unicode(tags.get('EXIF FocalLength', '')).strip() 
   self.color_space        = smart_unicode(tags.get('EXIF ColorSpace', '')).strip()
   self.focal_length       = smart_unicode(tags.get('EXIF FocalLength', '')).strip()
   self.ycbcr_positioning  = smart_unicode(tags.get('Image YCbCrPositioning', '')).strip()
   self.sensing_method     = smart_unicode(tags.get('EXIF SensingMethod', '')).strip()
   
   if not self.date_created:
       if self.date_raw:
           self.date_created = self.date_raw

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
    def rename_file(self, filename, media_type):
        if media_type == "photo":
            with open(filename, "rb") as file_stream:
                try:
                    tags = EXIF.process_file(file_stream)
                    datestr = str(tags["EXIF DateTimeDigitized"])
                    date_object = datetime.datetime.strptime(datestr,
                                                             "%Y:%m:%d %H:%M:%S")
                    formatted_date = datetime.datetime.strftime(date_object,
                                                                "%Y-%m-%d_%I-%M-%S_%p")

                    self.year = str(datetime.datetime.strftime(date_object, "%Y"))
                    self.month = str(datetime.datetime.strftime(date_object, "%m"))
                    self.day = str(datetime.datetime.strftime(date_object, "%d"))

                    camera_model = str(tags["Image Model"]).replace(" ", "_")

                    image_filename = os.path.split(filename)[1]
                    if image_filename.startswith("DSC"):
                        image_filename_base = os.path.splitext(image_filename)[0]
                        self.new_name = (camera_model + "_" + image_filename_base[4:] + "_" +
                                         formatted_date + ".jpg")
                    else:
                        self.new_name = camera_model + "_" + formatted_date + ".jpg"
                except KeyError:
                    sys.stderr.write("Key error reading EXIF tags")
                    self.log.error("Key error reading EXIF tags")
                    pass
        else:
            video_filename  = self.get_video_date(filename)
            video_root, video_ext = os.path.splitext(filename)
            self.new_name = video_filename + video_ext.lower()

        return self.new_name

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
def main():
    dom = xml.dom.minidom.parse(sys.argv[1])
    out = open(sys.argv[2], "wt")
    mismatched = None
    if len(sys.argv) > 3:
        mismatched = open(sys.argv[3], "wt")

    min_time, max_time = get_time_span(dom)

    images = {}
    for wpt in dom.getElementsByTagName("wpt"):
        name = text(wpt.getElementsByTagName("name")[0])
        images[name] = True

    print "Start time:", min_time
    print "End time  :", max_time
    print "Total deduplicated input A/V waypoints:", len(images.keys())

    for fname in images.keys():
#    print "Processing " + fname
        fullname = "../avnotes/" + fname
        if os.path.exists(fullname):
            f = open(fullname)
            tags = exifread.process_file(f)
            if len(tags) == 0:
                # Non-JPEG file, like mp3 or mp4
                st = os.stat(fullname)
                d = datetime.fromtimestamp(st[stat.ST_MTIME])
            else:
                d = tags["Image DateTime"]
                d = datetime.strptime(str(d), "%Y:%m:%d %H:%M:%S")
            d = local2utc(d)
#            print d
            if d < min_time or d > max_time:
                del images[fname]
        else:
            print "Warning: %s doesn't exists, so removing its waypoint either" % fullname
            del images[fname]

    print "Total A/V waypoints belonging to the track:", len(images.keys())


    out.write(GPX_HEADER)

    for n in dom.getElementsByTagName("trk"):
        print >>out, " ", n.toxml()

    seen = {}
    for wpt in dom.getElementsByTagName("wpt"):
        name = text(wpt.getElementsByTagName("name")[0])
        if name in images:
            if name not in seen:
                print >>out, " ", wpt.toxml()
                seen[name] = True
        else:
            if mismatched and name not in seen:
                print >>mismatched, " ", wpt.toxml()
                seen[name] = True

    print >>out, "</gpx>"

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
def exif_test(ifile):
    try:
        im = open(ifile, 'rb')
        tags = EXIF.process_file(im)
        tag_count = len(tags)
        return (True, tag_count) 
    except:
        return (False, None)

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
def exim_fetch(filename):
	f = open(filename, 'rb')
	tags = EXIF.process_file(f)
	test = [ item.split(':') for item in str(tags['EXIF DateTimeOriginal']).split(' ') ] 
	test = list(itertools.chain(*test))
	test = [ int(item) for item in test ]
	when = datetime(test[0], test[1], test[2], test[3], test[4], test[5])
	return when

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
 def exif_data(self):
     if not hasattr(self, "_exif"):
         media_path = settings.GALLERY_SETTINGS.get('media_path')
         ex = self.get_exported()
         f = open(os.path.join(media_path, ex.normal_relpath.decode('string_escape')))
         self._exif = EXIF.process_file(f)
         f.close()
     return self._exif

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
    def __init__(self, file_path):
        """ EXIFReader 클래스 생성자 """

        self.file_path = file_path
        # Open image file for reading (binary mode)
        f = open(file_path, "rb")

        # Return Exif tags
        self.tags = EXIF.process_file(f)

# 需要导入模块: import EXIF [as 别名]
# 或者: from EXIF import process_file [as 别名]
	def getdate(self,filename):
		imagefile = file(filename,"rb")
		imagetags = EXIF.process_file(imagefile)
		imagefile.close()
#		print dir(imagetags['EXIF DateTimeOriginal'])
#		return imagetags['EXIF DateTimeOriginal']
		datestr = imagetags['EXIF DateTimeOriginal']
		datelist = re.search(r'(....):(..):(..) (..):(..):(..).*',datestr.printable).group
		date = datetime.datetime(int(datelist(1)),int(datelist(2)), int(datelist(3)), int(datelist(4)), int(datelist(5)), int(datelist(6)))
		return date