Python imagehash.average_hash方法代碼示例

# 需要導入模塊: import imagehash [as 別名]
# 或者: from imagehash import average_hash [as 別名]
def trumpify(filename):
	inp = filename
	original = Image.open(inp).convert('RGBA')
	rects = face_rects(inp)
	width, height = original.size
	for overlay_fname in ['hair.png']:
		overlay = Image.open(overlay_fname).convert('RGBA')
		for rect in rects:
			original = overlay_alpha_png(original, overlay, rect)

	#overlay_alpha_png(original, Image.open('logo.png').convert('RGBA'), (width - 225,height - 50,200,100))
	width, height = original.size


	hashval = imagehash.average_hash(original)
	print hashval
	original.save('outs/' + str(hashval) + '.png')
	return str(hashval) + '.png' 

# 需要導入模塊: import imagehash [as 別名]
# 或者: from imagehash import average_hash [as 別名]
def run(self):
        date_path = self.search['date_path']
        files = sorted(os.listdir('data/%s/media' % date_path))
        hashes = {}
        matches = []
        g = nx.Graph()
        update_block_size = get_block_size(len(files), 5)
        for i in range(len(files)):
            f = files[i]
            fn = 'data/%s/media/%s' % (date_path, f)
            ahash = imagehash.average_hash(Image.open(fn))
            dhash = imagehash.dhash(Image.open(fn))
            phash = imagehash.phash(Image.open(fn))
            hashes[f] = {'ahash': ahash, 'dhash': dhash, 'phash': phash}
            for j in range(0, i):
                f2name = files[j]
                f2 = hashes[f2name]
                sumhash = sum([ahash - f2['ahash'],
                               dhash - f2['dhash'],
                               phash - f2['phash']])
                # FIXME: 40 is a hard-coded arbitrary (eyeballed) threshold
                if sumhash <= 40:
                    matches.append([f, files[j],
                                    ahash - f2['ahash'],
                                    dhash - f2['dhash'],
                                    phash - f2['phash'],
                                    sumhash])
                    g.add_edge(f, f2name)
            if i % update_block_size == 0:
                self.update_job(
                    date_path=self.search['date_path'],
                    status="STARTED: %s - %s/%s" %
                           (self.task_family, i, len(files))
                )
        with self.output().open('w') as fp_graph:
            components = list(nx.connected_components(g))
            # Note: sets are not JSON serializable
            d = []
            for s in components:
                d.append(list(s))
            json.dump(d, fp_graph, indent=2) 

# 需要導入模塊: import imagehash [as 別名]
# 或者: from imagehash import average_hash [as 別名]
def get_picture_hash(dir_name):
    dict1 = dict()
    for i, each_picture in enumerate(os.listdir(dir_name)):
        if each_picture.endswith(".png") or each_picture.endswith(".jpg"):
            picture_hash = imagehash.average_hash(Image.open(os.path.join(dir_name, each_picture)))
            order = os.path.splitext(each_picture)[0]
            dict1[order] = picture_hash
    return dict1 

# 需要導入模塊: import imagehash [as 別名]
# 或者: from imagehash import average_hash [as 別名]
def getImageHash(img):
    io = Image.open(img)
    hash1 = imagehash.average_hash(io)
    hash2 = imagehash.phash(io)
    hash3 = imagehash.dhash(io)
    return hash1, hash2, hash3 

# 需要導入模塊: import imagehash [as 別名]
# 或者: from imagehash import average_hash [as 別名]
def dist(self, image_1, image_2):
        """
        Calculates distance of two images.
        """
        hash_1 = imagehash.average_hash(image_1)

        hash_2 = imagehash.average_hash(image_2)

        return hash_1 - hash_2 

# 需要導入模塊: import imagehash [as 別名]
# 或者: from imagehash import average_hash [as 別名]
def deduplicate_images(self, userpath, hashfunc=imagehash.average_hash):
        """
        Remove duplicate images from a path
        :userpath: path of the image files
        :hashfunc: type of image hashing method
        """

        def is_image(filename):
            img_ext = [".jpg", ".png", ".gif", ".bmp", ".gif"]
            f = filename.lower()
            return any(f.endswith(ext) for ext in img_ext)

        """
        Available hashs functions:
            ahash:      Average hash
            phash:      Perceptual hash
            dhash:      Difference hash
            whash-haar: Haar wavelet hash
            whash-db4:  Daubechies wavelet hash
        """
        dd_img_set = []

        image_filenames = [os.path.join(userpath, path) for path in os.listdir(userpath) if is_image(path)]
        images = {}
        for img in sorted(image_filenames):
            hash = hashfunc(Image.open(img))
            images[hash] = images.get(hash, []) + [img]
        for k, img_list in six.iteritems(images):
            dd_img_set.append(os.path.basename(img_list[0]))
        dd_img_set.sort()
        return dd_img_set 

# 需要導入模塊: import imagehash [as 別名]
# 或者: from imagehash import average_hash [as 別名]
def run(self):
        """Creates a new key in the report dict for 
        the deuplicated screenshots.
        """
        self.key = "deduplicated_shots"
        shots = []

        hashmethod = "whash-db4"
        if hashmethod == 'ahash':
            hashfunc = imagehash.average_hash
        elif hashmethod == 'phash':
            hashfunc = imagehash.phash
        elif hashmethod == 'dhash':
            hashfunc = imagehash.dhash
        elif hashmethod == 'whash-haar':
            hashfunc = imagehash.whash
        elif hashmethod == 'whash-db4':
            hashfunc = lambda img: imagehash.whash(img, mode='db4')

        shots_path = os.path.join(self.analysis_path, "shots")
        if os.path.exists(shots_path):
            screenshots = self.deduplicate_images(userpath=shots_path, hashfunc=hashfunc)
            for screenshot in screenshots:
                shots.append(screenshot.replace(".jpg",""))

        return shots