natural-pdf 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

natural_pdf/ocr/engine_doctr.py

@@ -0,0 +1,346 @@
+# natural_pdf/ocr/engine_doctr.py
+import importlib.util
+import logging
+from typing import Any, List, Optional
+
+import numpy as np
+from PIL import Image
+
+from .engine import OCREngine, TextRegion
+from .ocr_options import BaseOCROptions, DoctrOCROptions
+
+logger = logging.getLogger(__name__)
+
+
+class DoctrOCREngine(OCREngine):
+    """docTR engine implementation."""
+
+    def __init__(self):
+        super().__init__()
+        self._model = None  # Will hold the doctr ocr_predictor
+        self._detection_model = None  # Will hold detection_predictor if detect_only is used
+        self._orientation_model = None  # Will hold page_orientation_predictor if enabled
+
+    def is_available(self) -> bool:
+        """Check if doctr is installed."""
+        return importlib.util.find_spec("doctr") is not None
+
+    def _initialize_model(
+        self, languages: List[str], device: str, options: Optional[BaseOCROptions]
+    ):
+        """Initialize the doctr model."""
+        if not self.is_available():
+            raise ImportError(
+                "Doctr engine requires the 'python-doctr' package. "
+                "Install with: pip install python-doctr[torch] or python-doctr[tf]"
+            )
+
+        try:
+            import doctr.models
+
+            self.logger.info("doctr.models imported successfully.")
+        except ImportError as e:
+            self.logger.error(f"Failed to import doctr: {e}")
+            raise
+
+        # Cast to DoctrOCROptions or use default
+        doctr_opts = options if isinstance(options, DoctrOCROptions) else DoctrOCROptions()
+
+        # Check if CUDA is available in device string
+        use_cuda = device.lower().startswith("cuda") if device else False
+
+        # Prepare OCR predictor arguments
+        predictor_args = {
+            "det_arch": doctr_opts.det_arch,
+            "reco_arch": doctr_opts.reco_arch,
+            "pretrained": doctr_opts.pretrained,
+            "assume_straight_pages": doctr_opts.assume_straight_pages,
+            "export_as_straight_boxes": doctr_opts.export_as_straight_boxes,
+        }
+        # Filter out None values
+        predictor_args = {k: v for k, v in predictor_args.items() if v is not None}
+
+        self.logger.debug(f"doctr ocr_predictor constructor args: {predictor_args}")
+        try:
+            # Create the main OCR predictor (doesn't accept batch_size)
+            self._model = doctr.models.ocr_predictor(**predictor_args)
+
+            # Apply CUDA if available
+            if use_cuda:
+                self._model = self._model.cuda()
+
+            self.logger.info("doctr ocr_predictor created successfully")
+
+            # Now initialize the detection-only model
+            try:
+                detection_args = {
+                    "arch": doctr_opts.det_arch,
+                    "pretrained": doctr_opts.pretrained,
+                    "assume_straight_pages": doctr_opts.assume_straight_pages,
+                    "symmetric_pad": doctr_opts.symmetric_pad,
+                    "preserve_aspect_ratio": doctr_opts.preserve_aspect_ratio,
+                    "batch_size": doctr_opts.batch_size,
+                }
+                self._detection_model = doctr.models.detection_predictor(**detection_args)
+
+                # Apply CUDA if available
+                if use_cuda:
+                    self._detection_model = self._detection_model.cuda()
+
+                # Configure postprocessing parameters if provided
+                if doctr_opts.bin_thresh is not None:
+                    self._detection_model.model.postprocessor.bin_thresh = doctr_opts.bin_thresh
+                if doctr_opts.box_thresh is not None:
+                    self._detection_model.model.postprocessor.box_thresh = doctr_opts.box_thresh
+
+                self.logger.info("doctr detection_predictor created successfully")
+            except Exception as e:
+                self.logger.error(f"Failed to create detection_predictor: {e}")
+                self._detection_model = None
+
+            # Initialize orientation predictor if enabled
+            if doctr_opts.use_orientation_predictor:
+                try:
+                    self._orientation_model = doctr.models.page_orientation_predictor(
+                        pretrained=True, batch_size=doctr_opts.batch_size
+                    )
+                    if use_cuda:
+                        self._orientation_model = self._orientation_model.cuda()
+                    self.logger.info("doctr page_orientation_predictor created successfully")
+                except Exception as e:
+                    self.logger.error(f"Failed to create page_orientation_predictor: {e}")
+                    self._orientation_model = None
+
+        except Exception as e:
+            self.logger.error(f"Failed to create doctr models: {e}")
+            raise
+
+        # Doctr doesn't explicitly use language list in ocr_predictor initialization
+        if languages and languages != [self.DEFAULT_LANGUAGES[0]]:
+            logger.warning(
+                f"Doctr engine currently doesn't support language selection during initialization. Using its default language capabilities for model: {doctr_opts.reco_arch}"
+            )
+
+    def _preprocess_image(self, image: Image.Image) -> np.ndarray:
+        """Convert PIL Image to RGB numpy array for doctr."""
+        # Ensure the image is in RGB mode
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        # Convert to numpy array
+        return np.array(image)
+
+    def _process_single_image(
+        self, image: np.ndarray, detect_only: bool, options: Optional[DoctrOCROptions]
+    ) -> Any:
+        """Process a single image with doctr."""
+        if self._model is None:
+            raise RuntimeError("Doctr model not initialized")
+
+        # Capture image dimensions for denormalization
+        height, width = image.shape[:2]
+
+        # Cast options to DoctrOCROptions or use default
+        doctr_opts = options if isinstance(options, DoctrOCROptions) else DoctrOCROptions()
+
+        # Check if we need to detect orientation first
+        if self._orientation_model is not None and options and options.use_orientation_predictor:
+            try:
+                # Process with orientation predictor
+                # For orientation predictor, we need to pass a batch of images
+                orientations = self._orientation_model([image])
+                orientation = orientations[1][0]  # Get the orientation angle
+                logger.info(f"Detected page orientation: {orientation} degrees")
+                # Note: doctr handles rotation internally for detection/recognition
+            except Exception as e:
+                logger.error(f"Error detecting orientation: {e}")
+
+        # Process differently based on detect_only flag
+        if detect_only and self._detection_model is not None:
+            try:
+                # Apply threshold settings at runtime for this detection
+                if doctr_opts.bin_thresh is not None:
+                    original_bin_thresh = self._detection_model.model.postprocessor.bin_thresh
+                    self._detection_model.model.postprocessor.bin_thresh = doctr_opts.bin_thresh
+                    logger.debug(f"Temporarily set bin_thresh to {doctr_opts.bin_thresh}")
+
+                if doctr_opts.box_thresh is not None:
+                    original_box_thresh = self._detection_model.model.postprocessor.box_thresh
+                    self._detection_model.model.postprocessor.box_thresh = doctr_opts.box_thresh
+                    logger.debug(f"Temporarily set box_thresh to {doctr_opts.box_thresh}")
+
+                # Use the dedicated detection model with a list of numpy arrays
+                result = self._detection_model([image])
+
+                # Restore original thresholds
+                if doctr_opts.bin_thresh is not None:
+                    self._detection_model.model.postprocessor.bin_thresh = original_bin_thresh
+
+                if doctr_opts.box_thresh is not None:
+                    self._detection_model.model.postprocessor.box_thresh = original_box_thresh
+
+                # Return tuple of (result, dimensions)
+                return (result, (height, width))
+            except Exception as e:
+                logger.error(f"Error in detection_predictor: {e}")
+                # Fall back to OCR predictor if detection fails
+                logger.warning("Falling back to OCR predictor for detection")
+
+        # Process with full OCR model, passing a list of numpy arrays directly
+        try:
+            # For full OCR, we should also apply the thresholds
+            if (
+                detect_only
+                and doctr_opts.bin_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "bin_thresh")
+            ):
+                original_bin_thresh = self._model.det_predictor.model.postprocessor.bin_thresh
+                self._model.det_predictor.model.postprocessor.bin_thresh = doctr_opts.bin_thresh
+
+            if (
+                detect_only
+                and doctr_opts.box_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "box_thresh")
+            ):
+                original_box_thresh = self._model.det_predictor.model.postprocessor.box_thresh
+                self._model.det_predictor.model.postprocessor.box_thresh = doctr_opts.box_thresh
+
+            result = self._model([image])
+
+            # Restore original thresholds
+            if (
+                detect_only
+                and doctr_opts.bin_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "bin_thresh")
+            ):
+                self._model.det_predictor.model.postprocessor.bin_thresh = original_bin_thresh
+
+            if (
+                detect_only
+                and doctr_opts.box_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "box_thresh")
+            ):
+                self._model.det_predictor.model.postprocessor.box_thresh = original_box_thresh
+
+            # Return tuple of (result, dimensions)
+            return (result, (height, width))
+        except Exception as e:
+            logger.error(f"Error in OCR prediction: {e}")
+            raise
+
+    def _standardize_results(
+        self, raw_results: Any, min_confidence: float, detect_only: bool
+    ) -> List[TextRegion]:
+        """Convert doctr results to standardized TextRegion objects."""
+        standardized_regions = []
+
+        # Extract results and dimensions
+        if isinstance(raw_results, tuple) and len(raw_results) == 2:
+            results, dimensions = raw_results
+            image_height, image_width = dimensions
+        else:
+            # Fallback if dimensions aren't provided
+            results = raw_results
+            image_width = 1
+            image_height = 1
+            logger.warning("Image dimensions not provided, using normalized coordinates")
+
+        # Handle detection-only results differently
+        if detect_only and self._detection_model is not None and not hasattr(results, "pages"):
+            # Import doctr utils for detach_scores if needed
+            try:
+                from doctr.utils.geometry import detach_scores
+            except ImportError:
+                logger.error("Failed to import doctr.utils.geometry.detach_scores")
+                return standardized_regions
+
+            # Extract coordinates and scores from detection results
+            for result in results:
+                # Detection results structure is different from ocr_predictor
+                if "words" in result:
+                    try:
+                        # Detach the coordinates and scores
+                        detached_coords, prob_scores = detach_scores([result.get("words")])
+
+                        for i, coords in enumerate(detached_coords[0]):
+                            score = (
+                                prob_scores[0][i]
+                                if prob_scores and len(prob_scores[0]) > i
+                                else 0.0
+                            )
+
+                            if score >= min_confidence:
+                                try:
+                                    # Handle both straight and rotated boxes
+                                    if coords.shape == (
+                                        4,
+                                    ):  # Straight box as [xmin, ymin, xmax, ymax]
+                                        xmin, ymin, xmax, ymax = coords.tolist()
+                                        # Denormalize coordinates
+                                        bbox = (
+                                            float(xmin * image_width),
+                                            float(ymin * image_height),
+                                            float(xmax * image_width),
+                                            float(ymax * image_height),
+                                        )
+                                    else:  # Polygon points
+                                        # Get bounding box from polygon
+                                        coords_list = coords.tolist()
+                                        x_coords = [p[0] * image_width for p in coords_list]
+                                        y_coords = [p[1] * image_height for p in coords_list]
+                                        bbox = (
+                                            float(min(x_coords)),
+                                            float(min(y_coords)),
+                                            float(max(x_coords)),
+                                            float(max(y_coords)),
+                                        )
+
+                                    # In detection mode, we don't have text or confidence score
+                                    standardized_regions.append(TextRegion(bbox, None, score))
+                                except Exception as e:
+                                    logger.error(f"Error processing detection result: {e}")
+                    except Exception as e:
+                        logger.error(f"Error detaching scores: {e}")
+
+            return standardized_regions
+
+        # Process standard OCR results
+        if not hasattr(results, "pages") or not results.pages:
+            logger.warning("Doctr result object does not contain pages.")
+            return standardized_regions
+
+        # Process results page by page (we typically process one image at a time)
+        for page in results.pages:
+            # Extract information from blocks, lines, words
+            for block in page.blocks:
+                for line in block.lines:
+                    for word in line.words:
+                        if word.confidence >= min_confidence:
+                            try:
+                                # doctr geometry is ((x_min, y_min), (x_max, y_max)) as relative coordinates
+                                x_min, y_min = word.geometry[0]
+                                x_max, y_max = word.geometry[1]
+
+                                # Denormalize coordinates to absolute pixel values
+                                bbox = (
+                                    float(x_min * image_width),
+                                    float(y_min * image_height),
+                                    float(x_max * image_width),
+                                    float(y_max * image_height),
+                                )
+
+                                # Skip text content if detect_only is True
+                                text = None if detect_only else word.value
+                                confidence = None if detect_only else word.confidence
+
+                                standardized_regions.append(TextRegion(bbox, text, confidence))
+                            except (ValueError, TypeError, IndexError) as e:
+                                logger.error(
+                                    f"Could not standardize bounding box/word from doctr result: {word}"
+                                )
+                                logger.error(f"Error: {e}")
+
+        return standardized_regions
+
+    def get_default_options(self) -> DoctrOCROptions:
+        """Return the default options specific to this engine."""
+        return DoctrOCROptions()

