add phash high frequence factor

Author: bjlittle

pytest_mpl/kernels.py

@@ -14,13 +14,17 @@
 #: The default imagehash hash size (N), resulting in a hash of N**2 bits.
 DEFAULT_HASH_SIZE = 16
 
+#: Level of image detail (high) or structure (low) represented by phash .
+DEFAULT_HIGH_FREQUENCY_FACTOR = 4
+
 #: Registered kernel names.
 KERNEL_SHA256 = "sha256"
 KERNEL_PHASH = "phash"
 
 __all__ = [
     "DEFAULT_HAMMING_TOLERANCE",
     "DEFAULT_HASH_SIZE",
+    "DEFAULT_HIGH_FREQUENCY_FACTOR",
     "KERNEL_PHASH",
     "KERNEL_SHA256",
     "KernelPHash",
@@ -36,7 +40,7 @@ class Kernel(ABC):
     """
 
     def __init__(self, plugin):
-        # Containment (read-only) of the plugin allows the kernel to cherry-pick state that it requires
+        # Containment of the plugin allows the kernel to cherry-pick required state
         self._plugin = plugin
 
     @abstractmethod
@@ -104,6 +108,7 @@ def update_summary(self, summary):
         Parameters
         ----------
         summary : dict
+            Image comparison test report summary.
 
         Returns
         -------
@@ -127,15 +132,22 @@ class KernelPHash(Kernel):
 
     def __init__(self, plugin):
         super().__init__(plugin)
+        # keep state of equivalence result
+        self.equivalent = None
+        # keep state of hash hamming distance (whole number) result
+        self.hamming_distance = None
+        # value may be overridden by py.test marker kwarg
+        self.hamming_tolerance = (
+            self._plugin.hamming_tolerance or DEFAULT_HAMMING_TOLERANCE
+        )
+        # the hash-size (N) defines the resultant N**2 bits hash size
         self.hash_size = self._plugin.hash_size
+        # the level of image detail or structure represented by perceptual hash
+        self.high_freq_factor = (
+            self._plugin.high_freq_factor or DEFAULT_HIGH_FREQUENCY_FACTOR
+        )
         # py.test marker kwarg
         self.option = "hamming_tolerance"
-        # value may be overridden by py.test marker kwarg
-        self.hamming_tolerance = self._plugin.hamming_tolerance or DEFAULT_HAMMING_TOLERANCE
-        # keep state of hash hamming distance (whole number) result
-        self.hamming_distance = None
-        # keep state of equivalence result
-        self.equivalent = None
 
     def equivalent_hash(self, actual, expected, marker=None):
         if marker:
@@ -149,14 +161,18 @@ def equivalent_hash(self, actual, expected, marker=None):
     def generate_hash(self, buffer):
         buffer.seek(0)
         data = Image.open(buffer)
-        phash = imagehash.phash(data, hash_size=self.hash_size)
+        phash = imagehash.phash(
+            data, hash_size=self.hash_size, highfreq_factor=self.high_freq_factor
+        )
         return str(phash)
 
     def update_status(self, message):
         result = str() if message is None else str(message)
         if self.equivalent is False:
-            msg = (f"Hash hamming distance of {self.hamming_distance} bits > "
-                   f"hamming tolerance of {self.hamming_tolerance} bits.")
+            msg = (
+                f"Hash hamming distance of {self.hamming_distance} bits > "
+                f"hamming tolerance of {self.hamming_tolerance} bits."
+            )
             result = f"{message} {msg}" if len(result) else msg
         return result
 

pytest_mpl/plugin.py

@@ -43,7 +43,8 @@
 
 import pytest
 
-from .kernels import DEFAULT_HAMMING_TOLERANCE, DEFAULT_HASH_SIZE, KERNEL_SHA256, kernel_factory
+from .kernels import (DEFAULT_HAMMING_TOLERANCE, DEFAULT_HASH_SIZE,
+                      DEFAULT_HIGH_FREQUENCY_FACTOR, KERNEL_SHA256, kernel_factory)
 from .summary.html import generate_summary_basic_html, generate_summary_html
 
 #: The default matplotlib backend.
@@ -67,6 +68,9 @@
 #: Valid formats for generate summary.
 SUPPORTED_FORMATS = {'html', 'json', 'basic-html'}
 
+#: Supported INET protocols.
+PROTOCOLS = ('http://', 'https://')
+
 #: Template error message for image shape conformance.
 TEMPLATE_SHAPE_MISMATCH = """Error! Image dimensions did not match.
 
@@ -150,22 +154,31 @@ def pytest_addoption(parser):
 
     msg = ('Directory for test results, relative to location where py.test '
            'is run.')
-    group.addoption('--mpl-results-path', help=msg, action='store')
-    parser.addini('mpl-results-path', help=msg)
+    option = 'mpl-results-path'
+    group.addoption(f'--{option}', help=msg, action='store')
+    parser.addini(option, help=msg)
 
     msg = ('Always compare to baseline images and save result images, even '
            'for passing tests. This option is automatically applied when '
            'generating a HTML summary.')
-    group.addoption('--mpl-results-always', help=msg, action='store_true')
-    parser.addini('mpl-results-always', help=msg)
+    option = 'mpl-results-always'
+    group.addoption(f'--{option}', help=msg, action='store_true')
+    parser.addini(option, help=msg)
 
     msg = 'Use fully qualified test name as the filename.'
     parser.addini('mpl-use-full-test-name', help=msg, type='bool')
 
     msg = ('Algorithm to be used for hashing images. Supported kernels are '
            '`sha256` (default) and `phash`.')
-    group.addoption('--mpl-kernel', help=msg, action='store')
-    parser.addini('mpl-kernel', help=msg)
+    option = 'mpl-kernel'
+    group.addoption(f'--{option}', help=msg, action='store')
+    parser.addini(option, help=msg)
+
+    msg = ('Determine the level of image detail (high) or structure (low)'
+           'represented in the perceptual hash.')
+    option = 'mpl-high-freq-factor'
+    group.addoption(f'--{option}', help=msg, action='store')
+    parser.addini(option, help=msg)
 
     msg = 'The hash size (N) used to generate a N**2 bit image hash.'
     group.addoption('--mpl-hash-size', help=msg, action='store')
@@ -211,8 +224,7 @@ def pytest_configure(config):
                         "--mpl-generate-path is set")
                 warnings.warn(wmsg)
 
