fix zoom shoulder

app/util/passport_photo_engine/passport_cropper.py

@@ -20,51 +20,57 @@ class PassportCropper:
         
         # Blend
         return (bgr.astype(float) * alpha + bg.astype(float) * (1.0 - alpha)).astype(np.uint8)
-
-    def crop_with_dynamic_zoom(self, img_bgr, angle_deg, raw_face_box, head_percent=0.75):
+    
+    def crop_with_dynamic_zoom(self, img_bgr, angle_deg, raw_face_box, top_margin=0.6, bottom_margin=1.3):
         """
-        REPLACES 'rotate_and_expand_face' AND 'crop_to_ratio'.
+        Calculates the crop based on padding the face box.
         
-        This function guarantees the face height is exactly 'head_percent' (75%)
-        of the final image height, performing rotation and padding in one step.
+        top_margin=0.6: Space for hair and top gap.
+        bottom_margin=1.3: Space for neck and chest/shoulders.
         """
         h0, w0 = img_bgr.shape[:2]
         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
+        # 1. Determine the Height of the Crop First
+        # We use the face height (fh) as the unit of measurement.
+        # Top padding = 0.6 * face height
+        # Bottom padding = 1.3 * face height (Includes chest)
+        # Face itself = 1.0
+        # Total Height = 0.6 + 1.0 + 1.3 = 2.9 units
+        
+        needed_top_pad = int(fh * top_margin)
+        needed_bottom_pad = int(fh * bottom_margin)
         
-        # 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)
+        # This is the total height of our final image in the original scale
+        required_crop_h = needed_top_pad + fh + needed_bottom_pad
         
-        # 3. Calculate Width based on the Aspect Ratio of the output (e.g. 3.5cm / 4.5cm)
+        # 2. Calculate Width based on Aspect Ratio
+        # We force the width to match the target aspect (e.g., 3.5/4.5)
+        # to ensure no distortion.
         required_crop_w = int(required_crop_h * self.target_aspect)
 
-        # 4. Find the center of the face
+        # 3. Find Center Points
         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
+        # 4. Determine Crop Center
+        # The crop shouldn't be centered exactly on the face center.
+        # It needs to be lower, because we added more padding to the bottom (chest) than the top.
+        # Center_Y = Face_Top - Top_Pad + (Total_Height / 2)
+        
+        crop_top_y = fy - needed_top_pad
+        center_y = crop_top_y + (required_crop_h / 2.0)
+        center_x = float(face_center_x) # Center horizontally on face
 
-        # 6. Create the Rotation Matrix
-        # We rotate around the calculated center
-        M = cv2.getRotationMatrix2D((float(center_x), float(center_y)), -angle_deg, 1.0)
+        # 5. Create Rotation Matrix
+        center_tuple = (float(center_x), float(center_y))
+        M = cv2.getRotationMatrix2D(center_tuple, -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
+        # 6. Translation (Move crop to origin)
+        M[0, 2] += (required_crop_w / 2.0) - center_x
+        M[1, 2] += (required_crop_h / 2.0) - center_y
         
-        # 8. Generate the Final Image
-        # cv2.warpAffine does the rotation, cropping, and background padding all at once.
+        # 7. Warp (Rotate + Crop + Pad)
         result = cv2.warpAffine(
             img_bgr, 
             M, 
@@ -73,5 +79,5 @@ class PassportCropper:
             flags=cv2.INTER_LINEAR
         )
         
-        # 9. Resize to the final output pixels (e.g. 413x531)
+        # 8. Final Resize
         return cv2.resize(result, (self.out_w, self.out_h), interpolation=cv2.INTER_AREA)

server.py

@@ -272,7 +272,8 @@ def create_app() -> Flask:
                 img_clean, 
                 angle, 
                 (x, y, w, h), 
-                head_percent=0.75
+                top_margin=0.6, 
+                bottom_margin=1.3
             )
             # Return result
             is_success, buffer = cv2.imencode(".jpg", final_passport)