Esempio n. 1
0
    def __init__(self, filename, aug=False, transform=None):
        # For now it just reads the h5 file
        # Will eventually add path functionality
        if filename.endswith('h5'):
            f = h5py.File(filename, "r")
            self.images = f["images"][()]
            self.category = f["category"][()]
            self.category_names = f["category_names"][()]
            f.close()
        else:
            self.root_path = '/'.join(filename.split('/')[:-1]) + '/images'
            self.file_names = pd.read_csv(filename, header=None, names=['ims'])
            self.file_names = self.file_names.apply(
                lambda x: x + '.jpg' if not x.ims.endswith('.jpg') else x,
                axis=1)
            self.category_names = np.array(
                list(
                    unique_everseen(
                        self.file_names.apply(lambda x: x.ims.split('/')[0],
                                              axis=1).tolist())))

            self.file_names = self.file_names.ims.values
            for file in self.file_names:
                piexif.remove(os.path.join(self.root_path, file))

        self.transform = transform
        self.aug = aug
Esempio n. 2
0
def retag_date(file):
    filename = os.path.basename(file)
    exif_dict = piexif.load(file)
    if piexif.ImageIFD.DateTime not in exif_dict['0th']:
        date_file_name = try_parsing_date(file)
        if date_file_name is not None:
            date_b = date_file_name.strftime("%Y:%m:%d %H:%M:%S")
            exif_dict['0th'][piexif.ImageIFD.DateTime] = date_b
            exif_dict['Exif'][piexif.ExifIFD.DateTimeOriginal] = date_b
            exif_dict['Exif'][piexif.ExifIFD.DateTimeDigitized] = date_b
            exif_bytes = piexif.dump(exif_dict)
            piexif.insert(exif_bytes, file)
            global MODIFIED_FILES
            MODIFIED_FILES = MODIFIED_FILES + 1
    else:
        try:
            #catch dates not well formated
            old_date_b = exif_dict['0th'][piexif.ImageIFD.DateTime]
            old_date = datetime.strptime(old_date_b.decode("utf-8"),
                                         '%Y:%m:%d %H:%M:%S')
        except ValueError:
            piexif.remove(file)
            global INCONSISTENT_EXIF
            INCONSISTENT_EXIF = INCONSISTENT_EXIF + 1
            print('Invalid date format in EXIF found for ' + file)
            retag_date(file)
            pass

    return True
Esempio n. 3
0
    def writeEXIF(self, file_paths, values):
        newexif = self.exif.copy()
        # UPDATE EXIF DATA WITH GPS DATA
        if values:
            del newexif["GPS"]
            gps = {}
            if "position_lat" in values:
                latitude = self.semicircles2dd(int(values["position_lat"][0]))
                longitude = self.semicircles2dd(int(values["position_long"][0]))
                gps[piexif.GPSIFD.GPSLatitudeRef] = 'N' if latitude > 0 else 'S'
                gps[piexif.GPSIFD.GPSLongitudeRef] = 'E' if longitude > 0 else 'W'
                gps[piexif.GPSIFD.GPSLatitude] = self.dd2dms(abs(latitude))
                gps[piexif.GPSIFD.GPSLongitude] = self.dd2dms(abs(longitude))
            if "enhanced_altitude" in values:
                elev = values["enhanced_altitude"][0]
                gps[piexif.GPSIFD.GPSAltitudeRef] = 0 if elev >= 0 else 1
                gps[piexif.GPSIFD.GPSAltitude] = (abs(int(elev*1000000)),10000000)
            newexif["GPS"] = gps
        else:
            del newexif["GPS"]

        # STRIP ANY EXISTING EXIF DATA
        for file_path in file_paths:
            piexif.remove(file_path)

        # CONVERT EXIF DICT TO BYTES
        exif_bytes = piexif.dump(newexif)

        # INSERT EXIF DATA INTO IMAGE FILE
        for file_path in file_paths:
            piexif.insert(exif_bytes, file_path)
Esempio n. 4
0
def remove_all_exif_data(dir_path):
    '''
    remove currept exif warning.
    '''
    file_list = find_all_files_sub(dir_path)
    for file in file_list:
        piexif.remove(file)  # first to  clear out all the exif data