-        protocols = ("https", "http")
-        if baseline_dir is not None and not baseline_dir.startswith(protocols):
+        if baseline_dir is not None and not baseline_dir.startswith(PROTOCOLS):
             baseline_dir = os.path.abspath(baseline_dir)
         if generate_dir is not None:
             baseline_dir = os.path.abspath(generate_dir)
@@ -249,8 +261,9 @@ def switch_backend(backend):
 
 
 def close_mpl_figure(fig):
-    "Close a given matplotlib Figure. Any other type of figure is ignored"
-
+    """
+    Close a given matplotlib Figure. Any other type of figure is ignored
+    """
     import matplotlib.pyplot as plt
     from matplotlib.figure import Figure
 
@@ -264,11 +277,12 @@ def close_mpl_figure(fig):
 
 def get_marker(item, marker_name):
     if hasattr(item, 'get_closest_marker'):
-        return item.get_closest_marker(marker_name)
+        result = item.get_closest_marker(marker_name)
     else:
         # "item.keywords.get" was deprecated in pytest 3.6
         # See https://docs.pytest.org/en/latest/mark.html#updating-code
-        return item.keywords.get(marker_name)
+        result = item.keywords.get(marker_name)
+    return result
 
 
 def path_is_not_none(apath):
@@ -308,24 +322,30 @@ def __init__(self,
         self.results_always = results_always
 
         # Configure hashing kernel options.
-        option = "mpl-hash-size"
-        hash_size = int(config.getoption(f"--{option}") or
+        option = 'mpl-hash-size'
+        hash_size = int(config.getoption(f'--{option}') or
                         config.getini(option) or DEFAULT_HASH_SIZE)
         self.hash_size = hash_size
 
-        option = "mpl-hamming-tolerance"
-        hamming_tolerance = int(config.getoption(f"--{option}") or
+        option = 'mpl-hamming-tolerance'
+        hamming_tolerance = int(config.getoption(f'--{option}') or
                                 config.getini(option) or
                                 DEFAULT_HAMMING_TOLERANCE)
         self.hamming_tolerance = hamming_tolerance
 
+        option = 'mpl-high-freq-factor'
+        high_freq_factor = int(config.getoption(f'--{option}') or
+                               config.getini(option) or
+                               DEFAULT_HIGH_FREQUENCY_FACTOR)
+        self.high_freq_factor = high_freq_factor
+
         # Configure the hashing kernel - must be done *after* kernel options.
-        option = "mpl-kernel"
-        kernel = config.getoption(f"--{option}") or config.getini(option)
+        option = 'mpl-kernel'
+        kernel = config.getoption(f'--{option}') or config.getini(option)
         if kernel:
             requested = str(kernel).lower()
             if requested not in kernel_factory:
-                emsg = f"Unrecognised hashing kernel {kernel!r} not supported."
+                emsg = f'Unrecognised hashing kernel {kernel!r} not supported.'
                 raise ValueError(emsg)
             kernel = requested
         else:
@@ -421,7 +441,7 @@ def get_baseline_directory(self, item):
                     baseline_dir = self.baseline_dir
 
         baseline_remote = (isinstance(baseline_dir, str) and  # noqa
-                           baseline_dir.startswith(('http://', 'https://')))
+                           baseline_dir.startswith(PROTOCOLS))
         if not baseline_remote:
             return Path(item.fspath).parent / baseline_dir
 
@@ -457,7 +477,7 @@ def obtain_baseline_image(self, item, target_dir):
         filename = self.generate_filename(item)
         baseline_dir = self.get_baseline_directory(item)
         baseline_remote = (isinstance(baseline_dir, str) and  # noqa
-                           baseline_dir.startswith(('http://', 'https://')))
+                           baseline_dir.startswith(PROTOCOLS))
         if baseline_remote:
             # baseline_dir can be a list of URLs when remote, so we have to
             # pass base and filename to download