DHash | Comparing images with dHash algorithm | Computer Vision library

I am trying to perform difference hashing with the python ImageHash library and keep getting a numpy error.

The error:

File "/Users/testuser/Desktop/test_folder/test_env/lib/python3.8/site-packages/imagehash.py", line 252, in dhash image = image.convert("L").resize((hash_size + 1, hash_size), Image.ANTIALIAS) AttributeError: 'numpy.ndarray' object has no attribute 'convert'

The code:

I am new to Python and am writing an application to identify matching images. I am using the dHash algorithm to compare the hashes of images. I have seen in a tutorial the following lines of code:

Each item in my collection has a 64-bit number, which represents dhash of the image. I want to run a query by this field, which will return all items, that have Hamming Distance more or less than some param.

In MySQL I would use BIT_COUNT function. Is there any built-in analog of it in CosmosDB? If no, then how my HAMMING_DISTANCE UDF should look like since JS doesn't support bitwise operations on 64-bit numbers?

I try to create some hashes on a cuda device and printing them on the host. But at the printf on the host i am getting a read error at position 0x000000000100002F

The relevant lines look like this:

I am not sure at all what changed. There were a couple of app upgrades that I ran which might or might not have caused the issue. I believe this may be an issue with the path but I am really not sure. That is the reason I am posting here. Thanks for your help in advance.

This is what I receive when I attempt to run any NPM command:

I have 2 image folder containing 10k and 35k images. Each image is approximately the size of (2k,2k).
I want to remove the images which are exact duplicates.
The variation in different images are just a change in some pixels.
I have tried DHashing, PHashing, AHashing but as they are lossy image hashing technique so they are giving the same hash for non-duplicate images too.
I also tried writing a code in python, which will just subtract images and the combination in which the resultant array is not zero everywhere gives those image pair to be duplicate of each other. Buth the time for a single combination is 0.29 seconds and for total 350 million combinations is really huge.
Is there a way to do it in a faster way without flagging non-duplicate images also. I am open to doing it in any language(C,C++), any approach(distributed computing, multithreading) which can solve my problem accurately.
Apologies if I added some of the irrelevant approaches as I am not from computer science background.
Below is the code I used for python approach -

I've cobbled together/wrote some code (Thanks stackoverflow users!) that checks for similarities in images using imagehash, but now I am having issues checking thousands of images (roughly 16,000). Is there anything that I could improve with the code (or a different route entirely) that can more accurately find matches and/or decrease time required? Thanks!

I first changed my list that is created to an itertools combination, so it only compares unique combinations of images.

Assume that one picture with different resolutions from one host has more than one copies.

At the metasearcher stage, I want to check if the 2 pictures have the same names, but not trivial names (such as image.jpg, photo.jpg ...). In this case, I want to include only the picture with higher resolution.

Example: search for "city"

https://znews-photo.zadn.vn/w480/Uploaded/lerl/2017_10_07/DJI_005701_zing.jpeg

​https://znews-photo.zadn.vn/Uploaded/lerl/2017_10_07/DJI_005701_zing.jpeg

The first one should not be returned.

This is a job assignment from a web search team, therefore I care a lot about performance.

My current approach:

*) To avoid trivial names, iterate through the testing queries for image search, count the number of appearance of each token from different URLs after tokenized by "/", and manually pick the most appeared tokens in the URLs which are similar to "photo", "picture", "background", etc... In the end, I will have a set of trivial names.

*) For pictures with the same name, each picture I get its dHash, its resolution, for every pair of pictures with dHash difference less than a certain thresh hold, I discard the picture with smaller resolution.

Edit: After consulted with my manager, I realized that I misunderstood the requirements. I should only work purely on the URLs without accessing to the actual images (which would be too expensive). With the example above, I should be able to discard the first image based on the URLs difference of the two. Also, as the result, expecting accuracy isn't high, anything > 85% should be decent.

I greatly appreciate any ideas/insights on improving my current approach.

I'd like to compare ORB, SIFT, BRISK, AKAZE, etc. to find which works best for my specific image set. I'm interested in the final alignment of images.

Is there a standard way to do it?

I'm considering this solution: take each algorithm, extract the features, compute the homography and transform the image.

Now I need to check which transformed image is closer to the target template.

Maybe I can repeat the process with the target template and the transformed image and look for the homography matrix closest to the identity but I'm not sure how to compute this closeness exactly. And I'm not sure which algorithm should I use for this check, I suppose a fixed one.

Or I could do some pixel level comparison between the images using a perceptual difference hash (dHash). But I suspect the the following hamming distance may not be very good for images that will be nearly identical.

I could blur them and do a simple subtraction but sounds quite weak.

Thanks for any suggestions.

EDIT: I have thousands of images to test. These are real world pictures. Images are of documents of different kinds, some with a lot of graphics, others mostly geometrical. I have about 30 different templates. I suspect different templates works best with different algorithms (I know in advance the template so I could pick the best one).

Right now I use cv2.matchTemplate to find some reference patches in the transformed images and I compare their locations to the reference ones. It works but I'd like to improve over this.