Esempio n. 5
0
    def __getitem__(self, index):
        assert index <= len(self), 'index range error'
        img_name = self.paths_index[index][0]
        try:
            img = Image.open(img_name)

        except ValueError:
            print('\t \t [Removing XIF infos from image ...] ')
            x = None
            piexif.remove(img.__getexif(), x)
            img = Image.frombytes(x)
        if img.mode == 'L':
            img = img.convert('RGB')

        img = np.asarray(img)
        gt_dmap = np.load(os.path.join(self.paths_index[index][1]))
        # gt_dmap=(gt_dmap-np.min(gt_dmap))/(np.max(gt_dmap)-np.min(gt_dmap))
        gt_dmap = gt_dmap[np.newaxis, :, :]
        # print(np.min(gt_dmap),np.max(gt_dmap))
        # img_tensor=torch.tensor(img,dtype=torch.float).permute((2,0,1))
        img_tensor = transforms.Compose([
            transforms.ToTensor(),
            transforms.RandomHorizontalFlip(),
            transforms.RandomVerticalFlip()
        ])(img)
        # gt_dmap_tensor=transforms.Compose([transforms.ToTensor()])(gt_dmap)
        # img_tensor=torch.from_numpy(img).permute((2,0,1))
        gt_dmap_tensor = torch.tensor(gt_dmap, dtype=torch.float)
        del img, gt_dmap
        return img_tensor.detach(), gt_dmap_tensor.detach()
Esempio n. 6
0
def upload_from_url(name, url):

    print('upload from url')

    x = requests.get(url)

    print('got content')

    tempname = name.replace("/", "_")

    with open(tempname, "wb") as file:
        for chunk in r.iter_content(1024):
            f.write(chunk)

    if tempname.split('.')[-1] in ['jpg', 'jpeg']:
        piexif.remove(tempname)

    S3.upload_file(tempname,
                   Bucket=BUCKET,
                   Key=name,
                   ExtraArgs={
                       'ACL': 'public-read',
                       "ContentType": "image/png",
                       "StorageClass": "INTELLIGENT_TIERING"
                   })

    remove(tempname)
Esempio n. 7
0
def upload_image():
    if request.method == 'POST':
        img_data = request.files['src']
        filename = request.form['date']
        location = request.form['location']

        full_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        img_data.save(full_path)

        # resize the image to fit
        from PIL import Image
        import piexif

        basewidth = 480
        img = Image.open(full_path)
        wpercent = (basewidth / float(img.size[0]))
        hsize = int((float(img.size[1]) * float(wpercent)))
        img = img.resize((basewidth, hsize), Image.ANTIALIAS)
        img.save(full_path)

        # update metadata to store location
        piexif.remove(full_path)
        exif_dict = piexif.load(full_path)
        exif_dict['Exif'] = {piexif.ExifIFD.UserComment: str(location)}
        exif_bytes = piexif.dump(exif_dict)
        piexif.insert(exif_bytes, full_path)

        return 'SUCCESS'
Esempio n. 8
0
def remove_exif(filename):
    image = Image.open(filename)

    if "exif" in image.info:
        exif_dict = piexif.load(image.info["exif"])

        # rotate accordingly
        if piexif.ImageIFD.Orientation in exif_dict["0th"]:
            orientation = exif_dict["0th"].pop(piexif.ImageIFD.Orientation)
            if orientation == 2:
                image = image.transpose(Image.FLIP_LEFT_RIGHT)
            elif orientation == 3:
                image = image.rotate(180)
            elif orientation == 4:
                image = image.rotate(180).transpose(Image.FLIP_LEFT_RIGHT)
            elif orientation == 5:
                image = image.rotate(-90, expand=True).transpose(Image.FLIP_LEFT_RIGHT)
            elif orientation == 6:
                image = image.rotate(-90, expand=True)
            elif orientation == 7:
                image = image.rotate(90, expand=True).transpose(Image.FLIP_LEFT_RIGHT)
            elif orientation == 8:
                image = image.rotate(90, expand=True)

            newfilename = filename.split('.')[0] + "_1" + '.' + filename.split('.')[1]
            image.save(newfilename, quality=95)
            piexif.remove(newfilename)
    else:
        #TODO add information on the interface for the user to understand
        print("Image skipped")