natural_pdf/ocr/engine_easyocr.py

@@ -143,11 +143,13 @@ class EasyOCREngine(OCREngine):
         standardized_regions = []
 
         if detect_only:
+            results = raw_results[0]
             # In detect_only mode, raw_results is already a list of bounding boxes
             # Each bbox is in [x_min, x_max, y_min, y_max] format
-            if isinstance(raw_results, list):
-                for detection in raw_results:
+            if isinstance(results, list):
+                for detection in results:
                     try:
+                        # This block expects 'detection' to be a list/tuple of 4 numbers
                         if isinstance(detection, (list, tuple)) and len(detection) == 4:
                             x_min, x_max, y_min, y_max = detection
                             # Convert to standardized (x0, y0, x1, y1) format
@@ -161,6 +163,7 @@ class EasyOCREngine(OCREngine):
                                     f"Invalid number format in EasyOCR detect bbox: {detection}"
                                 ) from e
                         else:
+                            # This is where the error is raised if 'detection' is not a list/tuple of 4 numbers
                             raise ValueError(f"Invalid detection format from EasyOCR: {detection}")
                     except ValueError as e:
                         # Re-raise any value errors from standardization or format checks
@@ -172,7 +175,7 @@ class EasyOCREngine(OCREngine):
                         ) from e
             else:
                 raise ValueError(
-                    f"Expected list of bounding boxes in detect_only mode, got: {raw_results}"
+                    f"Expected list of bounding boxes in detect_only mode, got: {type(raw_results)}"
                 )
 
             return standardized_regions

