pHash | pHash - the open source perceptual hash library | Hashing library

I have an application that uses OpenGL to draw output images. For testing purposes I'm trying to create reference images and then use precision hash to compare them to program output. While it works flawlessly within a context of a single computer I've encountered strange problems when using the same approach with computers running different GPUs. While the images generated on different GPUs appear absolutely identical to human eye they cannot pass prescision hash test when compared to one another and per-pixel comparison reveals that there are several pixels that are "off". I've been trying to find problems in my code for several days to no avail and this behaviour manifests itself on all the shaders that I use. Could this possibly be due to differences in OpenGL implementation from different hardware manufacturers? Is it a valid approach to compare images generated on different GPUs with phash for testing purposes?

I want to calculate the phash from about 10.000.000 pictures, from which i only have the url where they are located at.

I know how to download a picture and then calculate the phash after that, but i always have to safe the picture first.

Is it possible to download the picture and calculate the phash without saving it or is it even possible to not download the picture at all and just calculate the phash just using the url?

This is my code to download the first ten pictures and calculate the phash:

I'm currently having difficulties saving hashes to a txt file.

I am getting a hash from each image I download from reddit, and I am wishing to store this hash into a txt file if its not in the txt file already.

If the hash of the image is already in the txt file, it wont post it in the txt file again (no duplicate hashes) and it will delete the image.

However, i am having difficulty doing this, as it adds the same hash multiple times.

I'm trying to add a custom collating function into a qt project, using sqlite. I'm getting a segfault that i don't understand, thus can't fix.

It comes from the following code, in the sqlite3_create_collation sql function.

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'm using Shipwreck.Phash for image comparison. I just recognized that two identical white images return a cross correlation of 0, although it should return 1.

hash1: 0x00000000000000000000000000000000000000000000000000000000000000000000000000000000

hash2: 0x00000000000000000000000000000000000000000000000000000000000000000000000000000000

CrossCorrelation: 0

My code:

I am creating a application in Node.js to download image files. However, I have been having an issue where if my download speed is slow or I lose connection the image I am downloading will be truncated. This would not be so bad if my program threw an error warning me that the image did not finish downloading, however, it does not and resolves as if the image downloaded successfully. I do not receive an error when I check the response code or probe the image after downloading.

This is the current code I am using to download images.

I am Trying to compare two images which looks similar , but When I do pixel to pixel comparison ,they won't be similar . Here the Problem is the Image is compressed in different Ratios .

To give more Example , If we take the Facebook Profile picture and the Twitter Profile Picture and Compare Pixel by pixel , we will see images are NOT Same . But by look and feel, we will see Image are same (Image Width and Height are same)

I have tried one of the Library called ImageHashing which is available in Python , when I use Average hashing , even when I Have dark Line on image it will show as same , where Phash will have same problem as Pixel to pixel compare .

The Other way which, I thought was Template matching(OpenCV) , But I am not so convinced for Image Comparison

Is there any way can compare two similar images which are compressed or Sampled differently and get proper result ?

trying to build ffmpeg on ubuntu 18.10

https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu

first install dependencies