Esempio n. 9
0
def strip_metadata(filename):
    img1 = Image.open(filename)

    if "exif" in img1.info:
        exif_dict = piexif.load(img1.info["exif"])

    if piexif.ImageIFD.Orientation in exif_dict["0th"]:
        orientation = exif_dict["0th"].pop(piexif.ImageIFD.Orientation)
        exif_bytes = piexif.dump(exif_dict)

    piexif.remove(filename)

    img = Image.open(filename)

    if orientation == 2:
        img = img.transpose(Image.FLIP_LEFT_RIGHT)
    elif orientation == 3:
        img = img.rotate(180)
    elif orientation == 4:
        img = img.rotate(180).transpose(Image.FLIP_LEFT_RIGHT)
    elif orientation == 5:
        img = img.rotate(-90).transpose(Image.FLIP_LEFT_RIGHT)
    elif orientation == 6:
        img = img.rotate(-90)
    elif orientation == 7:
        img = img.rotate(90).transpose(Image.FLIP_LEFT_RIGHT)
    elif orientation == 8:
        img = img.rotate(90)

    return img
Esempio n. 10
0
def load_data(data_directory):
    directories = [
        d for d in os.listdir(data_directory)
        if os.path.isdir(os.path.join(data_directory, d))
    ]
    label_converters = []
    labels = []
    images = []
    i = 0
    while i < SAMPLE_TYPES:
        d = directories[i]
        ct = 0
        label_converters.append(d)
        label_directory = os.path.join(data_directory, d)
        file_names = [
            os.path.join(label_directory, f)
            for f in os.listdir(label_directory) if f.endswith(".jpg")
        ]
        while ct < len(file_names) and ct < SAMPLES_END:
            if ct < SAMPLES_BEGIN:
                ct = ct + 1
                continue
            f = file_names[ct]
            piexif.remove(f)
            images.append(skimage.data.imread(f))
            labels.append(i)
            ct = ct + 1
        i = i + 1
        print("Finished directory ", i)
    return images, labels, label_converters
Esempio n. 11
0
def fix_missing_exif(directories, v=True, prog_bar=None):
    """remove piexifs from images
    takes a list of keras image generators
    note that these are directory iterators
    so you must call flow_from_directory method 
    on the generators first.
    
    Args:
        image_generators (TYPE): Description
        v (bool, optional): verbose opt
        prog_bar (None, optional): if provided uses a progress bar such as tqdm

    """
    try:
        import piexif
    except ImportError:
        print('You must install the piexif library "pip install piexif"')
    for d in directories:
        filenames =os.listdir(d)
        if v:
            print('removing exifs from {} images at {}...'.format(len(filenames),
                                                                  d))
        if prog_bar:
            filenames =  prog_bar(filenames)
        for imfile in filenames:
            p = os.path.join(d, imfile)
            try:
                piexif.remove(p)
            except Exception:
                print('caught error InvalidImageDataError for file at {} ignoring...')
                pass
    if v:
        print('complete!')
Esempio n. 12
0
def clean_wildfish(path):
    # scan the image folder to clean each .jpg, jpeg file
    count = 0
    for part in path:
        files = os.listdir(part)
        for f in files:
            image_file = os.path.join(part, f)
            if f.endswith('.jpg') or f.endswith('.JPG') or f.endswith(
                    '.jpeg') or f.endswith('.JPEG'):
                if f.endswith('.jpeg') or f.endswith('.JPEG'):
                    piexif.remove(image_file)
                # following is the alternative approach
                try:
                    image = Image.open(image_file)
                    if image.mode != 'RGB':
                        image = image.convert("RGB")
                    image.save(image_file)
                except:
                    # delete this file
                    print('corrupted file deleted: ', image_file)
                    os.remove(image_file)
                    continue
                count += 1
                if count % 1000 == 0:
                    print(count, 'images processed!')
