🔨 Extract pixel perfect calculation (AUTOMATIC1111#1522)

Author: huchenlei

scripts/controlnet.py

@@ -716,26 +716,12 @@ def process(self, p, *args):
 
             preprocessor_resolution = unit.processor_res
             if unit.pixel_perfect:
-                raw_H, raw_W, _ = input_image.shape
-                target_H, target_W = h, w
-
-                k0 = float(target_H) / float(raw_H)
-                k1 = float(target_W) / float(raw_W)
-
-                if resize_mode == external_code.ResizeMode.OUTER_FIT:
-                    estimation = min(k0, k1) * float(min(raw_H, raw_W))
-                else:
-                    estimation = max(k0, k1) * float(min(raw_H, raw_W))
-
-                preprocessor_resolution = int(np.round(estimation))
-
-                print(f'Pixel Perfect Mode Enabled.')
-                print(f'resize_mode = {str(resize_mode)}')
-                print(f'raw_H = {raw_H}')
-                print(f'raw_W = {raw_W}')
-                print(f'target_H = {target_H}')
-                print(f'target_W = {target_W}')
-                print(f'estimation = {estimation}')
+                preprocessor_resolution = external_code.pixel_perfect_resolution(
+                    input_image,
+                    target_H=h,
+                    target_W=w,
+                    resize_mode=resize_mode
+                )
 
             print(f'preprocessor resolution = {preprocessor_resolution}')
             detected_map, is_image = preprocessor(input_image, res=preprocessor_resolution, thr_a=unit.threshold_a, thr_b=unit.threshold_b)

scripts/controlnet_ui/controlnet_ui_group.py

@@ -608,26 +608,12 @@ def run_annotator(image, module, pres, pthr_a, pthr_b, t2i_w, t2i_h, pp, rm):
             preprocessor = self.preprocessors[module]
 
             if pp:
-                raw_H, raw_W, _ = img.shape
-                target_H, target_W = t2i_h, t2i_w
-                rm = str(rm)
-
-                k0 = float(target_H) / float(raw_H)
-                k1 = float(target_W) / float(raw_W)
-
-                if rm == external_code.ResizeMode.OUTER_FIT.value:
-                    estimation = min(k0, k1) * float(min(raw_H, raw_W))
-                else:
-                    estimation = max(k0, k1) * float(min(raw_H, raw_W))
-
-                pres = int(np.round(estimation))
-                print(f"Pixel Perfect Mode Enabled In Preview.")
-                print(f"resize_mode = {rm}")
-                print(f"raw_H = {raw_H}")
-                print(f"raw_W = {raw_W}")
-                print(f"target_H = {target_H}")
-                print(f"target_W = {target_W}")
-                print(f"estimation = {estimation}")
+                pres = external_code.pixel_perfect_resolution(
+                    img,
+                    target_H=t2i_h,
+                    target_W=t2i_w,
+                    resize_mode=external_code.resize_mode_from_value(rm),
+                )
 
             class JsonAcceptor:
                 def __init__(self) -> None:

scripts/external_code.py

@@ -65,6 +65,57 @@ def control_mode_from_value(value: Union[str, int, ControlMode]) -> ControlMode:
         return [e for e in ControlMode][value]
     else:
         return value
+    
+
+def pixel_perfect_resolution(
+    image: np.ndarray,
+    target_H: int,
+    target_W: int,
+    resize_mode: ResizeMode,
+) -> int:
+    """
+    Calculate the estimated resolution for resizing an image while preserving aspect ratio.
+
+    The function first calculates scaling factors for height and width of the image based on the target 
+    height and width. Then, based on the chosen resize mode, it either takes the smaller or the larger 
+    scaling factor to estimate the new resolution.
+
+    If the resize mode is OUTER_FIT, the function uses the smaller scaling factor, ensuring the whole image 
+    fits within the target dimensions, potentially leaving some empty space. 
+
+    If the resize mode is not OUTER_FIT, the function uses the larger scaling factor, ensuring the target 
+    dimensions are fully filled, potentially cropping the image.
+
+    After calculating the estimated resolution, the function prints some debugging information.
+
+    Args:
+        image (np.ndarray): A 3D numpy array representing an image. The dimensions represent [height, width, channels].
+        target_H (int): The target height for the image.
+        target_W (int): The target width for the image.
+        resize_mode (ResizeMode): The mode for resizing.
+
+    Returns:
+        int: The estimated resolution after resizing.
+    """
+    raw_H, raw_W, _ = image.shape
+
+    k0 = float(target_H) / float(raw_H)
+    k1 = float(target_W) / float(raw_W)
+
+    if resize_mode == ResizeMode.OUTER_FIT:
+        estimation = min(k0, k1) * float(min(raw_H, raw_W))
+    else:
+        estimation = max(k0, k1) * float(min(raw_H, raw_W))
+    
+    print(f"Pixel Perfect Mode Enabled In Preview.")
+    print(f"resize_mode = {resize_mode}")
+    print(f"raw_H = {raw_H}")
+    print(f"raw_W = {raw_W}")
+    print(f"target_H = {target_H}")
+    print(f"target_W = {target_W}")
+    print(f"estimation = {estimation}")
+
+    return int(np.round(estimation))
 
 
 InputImage = Union[np.ndarray, str]

tests/external_code_api/external_code_test.py

@@ -116,5 +116,23 @@ def test_masked_image_dict(self):
         self.assert_dict_is_valid()
 
 
+class TestPixelPerfectResolution(unittest.TestCase):
+    def test_outer_fit(self):
+        image = np.zeros((100, 100, 3))
+        target_H, target_W = 50, 100
+        resize_mode = external_code.ResizeMode.OUTER_FIT
+        result = external_code.pixel_perfect_resolution(image, target_H, target_W, resize_mode)
+        expected = 50  # manually computed expected result
+        self.assertEqual(result, expected)
+
+    def test_inner_fit(self):
+        image = np.zeros((100, 100, 3))
+        target_H, target_W = 50, 100
+        resize_mode = external_code.ResizeMode.INNER_FIT
+        result = external_code.pixel_perfect_resolution(image, target_H, target_W, resize_mode)
+        expected = 100  # manually computed expected result
+        self.assertEqual(result, expected)
+
+
 if __name__ == '__main__':
     unittest.main()