fix: not enough zoom

app/util/passport_photo_engine/passport_cropper.py

@@ -2,56 +2,76 @@ import cv2
 import numpy as np
 
 class PassportCropper:
-    def __init__(self, output_size=(600,800), bg_color=(255,255,255)):
+    def __init__(self, output_size=(413, 531), bg_color=(255, 255, 255)):
+        # Default size: 3.5cm x 4.5cm @ 300 DPI
         self.out_w, self.out_h = output_size
         self.bg_color = tuple(int(x) for x in bg_color)
         self.target_aspect = self.out_w / self.out_h
 
     def composite(self, img_rgb, mask):
+        """Standard background removal composite"""
         bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+        if mask is None: return bgr
+        
+        # Blur mask slightly for better blending
         m = cv2.GaussianBlur(mask, (5,5), 0)
         alpha = (m.astype(float) / 255.0)[:,:,None]
         bg = np.full_like(bgr, np.array(self.bg_color, dtype=np.uint8))
+        
+        # Blend
         return (bgr.astype(float) * alpha + bg.astype(float) * (1.0 - alpha)).astype(np.uint8)
 
-    def rotate_and_expand_face(self, img_bgr, angle_deg, raw_face_box):
+    def crop_with_dynamic_zoom(self, img_bgr, angle_deg, raw_face_box, head_percent=0.75):
+        """
+        REPLACES 'rotate_and_expand_face' AND 'crop_to_ratio'.
+        
+        This function guarantees the face height is exactly 'head_percent' (75%)
+        of the final image height, performing rotation and padding in one step.
+        """
         h0, w0 = img_bgr.shape[:2]
-        x1, y1, x2, y2 = raw_face_box
-        # Expansion Logic: 0.4 sides, 0.6 top, 1.2 bottom
-        fw, fh = x2-x1, y2-y1
-        hx1, hy1 = max(0, x1-int(fw*0.4)), max(0, y1-int(fh*0.6))
-        hx2, hy2 = min(w0-1, x2+int(fw*0.4)), min(h0-1, y2+int(fh*1.2))
-        
-        # Rotation
-        M = cv2.getRotationMatrix2D((w0/2, h0/2), -angle_deg, 1.0)
-        cos, sin = np.abs(M[0,0]), np.abs(M[0,1])
-        nW, nH = int((h0*sin)+(w0*cos)), int((h0*cos)+(w0*sin))
-        M[0,2] += (nW/2) - w0/2; M[1,2] += (nH/2) - h0/2
-        
-        rot_img = cv2.warpAffine(img_bgr, M, (nW, nH), borderValue=self.bg_color)
-        
-        # Rotate Box Points
-        pts = np.array([[hx1,hy1,1],[hx2,hy1,1],[hx2,hy2,1],[hx1,hy2,1]]).T
-        rot_pts = M @ pts
-        rx, ry = rot_pts[0,:], rot_pts[1,:]
-        return rot_img, (int(rx.min()), int(ry.min()), int(rx.max()), int(ry.max()))
+        fx, fy, fw, fh = raw_face_box
+
+        # 1. Estimate Real Head Height (Chin to Top of Hair)
+        # Haar usually detects eyebrows to chin. We multiply by 1.35 to get full head.
+        estimated_head_h = fh * 1.35
+        
+        # 2. Calculate the Required Canvas Height based on the 75% rule
+        # If head needs to be 75%, then Canvas = Head / 0.75
+        required_crop_h = int(estimated_head_h / head_percent)
+        
+        # 3. Calculate Width based on the Aspect Ratio of the output (e.g. 3.5cm / 4.5cm)
+        required_crop_w = int(required_crop_h * self.target_aspect)
 
-    def crop_to_ratio(self, img, box):
-        bx1, by1, bx2, by2 = box
-        bw, bh = bx2-bx1, by2-by1
-        if bw/bh > self.target_aspect: # Too wide
-            new_h = int(bw/self.target_aspect)
-            by1 -= (new_h - bh)//2; by2 = by1 + new_h
-        else: # Too tall
-            new_w = int(bh*self.target_aspect)
-            bx1 -= (new_w - bw)//2; bx2 = bx1 + new_w
-        
-        # Canvas Crop
-        H, W = img.shape[:2]
-        canvas = np.full((by2-by1, bx2-bx1, 3), self.bg_color, dtype=np.uint8)
-        sx1, sy1 = max(0, bx1), max(0, by1)
-        sx2, sy2 = min(W, bx2), min(H, by2)
-        dx1, dy1 = max(0, sx1-bx1), max(0, sy1-by1)
-        if sx2>sx1 and sy2>sy1: canvas[dy1:dy1+(sy2-sy1), dx1:dx1+(sx2-sx1)] = img[sy1:sy2, sx1:sx2]
-        return cv2.resize(canvas, (self.out_w, self.out_h), interpolation=cv2.INTER_AREA)
+        # 4. Find the center of the face
+        face_center_x = fx + fw // 2
+        face_center_y = fy + fh // 2
+        
+        # 5. Determine the center of the Crop
+        # Eyes are usually at 45-50% from the top, not dead center.
+        # We shift the crop box UP slightly so the face sits nicely.
+        shift_y = int(required_crop_h * 0.05) 
+        center_x = face_center_x
+        center_y = face_center_y - shift_y
 
+        # 6. Create the Rotation Matrix
+        # We rotate around the calculated center
+        M = cv2.getRotationMatrix2D((center_x, center_y), -angle_deg, 1.0)
+        
+        # 7. Modify the Matrix for Translation
+        # This is the math magic: We tell OpenCV to move the (center_x, center_y) 
+        # to the center of our new (required_crop_w, required_crop_h) image.
+        M[0, 2] += (required_crop_w / 2) - center_x
+        M[1, 2] += (required_crop_h / 2) - center_y
+        
+        # 8. Generate the Final Image
+        # cv2.warpAffine does the rotation, cropping, and background padding all at once.
+        result = cv2.warpAffine(
+            img_bgr, 
+            M, 
+            (required_crop_w, required_crop_h), 
+            borderValue=self.bg_color,
+            flags=cv2.INTER_LINEAR
+        )
+        
+        # 9. Resize to the final output pixels (e.g. 413x531)
+        return cv2.resize(result, (self.out_w, self.out_h), interpolation=cv2.INTER_AREA)

server.py

@@ -268,9 +268,12 @@ def create_app() -> Flask:
             cropper = PassportCropper(output_size=output_size, bg_color=selected_bg)
             
             img_clean = cropper.composite(img_rgb, mask)
-            img_rot, rot_box = cropper.rotate_and_expand_face(img_clean, angle, (x,y,x+w,y+h))
-            final_passport = cropper.crop_to_ratio(img_rot, rot_box)
-
+            final_passport = cropper.crop_with_dynamic_zoom(
+                img_clean, 
+                angle, 
+                (x, y, w, h), 
+                head_percent=0.75
+            )
             # Return result
             is_success, buffer = cv2.imencode(".jpg", final_passport)
             return send_file(io.BytesIO(buffer), mimetype='image/jpeg')