Esempio n. 13
0
def load_data(data_directory):
    directories = [
        d for d in os.listdir(data_directory)
        if os.path.isdir(os.path.join(data_directory, d))
    ]
    label_converters = []
    labels = []
    images = []
    i = 0
    for d in directories:
        ct = 0
        label_converters.append(d)
        label_directory = os.path.join(data_directory, d)
        file_names = [
            os.path.join(label_directory, f)
            for f in os.listdir(label_directory) if f.endswith(".jpg")
        ]
        for f in file_names:
            piexif.remove(f)
            images.append(skimage.data.imread(f))
            labels.append(i)
            ct = ct + 1
            if ct > SAMPLES_PER_TYPE:
                break
        i = i + 1
        print("Finished directory ", i)
    return images, labels, label_converters
Esempio n. 14
0
def delete_exif():
    root.initial_photo = filedialog.askopenfilename(
        initialdir="/",
        title="Select file",
        filetypes=(("jpeg files", "*.jpg"), ("all files", "*.*")))
    piexif.remove(root.initial_photo)
    print("Done")
Esempio n. 15
0
def check_image_format_convert_2(arg):
    '''
    1. check image format and convert images in png to jpeg.
    2. check image for tfrecord.
    '''
    file_list, check_dir = arg
    img_format = ['JPEG']
    for file in file_list:
        try:
            try:
                img = PIL.Image.open(file)
            except:
                img = cv2.imread(file)
                img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
                im_pil = PIL.Image.fromarray(img)
                im_pil.save(file)
                img = PIL.Image.open(file)
            # check img mode
            if img.format in img_format:
                piexif.remove(file)  # clear out all the exif data
            else:
                new_img = os.path.abspath(file)
                img.convert('RGB').save(new_img, "JPEG")
                piexif.remove(new_img)  # clear out all the exif data
            # check_image_tf_format(file)
        except:
            file_name = os.path.basename(file)
            os.rename(os.path.abspath(file),
                      os.path.join(check_dir, file_name))
