Update scalingtestupdated.py

scalingtestupdated.py

@@ -271,7 +271,80 @@ def calculate_paper_scaling_factor(
     print(f"Final scaling factor: {scaling_factor:.6f} {unit_string}")
     
     return scaling_factor, unit_string
-
+    
+def calculate_paper_scaling_factor_corrected(
+    paper_contour: np.ndarray, 
+    paper_size: str, 
+    output_unit: str = "mm",
+    correction_factor: float = 0.79,
+    method: str = "average"
+) -> Tuple[float, str]:
+    """
+    Calculate scaling factor with configurable correction and method.
+    
+    :param paper_contour: Detected paper contour
+    :param paper_size: Paper size identifier ("A4", "A3", "US Letter")
+    :param output_unit: Desired unit for scaling factor ("mm" or "inches")
+    :param correction_factor: Empirical correction factor (default 0.79)
+    :param method: Calculation method ("min", "max", "average", "auto")
+    :return: Tuple of (scaling_factor, unit_string)
+    """
+    # Get paper dimensions in the desired unit
+    if output_unit == "inches":
+        expected_width = PAPER_SIZES[paper_size]["width_inches"]
+        expected_height = PAPER_SIZES[paper_size]["height_inches"]
+        unit_string = "inches per pixel"
+    else:
+        expected_width = PAPER_SIZES[paper_size]["width_mm"]
+        expected_height = PAPER_SIZES[paper_size]["height_mm"]
+        unit_string = "mm per pixel"
+    
+    # Calculate bounding rectangle of paper contour
+    rect = cv2.boundingRect(paper_contour)
+    detected_width_px = rect[2]
+    detected_height_px = rect[3]
+    
+    # Calculate scaling factors for both dimensions
+    scale_x = expected_width / detected_width_px
+    scale_y = expected_height / detected_height_px
+    
+    # Choose scaling method
+    if method == "min":
+        base_scaling_factor = min(scale_x, scale_y)
+    elif method == "max":
+        base_scaling_factor = max(scale_x, scale_y)
+    elif method == "average":
+        base_scaling_factor = (scale_x + scale_y) / 2
+    elif method == "auto":
+        # Auto-select based on aspect ratio similarity
+        detected_aspect = detected_width_px / detected_height_px
+        expected_aspect = expected_width / expected_height
+        
+        # If aspect ratios are similar, use average; otherwise use method that matches better
+        aspect_diff = abs(detected_aspect - expected_aspect)
+        aspect_diff_inv = abs(detected_aspect - (1/expected_aspect))
+        
+        if aspect_diff < aspect_diff_inv:
+            base_scaling_factor = (scale_x + scale_y) / 2  # Same orientation
+        else:
+            # Different orientation - swap and recalculate
+            scale_x_swap = expected_height / detected_width_px
+            scale_y_swap = expected_width / detected_height_px
+            base_scaling_factor = (scale_x_swap + scale_y_swap) / 2
+    else:
+        raise ValueError(f"Unknown method: {method}")
+    
+    # Apply correction factor
+    scaling_factor = base_scaling_factor * correction_factor
+    
+    print(f"Paper detection: {detected_width_px}x{detected_height_px} px")
+    print(f"Expected paper size: {expected_width}x{expected_height} {output_unit}")
+    print(f"Scale X: {scale_x:.6f}, Scale Y: {scale_y:.6f}")
+    print(f"Method: {method}, Base scaling: {base_scaling_factor:.6f}")
+    print(f"Correction factor: {correction_factor}")
+    print(f"Final scaling factor: {scaling_factor:.6f} {unit_string}")
+    
+    return scaling_factor, unit_string
 
 # Example usage:
 if __name__ == "__main__":