natural_pdf/ocr/ocr_factory.py

@@ -1,6 +1,6 @@
-import logging
 import importlib.util
-from typing import Dict, Any, Optional, Type, Union, List
+import logging
+from typing import Any, Dict, List, Optional, Type, Union
 
 from .engine import OCREngine
 
@@ -15,7 +15,7 @@ class OCRFactory:
         """Create and return an OCR engine instance.
 
         Args:
-            engine_type: One of 'surya', 'easyocr', 'paddle'
+            engine_type: One of 'surya', 'easyocr', 'paddle', 'doctr'
             **kwargs: Arguments to pass to the engine constructor
 
         Returns:
@@ -54,6 +54,16 @@ class OCRFactory:
                     "PaddleOCR engine requires 'paddleocr' and 'paddlepaddle'. "
                     "Install with: pip install paddleocr paddlepaddle"
                 )
+        elif engine_type == "doctr":
+            try:
+                from .engine_doctr import DoctrOCREngine
+
+                return DoctrOCREngine(**kwargs)
+            except ImportError:
+                raise ImportError(
+                    "Doctr engine requires the 'python-doctr' package. "
+                    "Install with: pip install python-doctr[torch] or python-doctr[tf]"
+                )
         else:
             raise ValueError(f"Unknown engine type: {engine_type}")
 
@@ -85,13 +95,19 @@ class OCRFactory:
         except ImportError:
             engines["paddle"] = False
 
+        # Check Doctr
+        try:
+            engines["doctr"] = importlib.util.find_spec("doctr") is not None
+        except ImportError:
+            engines["doctr"] = False
+
         return engines
 
     @staticmethod
     def get_recommended_engine(**kwargs) -> OCREngine:
         """Returns the best available OCR engine based on what's installed.
 
