| #requires pip install python-opencv-headless |
| |
| import argparse |
| import cv2 as cv |
| import numpy as np |
| import os |
| |
| parser = argparse.ArgumentParser(description= |
| """ |
| Compares to images by pixels, outputing two different images for the differences. |
| |
| output file {status} |
| output file {name}.diff0.png |
| The exact abs(A - B) of each pixel |
| output file {name}.diff1.png |
| A mask which has 1 for difference and 0 for no difference at a given pixel |
| """) |
| |
| parser.add_argument("-n", "--name", type=str, required=True, help="name used for output images") |
| parser.add_argument("-c", "--candidate", type=str, required=True, help="candidate for image diffing") |
| parser.add_argument("-g", "--golden", type=str, required=True, help="golden to compare against") |
| parser.add_argument("-s", "--status", type=str, required=True, help="output stats file name and location") |
| parser.add_argument("-o", "--outdir", type=str, help="output directory to store image diffs, if not provided then no output image is saved") |
| parser.add_argument("-v", "--verbose", action='store_true', help="enable verbose logging") |
| parser.add_argument("-l", "--log", action='store_true', help="redirect all verbose logging to a file with --name") |
| parser.add_argument("-H", "--histogram", action='store_true', help="compare images using histograms as an additional method for ruling out 'same' images. This should prevent subtle differences in the image that should not be visible from preventing a passing result") |
| |
| args = parser.parse_args() |
| |
| def verbose_log(val): |
| if not args.verbose: |
| return |
| if args.log: |
| with open(f"tmp/{args.name}.log", "a") as log_file: |
| log_file.write(val+"\n") |
| else: |
| print(val) |
| |
| def main(): |
| if args.log: |
| os.makedirs("tmp", exist_ok=True) |
| |
| size_match = False |
| failed = False |
| try: |
| verbose_log(f"loading {args.candidate}") |
| candidate = cv.imread(args.candidate) |
| verbose_log(f"loading {args.golden}") |
| golden = cv.imread(args.golden) |
| |
| if candidate is not None and golden is not None: |
| size_match = candidate.shape == golden.shape |
| # get absolute difference between golden and candidate |
| diff = cv.absdiff(golden, candidate) |
| #convert diff to grey scale to make calculations easier |
| grey_diff = cv.cvtColor(diff, cv.COLOR_BGR2GRAY) |
| #convert to rgb for output png |
| rgb_diff = cv.cvtColor(diff, cv.COLOR_BGR2RGB) |
| # convert the diff to just white where a difference is |
| _, mask = cv.threshold(grey_diff, 0, 255, cv.THRESH_BINARY) |
| # get the total number of different pixels |
| total_diff_count = cv.countNonZero(grey_diff) |
| # get the max channel independent difference |
| max_diff = int(diff.max()) |
| # get average pixel diff, this result is slitely different then imageDiff but its very close. |
| # the only difference is that we first convert the diff to grey scale rather than adding the max of every channel |
| avg = grey_diff.sum() / (grey_diff.shape[0]*grey_diff.shape[1]*255) |
| |
| if args.histogram: |
| # convert to HSV |
| hsv_candidate = cv.cvtColor(candidate, cv.COLOR_BGR2HSV) |
| hsv_golden = cv.cvtColor(golden, cv.COLOR_BGR2HSV) |
| |
| # down sample to 32x32 for the histogram |
| h_bins = 32 |
| s_bins = 32 |
| histSize = [h_bins, s_bins] |
| |
| # available range for hue and saturation |
| h_ranges = [0, 180] |
| s_ranges = [0, 256] |
| ranges = h_ranges + s_ranges |
| |
| # get our histograms |
| hist_candidate = cv.calcHist(hsv_candidate, [0,1], None, histSize, ranges, accumulate=False) |
| hist_golden = cv.calcHist(hsv_golden, [0,1], None, histSize, ranges, accumulate=False) |
| |
| # compare using CORREL histogram algorithm. the different options are detailed here |
| # https://docs.opencv.org/3.4/d6/dc7/group__imgproc__hist.html#ga994f53817d621e2e4228fc646342d386 |
| # a hist_result of 1.0 means identical with this method. any variance results in a number less then 1.0 |
| hist_result = cv.compareHist(hist_candidate, hist_golden, cv.HISTCMP_CORREL) |
| |
| except Exception as E: |
| print(f"Failed to load and process images {E}") |
| failed = True |
| |
| # make path to stats file if necessary |
| if os.path.dirname(args.status): |
| verbose_log(f"making status file path {os.path.dirname(args.status)}") |
| os.makedirs(os.path.dirname(args.status), exist_ok=True) |
| verbose_log(f"making status file {args.status}") |
| with open(args.status, "a") as status: |
| status.write(args.name + "\t"); |
| if candidate is None: |
| status.write("missing_candidate\n") |
| verbose_log("missing golden for " + args.name) |
| return |
| if golden is None: |
| status.write("missing_golden\n") |
| verbose_log("missing golden for " + args.name) |
| return |
| if failed: |
| status.write("failed\n") |
| verbose_log("failed to load golden or candidate") |
| return |
| if total_diff_count == 0: |
| status.write("identical\n") |
| verbose_log("files are identical") |
| return |
| if not size_match: |
| status.write("sizemismatch\n") |
| verbose_log("files are not the same size") |
| return |
| status.write(str(max_diff)+"\t") |
| # prevent python from writing out in scientific notation |
| status.write(f"{float(avg):.5f}\t") |
| status.write(str(total_diff_count)+"\t") |
| status.write(str(diff.shape[0]*diff.shape[1])) |
| # add our histogram result as the last value of the status file or write a new line to say we are finished with this status |
| if args.histogram: |
| status.write(f"\t{float(hist_result):.5f}\n") |
| else: |
| status.write("\n") |
| |
| verbose_log("status file finished") |
| # save the output file if location provided |
| if args.outdir: |
| # color diff file location |
| c_diff_path = os.path.join(args.outdir, args.name + ".diff0.png") |
| # mask diff file location |
| c_mask_path = os.path.join(args.outdir, args.name + ".diff1.png") |
| # create output dir if needed |
| verbose_log(f"making output directory {args.outdir}") |
| os.makedirs(args.outdir, exist_ok=True) |
| verbose_log(f"writing images {c_diff_path} and {c_mask_path}") |
| cv.imwrite(c_diff_path, rgb_diff) |
| cv.imwrite(c_mask_path, mask) |
| verbose_log("finished writing output images") |
| |
| if __name__ == '__main__': |
| main() |