Esempio n. 16
0
def checkImage():
    # read data from 'cap_json_path'
    with open(cap_json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
        f.close()

    print("Checking and fixing images...")

    # recognize 'UserWarning' as error, for finding images with corrupt EXIF info
    warnings.filterwarnings("error", category=UserWarning)

    for cnt, imgID in enumerate(tqdm(data, desc='Checked images: ')):
        image_path = os.path.join(image_dir_path, imgID)
        while True:
            try:
                # verify that it is in fact an validate image
                img = Image.open(image_path).resize((256, 256))
            # image corrupt
            except (IOError, SyntaxError, ValueError) as e:
                print('Bad image:', imgID)
                # download it again
                os.remove(image_path)
                getImage(data[imgID]['image_url'], imgID)
            # EXIF info corrupt, remove EXIF info
            except warning as e:
                print('Bad EXIF info:', imgID)
                piexif.remove(image_path)
            else:
                # validate image, go to the next
                break
Esempio n. 17
0
def upload_file():
    if syndbb.request.method == 'POST':
        image_types = [".jpg", ".jpeg", ".jpe"]
        if 'logged_in' in syndbb.session:
            userid = check_session_by_id(str(syndbb.session['logged_in']))
            uploader = syndbb.request.form['uploader']

            if 'anonymous' in syndbb.request.form:
                anonymous = 1
            else:
                anonymous = 0

            if 'timedelete' in syndbb.request.form:
                timedelete = 1
            else:
                timedelete = 0

            if userid:
                user = d2_user.query.filter_by(user_id=userid).first()
                if anonymous:
                    uploadfolder = syndbb.app.static_folder + "/data/uploads/" + d2_hash(
                        user.username + user.password)[:10] + "/"
                else:
                    uploadfolder = syndbb.app.static_folder + "/data/uploads/" + user.username + "/"
                if not syndbb.os.path.exists(uploadfolder):
                    syndbb.os.makedirs(uploadfolder)
                if 'file' not in syndbb.request.files:
                    syndbb.flash('No file selected.', 'danger')
                    return syndbb.redirect(syndbb.url_for(uploader))
                file = syndbb.request.files['file']
                if file.filename == '':
                    syndbb.flash('No file selected.', 'danger')
                    return syndbb.redirect(syndbb.url_for(uploader))
                if file:
                    filename = secure_filename(file.filename)
                    extension = syndbb.os.path.splitext(filename)[1]
                    newname = ''.join(
                        random.sample(
                            "-_" + string.ascii_uppercase +
                            string.ascii_lowercase + string.digits,
                            20)) + extension
                    file.save(syndbb.os.path.join(uploadfolder, newname))
                    if extension in image_types:
                        piexif.remove(uploadfolder + newname)
                    if uploader == 'upload_simple':
                        return "/upload/simple/?file=" + newname
                    else:
                        syndbb.flash('File uploaded successfully.', 'success')
                        syndbb.cache.delete_memoized(
                            syndbb.views.upload.get_user_files)

                        if anonymous:
                            fpath = d2_hash(user.username +
                                            user.password)[:10] + "/" + newname
                        else:
                            fpath = user.username + "/" + newname

                        return syndbb.redirect('/upload/view?file=' + fpath)
Esempio n. 18
0
def delete_metadata(full_path_to_img):
    """
    This function used for remove metadata only from documents, if you send image 'as image' Telegram automatically
    removes all metadata at sending. This function removes all metadata via 'piexif' lib, saved image in '/app'
    folder, and after that move it to 'documents' folder.
    :param full_path_to_img: path to folder with documents e.g.'documents/image.jpg'
    """
    piexif.remove(full_path_to_img, "clean_image.jpg")
    move("clean_image.jpg", "documents/clean_image.jpg")
Esempio n. 19
0
def copy_random_images(source, destination, num = 50, copier = get_random_images):
    images = copier(source, num)
    for i in images:
        f = path(i)
        try:
            piexif.remove(i)
        except (IOError, piexif.InvalidImageDataError, UnboundLocalError):
            pass
        f.copy(destination + "/" + f.namebase + str(random.randint(1,1000000000)) + f.ext)      
Esempio n. 20
0
def queue_folder(myblog, myblogname, folder, tags=[]):
    myfolder = path(folder)
    for f in myfolder.files():
        if isimage(f) == True:
            try:
                piexif.remove(f)
            except (piexif.InvalidImageDataError, UnboundLocalError):
                pass
            myblog.create_photo(myblogname, state="queue", tags=tags, data=str(f))
Esempio n. 21
0
 def test_04_remove_dir(self):
     target = "../samples"
     directory = os.fsencode(target)
     for file in os.listdir(directory):
         filename = os.fsdecode(file)
         if filename.endswith(".jpg") or filename.endswith(".jpeg"):
             piexif.remove(target + '/' + filename)
     for _ in os.listdir(directory):
         for i in ("0th", "Exif", "GPS", "Interop", "1st"):
             exif_dict = piexif.load(target + '/' + filename)
             self.assertEqual(exif_dict[i], {})
Esempio n. 22
0
def main():
    i = 0
    for filename in os.listdir("test"):
        dst = f"IMGA{i}.jpg"
        src = 'test/' + filename
        dst = 'test/' + dst
        piexif.remove(src)
        os.rename(src, dst)
        setFileDates(dst)
        print(f"File name '{src}' has been changed to '{dst}'.")
        i += 1
Esempio n. 23
0
def set_metadata(file, keywords='', authors='', comment=''):
    try:
        exif = piexif.load(file)
    except piexif._exceptions.InvalidImageDataError:
        return

    exif["0th"][piexif.ImageIFD.XPKeywords] = exif_str_encode(keywords)
    exif["0th"][piexif.ImageIFD.XPAuthor] = exif_str_encode(authors)
    exif["0th"][piexif.ImageIFD.XPComment] = exif_str_encode(comment)

    piexif.remove(file)
    piexif.insert(piexif.dump(exif), file)
Esempio n. 24
0
def get_image(image_name, raw_images_folder, save_images_folder):
    print(image_name)
    if image_name == '.DS_Store':
        return 0
    image_path = os.path.join(raw_images_folder,
                              '%s.jpg' % (image_name))  #本次原始图片jpg路径

    save_file_path = os.path.join(save_images_folder,
                                  '%s.jpg' % (image_name))  #本次保存图片jpg路径
    image = cv2.imread(image_path)
    cv2.imwrite(save_file_path, image)
    piexif.remove(save_file_path)
Esempio n. 25
0
    def remove_exif_data(self, train_path, test_path, dir):
        _, _, train_images = next(os.walk(train_path))
        for img in train_images:
            try:
                piexif.remove(train_path + dir + img)
            except:
                pass

        _, _, test_images = next(os.walk(test_path))
        for img in test_images:
            try:
                piexif.remove(test_path + dir + img)
            except:
                pass
Esempio n. 26
0
def remove_exif_data(src_folder):
    _, _, cat_images = next(os.walk(src_folder + 'Cat/'))
    for img in cat_images:
        try:
            piexif.remove(src_folder + 'Cat/' + img)
        except:
            pass

    _, _, dog_images = next(os.walk(src_folder + 'Dog/'))
    for img in dog_images:
        try:
            piexif.remove(src_folder + 'Dog/' + img)
        except:
            pass
Esempio n. 27
0
def upload_file_external():
    if syndbb.request.method == 'POST':
        image_types = [".jpg", ".jpeg", ".jpe"]
        username = syndbb.request.form['username']
        if 'auth' in syndbb.request.form:
            password = syndbb.request.form['auth']
        elif 'password' in syndbb.request.form:
            password = syndbb.request.form['password']
        else:
            return "No password set."
        user = d2_user.query.filter_by(username=username).filter_by(
            upload_auth=password).first()
        if user:
            #            ban_check = check_ban_by_id(user.user_id)
            #            if ban_check:
            #                return "This user or IP address is banned."
            uploadfolder = syndbb.app.static_folder + "/data/uploads/" + user.username + "/"
            if not syndbb.os.path.exists(uploadfolder):
                syndbb.os.makedirs(uploadfolder)
            if 'file' not in syndbb.request.files:
                return "No file selected."
            file = syndbb.request.files['file']
            if file.filename == '':
                return "No file selected."
            if file:
                filename = secure_filename(file.filename)
                extension = syndbb.os.path.splitext(filename)[1]
                newname = ''.join(
                    random.sample(
                        "-_" + string.ascii_uppercase + string.ascii_lowercase
                        + string.digits, 20)) + extension
                file.save(syndbb.os.path.join(uploadfolder, newname))
                if extension in image_types:
                    piexif.remove(uploadfolder + newname)

                uploadurl = user.upload_url
                if uploadurl == "local":
                    uploadurl = cdn_path(
                    ) + "/data/uploads/" + user.username + "/" + newname
                else:
                    uploadurl = "https://" + uploadurl + "/" + user.username + "/" + newname
                syndbb.cache.delete_memoized(
                    syndbb.views.upload.get_user_files)

                return uploadurl
        else:
            return "Invalid details or not logged in."
    else:
        return "Invalid request, must be POST."
Esempio n. 28
0
def task_proc(task_list, fpath_list):
    '''

    :param task_list:
    :param fpath_list:
    :return:
    '''
    for img_path in fpath_list:
        # check if the image file is valid
        if '1' in task_list:
            im = Image.open(img_path)
            try:
                im.load()
            except:
                print('removing the corrupted image file: {}'.format(img_path))
                os.system('rm {}'.format(img_path))

        # remove EXIF info from the img file
        if '2' in task_list:
            try:
                piexif.remove(img_path)
            except:
                print('piexif raise exceptions when processing {}'.format(
                    img_path))

        # convert image to RGB and 3-channel mode
        if '3' in task_list:
            saving_flag = False

            pil_im = Image.open(img_path)
            if pil_im.mode != "RGB":
                pil_im = pil_im.convert("RGB")
                saving_flag = True
                print("RGB issue: %s" % img_path)

            im = np.array(pil_im)
            if len(im.shape) < 2:
                im = im[0]
                pil_im = Image.fromarray(im)
                pil_im.save(img_path, "JPEG")
                print("too few channel: %s" % img_path)
            elif len(im.shape) == 3 and im.shape[2] >= 4:
                im = im[:, :, :3]
                pil_im = Image.fromarray(im)
                pil_im.save(img_path, "JPEG")
                print("too much channel: %s" % img_path)
            else:
                if saving_flag:
                    pil_im.save(img_path, "JPEG")
Esempio n. 29
0
    def test_remove(self):
        piexif.remove(INPUT_FILE1, "remove.jpg")
        exif_dict = piexif.load("remove.jpg")
        none_dict = {"0th":{},
                     "Exif":{},
                     "GPS":{},
                     "Interop":{},
                     "1st":{},
                     "thumbnail":None}
        self.assertEqual(exif_dict, none_dict)

        piexif.remove("remove.jpg")
        exif_dict = piexif.load("remove.jpg")
        self.assertEqual(exif_dict, none_dict)
        os.remove("remove.jpg")
Esempio n. 30
0
 def test_remove2(self):
     with open(INPUT_FILE1, "rb") as f:
         data = f.read()
     with open("remove2.jpg", "wb+") as f:
         f.write(data)
     piexif.remove("remove2.jpg")
     exif_dict = piexif.load("remove2.jpg")
     none_dict = {"0th":{},
                  "Exif":{},
                  "GPS":{},
                  "Interop":{},
                  "1st":{},
                  "thumbnail":None}
     self.assertEqual(exif_dict, none_dict)
     os.remove("remove2.jpg")
Esempio n. 31
0
 def test_remove2(self):
     with open(INPUT_FILE1, "rb") as f:
         data = f.read()
     with open("remove2.jpg", "wb+") as f:
         f.write(data)
     piexif.remove("remove2.jpg")
     exif_dict = piexif.load("remove2.jpg")
     none_dict = {"0th":{},
                  "Exif":{},
                  "GPS":{},
                  "Interop":{},
                  "1st":{},
                  "thumbnail":None}
     self.assertEqual(exif_dict, none_dict)
     os.remove("remove2.jpg")
Esempio n. 32
0
    def test_remove(self):
        piexif.remove(INPUT_FILE1, "remove.jpg")
        exif_dict = piexif.load("remove.jpg")
        none_dict = {"0th":{},
                     "Exif":{},
                     "GPS":{},
                     "Interop":{},
                     "1st":{},
                     "thumbnail":None}
        self.assertEqual(exif_dict, none_dict)

        piexif.remove("remove.jpg")
        exif_dict = piexif.load("remove.jpg")
        self.assertEqual(exif_dict, none_dict)
        os.remove("remove.jpg")
Esempio n. 33
0
def remove_exif(dir, phase):
    dir = os.path.expanduser(dir)
    for target in sorted(os.listdir(dir)):
        d = os.path.join(dir, target)
        d = os.path.join(d, phase)
        if not os.path.isdir(d):
            continue
        for root, _, fnames in sorted(os.walk(d)):
            for fname in sorted(fnames):
                if not is_image_file(fname):
                    continue
                path = os.path.join(root, fname)
                try:
                    piexif.remove(path)
                except:
                    print("Failed to remove exif for: " + path)
Esempio n. 34
0
 def test_remove_m(self):
     """'remove' on memory.
     """
     o = io.BytesIO()
     with  self.assertRaises(ValueError):
         piexif.remove(I1)
     piexif.remove(I1, o)
     exif_dict = piexif.load(o.getvalue())
     none_dict = {"0th":{},
                  "Exif":{},
                  "GPS":{},
                  "Interop":{},
                  "1st":{},
                  "thumbnail":None}
     self.assertEqual(exif_dict, none_dict)
     Image.open(o).close()
Esempio n. 35
0
 def test_remove_m(self):
     """'remove' on memory.
     """
     o = io.BytesIO()
     with  self.assertRaises(ValueError):
         piexif.remove(I1)
     piexif.remove(I1, o)
     exif_dict = piexif.load(o.getvalue())
     none_dict = {"0th":{},
                  "Exif":{},
                  "GPS":{},
                  "Interop":{},
                  "1st":{},
                  "thumbnail":None}
     self.assertEqual(exif_dict, none_dict)
     Image.open(o).close()
Esempio n. 36
0
#!/usr/bin/env python


import sys
import piexif
from PIL import Image


def isJPEG(filename):
    try:
        img = Image.open(filename)
        return img.format == 'JPEG'
    except IOError:
        return False


usageString = """
Usage:
    ./remove-exif.py name.jpg
    ./remove-exif.py *.jpg
"""
if len(sys.argv) == 1:
    print(usageString)

for arg in sys.argv[1:]:
    if isJPEG(arg) == True:
        piexif.remove(arg)
        print(arg + ' -> has been removed Exif.')
    else:
        print(arg + ' -> is not a JPEG image!')
Esempio n. 37
0
def remove_sample():
    piexif.remove(os.path.join("tests", "images", "01.jpg"),
                 "remove_sample.jpg")