-        First tries engines in order of preference: EasyOCR, Paddle, Surya.
+        First tries engines in order of preference: EasyOCR, Doctr, Paddle, Surya.
         If none are available, raises ImportError with installation instructions.
 
         Args:
@@ -109,6 +125,9 @@ class OCRFactory:
         if available.get("easyocr", False):
             logger.info("Using EasyOCR engine (recommended)")
             return OCRFactory.create_engine("easyocr", **kwargs)
+        elif available.get("doctr", False):
+            logger.info("Using Doctr engine")
+            return OCRFactory.create_engine("doctr", **kwargs)
         elif available.get("paddle", False):
             logger.info("Using PaddleOCR engine")
             return OCRFactory.create_engine("paddle", **kwargs)
@@ -120,6 +139,7 @@ class OCRFactory:
         raise ImportError(
             "No OCR engines available. Please install at least one of: \n"
             "- EasyOCR (recommended): pip install easyocr\n"
+            "- Doctr: pip install python-doctr[torch] or python-doctr[tf]\n"
             "- PaddleOCR: pip install paddleocr paddlepaddle\n"
             "- Surya OCR: pip install surya"
         )

natural_pdf/ocr/ocr_manager.py

@@ -1,17 +1,26 @@
 # ocr_manager.py
 import copy  # For deep copying options
 import logging
