I am using the the image-comparison library in mobile visual test automation and in some cases even with size mismatch it's practical to do the comparison despite the size difference that's in case of the design will keep it's ratio.

another case the difference sometimes could be small number of pixels so that I find it very useful that we have an option to resize the actual image to the expected dimensions and then do the comparison.

wating for your opinion and many thanks.

-Added overloaded function of compareImages(boolean resizeIfSizeMisMatch) to enable resizing to expected dimensions. -Added resize function to utils.

Describe the bug The program hangs forever.

To Reproduce Steps to reproduce the behavior:

1. Download attached zip and extract the 2 image files anywhere. files.zip
2. Run this code:

ImageComparison comparison = new ImageComparison("output_153.png", "output_154.png"); comparison.createMask(); // hangs forever

Expected behavior Program should run and exit appropriately.

Screenshots See attached zip above

Java

• OS: Windows
• openjdk version "1.8.0_252"

Additional context I managed to trace this to the method mergeRectangles. I don't know why it hangs, but I debugged it and the (minimum and maximum rectangles) are equal to the image size (width*height). I (thought I) fixed it (see my comment) by skipping running mergeRectangles in a special scenario:

private List<Rectangle> populateRectangles() {
        long countOfDifferentPixels = populateTheMatrixOfTheDifferences();

        if (countOfDifferentPixels == 0) {
            return emptyList();
        }

        if (isAllowedPercentOfDifferentPixels(countOfDifferentPixels)) {
            return emptyList();
        }
        groupRegions();
        List<Rectangle> rectangles = new ArrayList<>();

        int minX = Integer.MAX_VALUE, minY = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE, maxY = Integer.MIN_VALUE;

        while (counter <= regionCount) {
            Rectangle rectangle = createRectangle();
            if (!rectangle.equals(Rectangle.createDefault()) && rectangle.size() >= minimalRectangleSize) {
                rectangles.add(rectangle);
                Point min = rectangle.getMinPoint();
                Point max = rectangle.getMaxPoint();
                if (min.x < minX) minX = min.x;
                if (min.y < minY) minY = min.y;
                if (max.x > maxX) maxX = max.x;
                if (max.y > maxY) maxY = max.y;
            }
            counter++;
        }

        if (minX == 0 && minY == 0 &&
            maxX == actual.getWidth() - 1 &&
            maxY == actual.getHeight() - 1)
            return Collections.singletonList(new Rectangle(0, 0, maxX, maxY));

        return mergeRectangles(rectangles);
    }

(I don't feel comfortable making a pull request).

I add many excluded areas to my images and find it very useful that they appear as green rectangles on the results image. I often need to define long exclusions along edges of the image. In those cases, looking at the resulting image, it is not easy to determine which areas have been excluded, partly due to the fact that the green lines along the edges are cropped out of the picture.

It would be less ambiguous if there was an option to fill the the green rectangles with a transparent green fill.

Should close issue #145.

• Migrated from JUnit 4.12 to JUnit 5.5.2 (Jupiter).
• Use JUnit exception handling instead of BaseTest#getException()
• Updated the Gradle version from 3.5-rc-2-all to 6.0.1-bin. Starting with version 4.6, Gradle provides native support for executing tests on the JUnit Platform.
• Fixed Maven warnings for plugins without a version number.
• Fixed Maven warning about platform dependent file encoding.

PR Details

Fix to getDifferencePercent method in ImageComparisonUtil

Description

The getDifferencePercent was calculating pixels incorrectly: instead of calculating each different pixels towards the overall counter, it was using an overall sum of differences. This PR fixes that.

Related Issue

https://github.com/romankh3/image-comparison/issues/233

Motivation and Context

getDifferencePercent can be used to retrieve exact % of differences for ignoring them in ImageComparisonResult config. This can be used to individually configure tests with different images to pass.

How Has This Been Tested

I have ran and updated the existing tests, and also added a new one which gets and sets percentage of differences. I have also tested these changes in my own project, which uses this library with Selenide for Web visual testing: https://github.com/nikmazur/ui-visual-testing

Types of changes

• [ ] Docs change / refactoring / dependency upgrade
• [x] Bug fix (non-breaking change which fixes an issue)
• [ ] New feature (non-breaking change which adds functionality)
• [ ] Breaking change (fix or feature that would cause existing functionality to change)

Checklist

• [x] My code follows the code style of this project.
• [ ] My change requires a change to the documentation.
• [ ] I have updated the documentation accordingly.
• [x] I have read the CONTRIBUTING document.
• [x] I have added tests to cover my changes.
• [x] All new and existing tests passed.

tired other way to set images path but it does not support with makeDiff method. Is there any support for File path ? error is Cannot resolve symbol 'BufferedImage'

Hi Roman

Thank you for providing the comparison tool. It's useful for our work. besides that, Could you consider adding more comparison methods like SSIM (Structural Similarity Index)?

Reference https://pyimagesearch.com/2017/06/19/image-difference-with-opencv-and-python/

https://stackoverflow.com/questions/71567315/how-to-get-the-ssim-comparison-score-between-two-images

https://github.com/americanexpress/jest-image-snapshot

https://www.google.com/amp/s/discuss.dizzycoding.com/detect-and-visualize-differences-between-two-images-with-opencv-python/%3famp=1

I'm trying to understand why getDifferencePercent(BufferedImage img1, BufferedImage img2) on line 138 of the ImageComparisonUtil class is returning a different result than the percent calculated in line 313 of the ImageComparison class.

The algorithm used to acquire the count of different pixels in populateTheMatrixOfTheDifferences() on line 234 seems to be similar to what's being done in getDifferencePercent(BufferedImage img1, BufferedImage img2) but the end result isn't the same.

It seems like if I'm trying to set an allowed percentage difference using setAllowingPercentOfDifferentPixels() I can't use the output of getDifferencePercent as a gauge since that value doesn't match what's calculated during the image comparison inside isAllowedPercentOfDifferentPixels(long countOfDifferentPixels)

Thanks for providing this comparison tool. BTW, I notice that in issue#215, pacioc193 creates GUI for his comparing. FMPV, a concise and convenient GUI is what this tool needs at present. IT IS USEFUL, I NEED IT.