+import threading  # Import threading for lock
+import time  # Import time for timing
 from typing import Any, Dict, List, Optional, Type, Union
 
 from PIL import Image
 
 # Import engine classes and options
 from .engine import OCREngine
+from .engine_doctr import DoctrOCREngine
 from .engine_easyocr import EasyOCREngine
 from .engine_paddle import PaddleOCREngine
 from .engine_surya import SuryaOCREngine
-from .ocr_options import OCROptions
-from .ocr_options import BaseOCROptions, EasyOCROptions, PaddleOCROptions, SuryaOCROptions
+from .ocr_options import (
+    BaseOCROptions,
+    DoctrOCROptions,
+    EasyOCROptions,
+    OCROptions,
+    PaddleOCROptions,
+    SuryaOCROptions,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -23,37 +32,88 @@ class OCRManager:
     ENGINE_REGISTRY: Dict[str, Dict[str, Any]] = {
         "easyocr": {"class": EasyOCREngine, "options_class": EasyOCROptions},
         "paddle": {"class": PaddleOCREngine, "options_class": PaddleOCROptions},
-        "surya": {"class": SuryaOCREngine, "options_class": SuryaOCROptions},  # <-- Add Surya
+        "surya": {"class": SuryaOCREngine, "options_class": SuryaOCROptions},
+        "doctr": {"class": DoctrOCREngine, "options_class": DoctrOCROptions},
         # Add other engines here
     }
 
     def __init__(self):
         """Initializes the OCR Manager."""
         self._engine_instances: Dict[str, OCREngine] = {}  # Cache for engine instances
+        self._engine_locks: Dict[str, threading.Lock] = (
+            {}
+        )  # Lock per engine type for initialization
+        self._engine_inference_locks: Dict[str, threading.Lock] = (
+            {}
+        )  # Lock per engine type for inference
         logger.info("OCRManager initialized.")
 
     def _get_engine_instance(self, engine_name: str) -> OCREngine:
-        """Retrieves or creates an instance of the specified OCR engine."""
+        """Retrieves or creates an instance of the specified OCR engine, ensuring thread-safe initialization."""
         engine_name = engine_name.lower()
         if engine_name not in self.ENGINE_REGISTRY:
             raise ValueError(
                 f"Unknown OCR engine: '{engine_name}'. Available: {list(self.ENGINE_REGISTRY.keys())}"
             )
 
-        if engine_name not in self._engine_instances:
-            logger.info(f"Creating instance of engine: {engine_name}")
+        # Quick check if instance already exists (avoid lock contention)
+        if engine_name in self._engine_instances:
+            return self._engine_instances[engine_name]
+
+        # Get or create the lock for this engine type
+        if engine_name not in self._engine_locks:
+            self._engine_locks[engine_name] = threading.Lock()
+
+        engine_init_lock = self._engine_locks[engine_name]
+
+        # Acquire lock to safely check and potentially initialize the engine
+        with engine_init_lock:
+            # Double-check if another thread initialized it while we waited for the lock
+            if engine_name in self._engine_instances:
+                return self._engine_instances[engine_name]
+
+            # If still not initialized, create it now under the lock
+            logger.info(
+                f"[{threading.current_thread().name}] Creating shared instance of engine: {engine_name}"
+            )
             engine_class = self.ENGINE_REGISTRY[engine_name]["class"]
-            engine_instance = engine_class()  # Instantiate first
-            if not engine_instance.is_available():
-                # Check availability before storing
-                # Construct helpful error message with install hint
-                install_hint = f"pip install 'natural-pdf[{engine_name}]'"
-                raise RuntimeError(
-                    f"Engine '{engine_name}' is not available. Please install the required dependencies: {install_hint}"
+            start_time = time.monotonic()  # Optional: time initialization
+            try:
+                engine_instance = engine_class()  # Instantiate first
+                if not engine_instance.is_available():
+                    # Check availability before storing
+                    install_hint = f"pip install 'natural-pdf[{engine_name}]'"
+                    raise RuntimeError(
+                        f"Engine '{engine_name}' is not available. Please install the required dependencies: {install_hint}"
+                    )
+                # Store the shared instance
+                self._engine_instances[engine_name] = engine_instance
+                end_time = time.monotonic()
+                logger.info(
+                    f"[{threading.current_thread().name}] Shared instance of {engine_name} created successfully (Duration: {end_time - start_time:.2f}s)."
                 )
-            self._engine_instances[engine_name] = engine_instance  # Store if available
+                return engine_instance
+            except Exception as e:
+                # Ensure we don't leave a partial state if init fails
+                logger.error(
+                    f"[{threading.current_thread().name}] Failed to create shared instance of {engine_name}: {e}",
+                    exc_info=True,
+                )
+                # Remove potentially partial entry if exists
+                if engine_name in self._engine_instances:
+                    del self._engine_instances[engine_name]
+                raise  # Re-raise the exception after logging
 
-        return self._engine_instances[engine_name]
+    def _get_engine_inference_lock(self, engine_name: str) -> threading.Lock:
+        """Gets or creates the inference lock for a given engine type."""
+        engine_name = engine_name.lower()
+        # Assume engine_name is valid as it's checked before this would be called
+        if engine_name not in self._engine_inference_locks:
+            # Create lock if it doesn't exist (basic thread safety for dict access)
+            # A more robust approach might lock around this check/creation too,
+            # but contention here is less critical than for engine init or inference itself.
+            self._engine_inference_locks[engine_name] = threading.Lock()
+        return self._engine_inference_locks[engine_name]
 
     def apply_ocr(
         self,
@@ -72,7 +132,7 @@ class OCRManager:
 
         Args:
             images: A single PIL Image or a list of PIL Images to process.
-            engine: Name of the engine (e.g., 'easyocr', 'paddle', 'surya').
+            engine: Name of the engine (e.g., 'easyocr', 'paddle', 'surya', 'doctr').
                     Defaults to 'easyocr' if not specified.
             languages: List of language codes (e.g., ['en', 'fr'], ['en', 'german']).
                        **Passed directly to the engine.** Must be codes understood
@@ -127,21 +187,57 @@ class OCRManager:
         try:
             engine_instance = self._get_engine_instance(selected_engine_name)
             processing_mode = "batch" if is_batch else "single image"
-            logger.info(f"Processing {processing_mode} with engine '{selected_engine_name}'...")
+            # Log thread name for clarity during parallel calls
+            thread_id = threading.current_thread().name
+            logger.info(
+                f"[{thread_id}] Processing {processing_mode} using shared engine instance '{selected_engine_name}'..."
+            )
             logger.debug(
                 f"  Engine Args: languages={languages}, min_confidence={min_confidence}, device={device}, options={final_options}"
             )
 
-            # Call the engine's process_image, passing common args and options object
-            # **ASSUMPTION**: Engine process_image signatures are updated to accept these common args.
-            results = engine_instance.process_image(
-                images=images,
-                languages=languages,
-                min_confidence=min_confidence,
-                device=device,
-                detect_only=detect_only,
-                options=final_options,
+            # Log image dimensions before processing
+            if is_batch:
+                image_dims = [
+                    f"{img.width}x{img.height}"
+                    for img in images
+                    if hasattr(img, "width") and hasattr(img, "height")
+                ]
+                logger.debug(
+                    f"[{thread_id}] Processing batch of {len(images)} images with dimensions: {image_dims}"
+                )
+            elif hasattr(images, "width") and hasattr(images, "height"):
+                logger.debug(
+                    f"[{thread_id}] Processing single image with dimensions: {images.width}x{images.height}"
+                )
+            else:
+                logger.warning(f"[{thread_id}] Could not determine dimensions of input image(s).")
+
+            # Acquire lock specifically for the inference call
+            inference_lock = self._get_engine_inference_lock(selected_engine_name)
+            logger.debug(
+                f"[{thread_id}] Attempting to acquire inference lock for {selected_engine_name}..."
             )
+            inference_wait_start = time.monotonic()
+            with inference_lock:
+                inference_acquired_time = time.monotonic()
+                logger.debug(
+                    f"[{thread_id}] Acquired inference lock for {selected_engine_name} (waited {inference_acquired_time - inference_wait_start:.2f}s). Calling process_image..."
+                )
+                inference_start_time = time.monotonic()
+
+                results = engine_instance.process_image(
+                    images=images,
+                    languages=languages,
+                    min_confidence=min_confidence,
+                    device=device,
+                    detect_only=detect_only,
+                    options=final_options,
+                )
+                inference_end_time = time.monotonic()
+                logger.debug(
+                    f"[{thread_id}] process_image call finished for {selected_engine_name} (Duration: {inference_end_time - inference_start_time:.2f}s). Releasing lock."
+                )
 
             # Log result summary based on mode
             if is_batch: