Upload 18 files

.dockerignore

@@ -0,0 +1,2 @@
+exe
+

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10
+
+WORKDIR /app
+
+# Install required dependencies
+RUN apt-get update && apt-get install -y libgl1-mesa-glx
+
+# Copy and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Run the application (Fix: Bind to 0.0.0.0)
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Models/New_Apparatus_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71e4435577d00ab03c2e7235d725fafec791701e74e474bbddb981f5c1c9c01a
+size 6585932

Models/Remaining_tests_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd46c28050ed420df8e3b6f08fbea4a54f949b1f23bf8bea0e063503f04cbdbc
+size 6650636

Models/analog_box_v1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:160cabca761c1b6f0e9b3721a0b793e2ec4752fde7b088b53fa0bbc9ff761814
+size 6691340

Models/analog_box_v2.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8da74f63d7648dbbff9258faab09fb2e85e6f823f02e5db2e44bf509cf6a0f8d
+size 6437324

Models/analog_reading.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acd3a3f754cf4555b09330af12727ab1b958fea71aa66dc2a6d0bb8dc41a8393
+size 6752652

Models/analog_reading_v1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acd3a3f754cf4555b09330af12727ab1b958fea71aa66dc2a6d0bb8dc41a8393
+size 6752652

Models/analog_reading_v2.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc51c222ffa476ad1dadfa56937238c08149102aa49b13d3de533ba62c875c9e
+size 6760652

Models/res_temp_box.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21b3300ece908bba2b786195f36c1842a3b1583d8a5be5e0548e946c98e391ab
+size 6649420

Models/res_temp_ocr.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41b7fc8aca0bb09f51a2dcbec9e27a5cc454cbbc83a9f3e72c61e3b00d85e1ba
+size 6828236

Remaining_test.py

@@ -0,0 +1,66 @@
+import sys
+import cv2
+import numpy as np
+import easyocr
+from ultralytics import YOLO
+
+# Initialize EasyOCR reader
+reader = easyocr.Reader(['en'])
+
+def draw_obb(image, obb):
+    boxes = obb.xyxyxyxy.cpu().numpy()
+    extracted_texts = []
+
+    for i, box in enumerate(boxes):
+        pts = box.reshape(4, 2).astype(np.int32)
+        
+        # Draw the bounding box
+        cv2.polylines(image, [pts], isClosed=True, color=(0, 255, 0), thickness=2)
+        
+        # Crop the detected region
+        x_min, y_min = np.min(pts, axis=0)
+        x_max, y_max = np.max(pts, axis=0)
+        cropped_region = image[y_min:y_max, x_min:x_max]
+        
+        # Apply OCR on the cropped region
+        if cropped_region.size > 0:
+            text_results = reader.readtext(cropped_region)
+            detected_text = " ".join([text[1] for text in text_results])
+            extracted_texts.append(detected_text)
+
+            # Put extracted text on the image
+            cv2.putText(image, detected_text, (x_min, y_min - 10), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 2)
+
+    return image, extracted_texts
+
+def main(model_path_3, image_path):
+    # Load the YOLO OBB model for detection
+    model_3 = YOLO(model_path_3)
+    
+    # Read the input image
+    image = cv2.imread(image_path)
+    if image is None:
+        print("Error: Could not read image at", image_path)
+        sys.exit(1)
+    
+    # Run inference using model_3 for detection
+    results = model_3(image)
+    
+    all_extracted_texts = []
+    
+    # Iterate over the results and draw OBB predictions
+    for r in results:
+        if r.obb is not None:
+            image, extracted_texts = draw_obb(image, r.obb)
+            all_extracted_texts.extend(extracted_texts)
+            for i, class_id in enumerate(r.obb.cls.cpu().numpy()):
+                class_name = r.names[int(class_id)]
+                print(f"Detected class ID: {class_id}, Class name: {class_name}")
+            
+            # Print extracted texts from OCR
+            for idx, text in enumerate(extracted_texts):
+                print(f"OCR Extracted Text {idx + 1}: {text}")
+    
+    return image, all_extracted_texts
+

analog.py

@@ -0,0 +1,254 @@
+import sys
+import cv2
+import numpy as np
+from ultralytics import YOLO
+
+# -----------------------------
+# Part 1: Helper functions for cropping
+# -----------------------------
+
+def draw_obb(image, obb):
+    """Draw oriented bounding boxes on an image."""
+    boxes = obb.xyxyxyxy.cpu().numpy()
+    for box in boxes:
+        pts = box.reshape(4, 2).astype(np.int32)
+        cv2.polylines(image, [pts], isClosed=True, color=(0, 255, 0), thickness=2)
+    return image
+
+def order_points(pts):
+    """Order 4 points as top-left, top-right, bottom-right, bottom-left."""
+    rect = np.zeros((4, 2), dtype="float32")
+    s = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(s)]
+    rect[2] = pts[np.argmax(s)]
+    diff = np.diff(pts, axis=1)
+    rect[1] = pts[np.argmin(diff)]
+    rect[3] = pts[np.argmax(diff)]
+    return rect
+
+def crop_region(image, obb):
+    """
+    Crop the meter region from the image using the OBB.
+    Uses a perspective transformation based on the minimal area rectangle.
+    """
+    boxes = obb.xyxyxyxy.cpu().numpy()
+    if len(boxes) == 0:
+        return None
+    # Use the first detected box for cropping.
+    box = boxes[0]
+    pts = box.reshape(4, 2).astype(np.float32)
+    
+    # Get the minimal area rectangle for the points.
+    rect = cv2.minAreaRect(pts)
+    width = int(rect[1][0])
+    height = int(rect[1][1])
+    if width <= 0 or height <= 0:
+        return None
+
+    # Destination points for the warp (top-left, top-right, bottom-right, bottom-left)
+    dst_pts = np.array([
+        [0, 0],
+        [width - 1, 0],
+        [width - 1, height - 1],
+        [0, height - 1]], dtype=np.float32)
+    
+    # Order the source points and compute the perspective transform.
+    ordered_pts = order_points(pts)
+    M = cv2.getPerspectiveTransform(ordered_pts, dst_pts)
+    cropped = cv2.warpPerspective(image, M, (width, height))
+    return cropped
+
+def detect_and_crop_region(analog_box_model, image_path):
+    """
+    Detect the meter region using analog_box.pt and return the cropped image.
+    """
+    model = YOLO(analog_box_model)
+    image = cv2.imread(image_path)
+    if image is None:
+        print("Error: Could not read image at", image_path)
+        sys.exit(1)
+    
+    results = model(image)
+    for r in results:
+        if hasattr(r, "obb") and r.obb is not None:
+            cropped = crop_region(image, r.obb)
+            if cropped is not None:
+                return cropped
+    print("No meter detected.")
+    sys.exit(1)
+
+# -----------------------------
+# Part 2: Meter reading functions (provided calculation code)
+# -----------------------------
+
+def get_center_point(box):
+    """Calculate the center point of a bounding box (4 corners)."""
+    pts = box.reshape(4, 2)
+    center_x = np.mean(pts[:, 0])
+    center_y = np.mean(pts[:, 1])
+    return (center_x, center_y)
+
+def calculate_meter_reading(needle_corners, number_positions):
+    """
+    Given the needle corners and number positions, calculate the meter reading.
+    The numbers are standardized as [0, 5, 10, 15, 20, 25, 30].
+    """
+    number_values = [0, 5, 10, 15, 20, 25, 30]
+    
+    # Sort number positions left-to-right by x-coordinate.
+    sorted_positions = sorted(number_positions, key=lambda x: x[1][0])
+    labeled_positions = []
+    for i, (_, position) in enumerate(sorted_positions):
+        if i < len(number_values):
+            labeled_positions.append((number_values[i], position))
+    
+    # Compute needle tip as midpoint between corner 3 and corner 4.
+    needle_tip_x = (needle_corners[2][0] + needle_corners[3][0]) / 2
+    needle_tip_y = (needle_corners[2][1] + needle_corners[3][1]) / 2
+    needle_tip = np.array([needle_tip_x, needle_tip_y])
+    
+    # Check if needle tip exactly matches a number position.
+    for value, position in labeled_positions:
+        distance = np.sqrt((needle_tip[0] - position[0])**2 + (needle_tip[1] - position[1])**2)
+        if distance < 15:  # threshold for "exact match"
+            return value, "exact_midpoint"
+    
+    # If not an exact match, find the two numbers between which the needle lies.
+    left_value = None
+    right_value = None
+    left_position = None
+    right_position = None
+    for i in range(len(labeled_positions) - 1):
+        curr_value, curr_pos = labeled_positions[i]
+        next_value, next_pos = labeled_positions[i + 1]
+        if curr_pos[0] <= needle_tip[0] <= next_pos[0]:
+            left_value = curr_value
+            right_value = next_value
+            left_position = curr_pos
+            right_position = next_pos
+            break
+
+    # If not between any two, return the closest.
+    if left_value is None or right_value is None:
+        min_distance = float('inf')
+        closest_value = None
+        for value, position in labeled_positions:
+            distance = np.sqrt((needle_tip[0] - position[0])**2 + (needle_tip[1] - position[1])**2)
+            if distance < min_distance:
+                min_distance = distance
+                closest_value = value
+        return closest_value, "closest_midpoint"
+    
+    # Interpolate based on x-distance.
+    total_x_distance = right_position[0] - left_position[0]
+    needle_x_distance = needle_tip[0] - left_position[0]
+    ratio = needle_x_distance / total_x_distance if total_x_distance > 0 else 0
+    value_range = right_value - left_value
+    interpolated_value = left_value + (ratio * value_range)
+    interpolated_value = round(interpolated_value, 1)
+    
+    return interpolated_value, "interpolated_midpoint"
+
+def process_meter_reading(analog_reading_model, image):
+    """
+    Run detection on the provided (cropped) meter image using analog_reading_v2.pt,
+    compute the meter reading, and print the result.
+    """
+    model = YOLO(analog_reading_model)
+    results = model(image)
+    
+    needle_corners = None
+    number_positions = []  # Each element is a tuple: (detected_label, center)
+    
+    # Process each detection result.
+    for r in results:
+        if hasattr(r, "obb") and r.obb is not None:
+            image = draw_obb(image, r.obb)
+            boxes = r.obb.xyxyxyxy.cpu().numpy()
+            classes = r.obb.cls.cpu().numpy()
+            
+            for box, class_id in zip(boxes, classes):
+                class_name = r.names[int(class_id)]
+                center = get_center_point(box)
+                cv2.circle(image, (int(center[0]), int(center[1])), 3, (0, 0, 255), -1)
+                
+                if class_name.lower() == "needle":
+                    needle_corners = box.reshape(4, 2)
+                # Check if class is a digit (or the word "numbers") representing meter numbers.
+                elif class_name.isdigit() or class_name in ["0", "5", "10", "15", "20", "25", "30"] or class_name.lower() == "numbers":
+                    number_positions.append((0, center))
+    
+    # Label the numbers (using standard ordering) on the image.
+    if number_positions:
+        number_values = [0, 5, 10, 15, 20, 25, 30]
+        sorted_positions = sorted(number_positions, key=lambda x: x[1][0])
+        for i, (_, position) in enumerate(sorted_positions):
+            if i < len(number_values):
+                label = str(number_values[i])
+                cv2.putText(image, label, 
+                            (int(position[0]), int(position[1]) - 15),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+    
+    # Compute and print the meter reading if needle and numbers are detected.
+    if needle_corners is not None and number_positions:
+        needle_tip_x = (needle_corners[2][0] + needle_corners[3][0]) / 2
+        needle_tip_y = (needle_corners[2][1] + needle_corners[3][1]) / 2
+        needle_tip = np.array([needle_tip_x, needle_tip_y])
+                
+        reading, method = calculate_meter_reading(needle_corners, number_positions)
+        if reading is not None:
+            result_text = f"Meter reading: {reading} ({method})"
+            print(result_text)
+            
+            # Visualize connection between the needle tip and the nearest number.
+            number_values = [0, 5, 10, 15, 20, 25, 30]
+            sorted_positions = sorted(number_positions, key=lambda x: x[1][0])
+            labeled_positions = []
+            for i, (_, position) in enumerate(sorted_positions):
+                if i < len(number_values):
+                    labeled_positions.append((number_values[i], position))
+            
+            # Find adjacent numbers for interpolation visualization.
+            left_pos = None
+            right_pos = None
+            for i in range(len(labeled_positions) - 1):
+                curr_value, curr_pos = labeled_positions[i]
+                next_value, next_pos = labeled_positions[i + 1]
+                if curr_pos[0] <= needle_tip[0] <= next_pos[0]:
+                    left_pos = curr_pos
+                    right_pos = next_pos
+                    break
+            
+            if "interpolated" in method and left_pos is not None and right_pos is not None:
+                cv2.line(image, 
+                         (int(needle_tip[0]), int(needle_tip[1])), 
+                         (int(left_pos[0]), int(left_pos[1])), 
+                         (255, 0, 255), 1, cv2.LINE_AA)
+                cv2.line(image, 
+                         (int(needle_tip[0]), int(needle_tip[1])), 
+                         (int(right_pos[0]), int(right_pos[1])), 
+                         (255, 0, 255), 1, cv2.LINE_AA)
+            else:
+                # Connect to closest number if not interpolated.
+                min_distance = float('inf')
+                closest_position = None
+                for _, position in labeled_positions:
+                    distance = np.sqrt((needle_tip[0] - position[0])**2 + 
+                                       (needle_tip[1] - position[1])**2)
+                    if distance < min_distance:
+                        min_distance = distance
+                        closest_position = position
+                if closest_position is not None:
+                    cv2.line(image, 
+                             (int(needle_tip[0]), int(needle_tip[1])), 
+                             (int(closest_position[0]), int(closest_position[1])), 
+                             (255, 0, 255), 2)
+        else:
+            print("Needle position is out of range")
+    else:
+        if needle_corners is None:
+            print("Needle not detected")
+        if not number_positions:
+            print("No numbers detected")
+            
+    return image

app.py

@@ -0,0 +1,243 @@
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+import cv2
+import numpy as np
+import os
+from ultralytics import YOLO
+from PIL import Image
+import io
+import easyocr
+from ocr import detect_and_crop as ocr_detect_and_crop, detect_final_classes
+from Remaining_test import draw_obb  
+from analog import crop_region, calculate_meter_reading, get_center_point, process_meter_reading, detect_and_crop_region
+from fastapi.responses import Response
+import tempfile
+
+app = FastAPI()
+
+try:
+    res_temp_box = YOLO("Models/res_temp_box.pt")
+    res_temp_ocr = YOLO("Models/res_temp_ocr.pt")
+    analog_box = YOLO("Models/analog_box_v2.pt")
+    analog_reading = YOLO("Models/analog_reading_v2.pt")
+    remaining_test_model = YOLO("Models/Remaining_tests_model.pt")
+    new_apparatus_model = YOLO("Models/New_Apparatus_model.pt")
+except Exception as e:
+    print(f"Error loading models: {str(e)}")
+    raise
+
+reader = easyocr.Reader(['en'])
+
+def process_res_temp(file_bytes):
+    try:
+        # Try to process using both models and select the best result
+        image = Image.open(io.BytesIO(file_bytes)).convert("RGB")
+        
+        # For OCR model processing (original res_temp approach)
+        cropped_regions = ocr_detect_and_crop(res_temp_box, image)
+        final_classes_dict = detect_final_classes(res_temp_ocr, cropped_regions)
+        
+        # Convert image for apparatus model
+        image_cv = cv2.imdecode(np.frombuffer(file_bytes, np.uint8), cv2.IMREAD_COLOR)
+        
+        # Process with new apparatus model
+        apparatus_results = new_apparatus_model(image_cv)
+        apparatus_data = {}
+        confidence_scores = {}
+        
+        # Extract text using apparatus model
+        for r in apparatus_results:
+            if r.obb is not None:
+                # Get confidence scores for detections
+                confidences = r.obb.conf.cpu().numpy() if hasattr(r.obb, 'conf') else None
+                
+                _, extracted_texts = draw_obb(image_cv.copy(), r.obb)
+                for i, class_id in enumerate(r.obb.cls.cpu().numpy()):
+                    class_name = r.names[int(class_id)]
+                    if i < len(extracted_texts) and extracted_texts[i]:
+                        apparatus_data[class_name] = extracted_texts[i]
+                        
+                        # Store confidence score if available
+                        if confidences is not None and i < len(confidences):
+                            confidence_scores[class_name] = float(confidences[i])
+                        else:
+                            confidence_scores[class_name] = 0.75  # Default fallback
+        
+        # Combine results from both models
+        final_data = {**final_classes_dict, **apparatus_data}
+        
+        # Calculate overall confidence (average of available scores)
+        overall_confidence = 0.0
+        if confidence_scores:
+            overall_confidence = sum(confidence_scores.values()) / len(confidence_scores)
+        else:
+            overall_confidence = 0.75  # Default if no scores available
+            
+        # Round overall confidence to 2 decimal places
+        overall_confidence = round(overall_confidence, 2)
+        
+        # Convert to key-value list format with individual confidence scores
+        kv_list = []
+        for k, v in final_data.items():
+            # Use the confidence score if available, otherwise use default
+            conf = round(confidence_scores.get(k, 0.75), 2)
+            kv_list.append({
+                "keyName": k, 
+                "keyValue": "".join(v) if isinstance(v, list) else v, 
+                "actualValue": "".join(v) if isinstance(v, list) else v, 
+                "confidenceScore": conf
+            })
+        
+        return {"ocs": overall_confidence, "extractions": kv_list}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error processing data: {str(e)}")
+
+
+def process_remaining_test(file_bytes, expected_classes):
+    try:
+        image_cv = cv2.imdecode(np.frombuffer(file_bytes, np.uint8), cv2.IMREAD_COLOR)
+        if image_cv is None:
+            raise HTTPException(status_code=400, detail="Invalid image data for processing")
+        
+        # Run inference using the remaining tests model
+        results = remaining_test_model(image_cv)
+        
+        extracted_data = {}
+        confidence_scores = {}
+        
+        # Process results and extract data with confidence scores
+        for r in results:
+            if r.obb is not None:
+                _, extracted_texts = draw_obb(image_cv.copy(), r.obb)
+                confidences = r.obb.conf.cpu().numpy()
+                
+                for i, (class_id, conf) in enumerate(zip(r.obb.cls.cpu().numpy(), confidences)):
+                    class_name = r.names[int(class_id)]
+                    if class_name in expected_classes and i < len(extracted_texts) and extracted_texts[i]:
+                        extracted_data[class_name] = extracted_texts[i]
+                        confidence_scores[class_name] = float(conf)
+        
+        # Calculate overall confidence with fallback
+        if confidence_scores:
+            overall_confidence = sum(confidence_scores.values()) / len(confidence_scores)
+            overall_confidence = round(overall_confidence, 2)
+        else:
+            overall_confidence = 0.0  # Fallback when no confidences available
+        
+        # Create result list with proper error handling
+        result_list = [
+            {
+                "keyName": k,
+                "keyValue": round(float(v), 2) if isinstance(v, (int, float, str)) and str(v).replace('.','',1).isdigit() else v,
+                "actualValue": round(float(v), 2) if isinstance(v, (int, float, str)) and str(v).replace('.','',1).isdigit() else v,
+                "confidenceScore": round(confidence_scores.get(k, overall_confidence), 2)
+            }
+            for k, v in extracted_data.items()
+            if v is not None  # Skip None values
+        ]
+        
+        if not result_list:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"No valid data found for expected classes: {expected_classes}"
+            )
+        
+        return {"ocs": overall_confidence, "extractions": result_list}
+        
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error processing test data: {str(e)}")
+
+
+def process_dc_test(file_bytes):
+    """
+    Implements the DC_TEST pipeline using functions from analog.py.
+    It decodes the image, ensures consistent color format, detects and crops the meter
+    region using the analog_box model, and then uses the analog_reading model along with
+    calculate_meter_reading and get_center_point to compute the meter reading.
+    """
+    try:
+        # Decode file bytes into a CV image (BGR)
+        image_cv = cv2.imdecode(np.frombuffer(file_bytes, np.uint8), cv2.IMREAD_COLOR)
+        if image_cv is None:
+            raise HTTPException(status_code=400, detail="Invalid image data for DC_TEST")
+        
+        results = analog_box(image_cv)
+        cropped_meter = None
+        for r in results:
+            if hasattr(r, "obb") and r.obb is not None:
+                cropped_meter = crop_region(image_cv, r.obb)
+                if cropped_meter is not None:
+                    break
+        
+        if cropped_meter is None:
+            raise HTTPException(status_code=400, detail="No analog meter detected in image")
+        
+        meter_results = analog_reading(cropped_meter)
+        needle_corners = None
+        needle_corners = None
+        number_positions = []
+        needle_confidence = 0
+        number_confidences = []
+        
+        for r in meter_results:
+            if hasattr(r, "obb") and r.obb is not None:
+                boxes = r.obb.xyxyxyxy.cpu().numpy()
+                classes = r.obb.cls.cpu().numpy()
+                confidences = r.obb.conf.cpu().numpy()  # Get confidence scores
+                
+                for box, class_id, conf in zip(boxes, classes, confidences):
+                    class_name = r.names[int(class_id)]
+                    center = get_center_point(box)
+                    
+                    if class_name.lower() == "needle":
+                        needle_corners = box.reshape(4, 2)
+                        needle_confidence = float(conf)
+                    elif (class_name.isdigit() or 
+                          class_name in ["0", "5", "10", "15", "20", "25", "30"] or 
+                          class_name.lower() == "numbers"):
+                        number_positions.append((0, center))
+                        number_confidences.append(float(conf))
+        
+        if needle_corners is not None and number_positions:
+            reading, method = calculate_meter_reading(needle_corners, number_positions)
+            
+            # Calculate overall confidence using the formula
+            # (2 * needle_confidence + sum of number confidences) / (2 + number of numbers)
+            overall_confidence = (2 * needle_confidence + sum(number_confidences)) / (2 + len(number_confidences))
+            overall_confidence = round(overall_confidence, 2)
+            
+            reading = round(float(reading), 2)
+            
+            list = [{
+                "keyName": "MeterReading",
+                "keyValue": str(reading),
+                "actualValue": str(reading),
+                "confidenceScore": overall_confidence,
+            }]
+            
+            return {
+                "ocs": overall_confidence,
+                "extractions": list
+            }
+    
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error processing DC_TEST: {str(e)}")
+
+
+@app.post("/detect/")
+async def detect(file: UploadFile = File(...), test_type: str = Form(...)):
+    file_bytes = await file.read()
+    if test_type == "CONDUCTOR_RESISTANCE_TEST":
+        return process_res_temp(file_bytes)
+    elif test_type == "DC_TEST":
+        # For DC_TEST, use the enhanced pipeline which now calls analog_reading only once.
+        return process_dc_test(file_bytes)
+    elif test_type == "PARTIAL_DISCHARGE_TEST":
+        return process_remaining_test(file_bytes, expected_classes=["UVolt", "qCValue"])
+    elif test_type == "HIGH_VOLTAGE_TEST":
+        return process_remaining_test(file_bytes, expected_classes=["kV", "TimeLeft", "q(IEC) value"])
+    else:
+        raise HTTPException(status_code=400, detail="Invalid test_type. Choose 'CONDUCTOR_RESISTANCE_TEST', 'DC_TEST', 'PARTIAL_DISCHARGE_TEST', or 'HIGH_VOLTAGE_TEST'")
+
+@app.get("/")
+def health_check():
+    return {"status": "healthy", "version": "v2.4"}

docker-compose.yaml

@@ -0,0 +1,10 @@
+version: "3.8"
+
+services:
+  fastapi-app:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/app
+    restart: always

new_apparatus.py

@@ -0,0 +1,70 @@
+import sys
+import cv2
+import numpy as np
+import easyocr
+from ultralytics import YOLO
+
+# Initialize EasyOCR reader
+reader = easyocr.Reader(['en'])
+
+def draw_obb(image, obb):
+    boxes = obb.xyxyxyxy.cpu().numpy()
+    extracted_texts = []
+
+    for i, box in enumerate(boxes):
+        pts = box.reshape(4, 2).astype(np.int32)
+        
+        # Draw the bounding box
+        cv2.polylines(image, [pts], isClosed=True, color=(0, 255, 0), thickness=2)
+        
+        # Crop the detected region
+        x_min, y_min = np.min(pts, axis=0)
+        x_max, y_max = np.max(pts, axis=0)
+        cropped_region = image[y_min:y_max, x_min:x_max]
+        
+        # Apply OCR on the cropped region
+        if cropped_region.size > 0:
+            text_results = reader.readtext(cropped_region)
+            detected_text = " ".join([text[1] for text in text_results])
+            extracted_texts.append(detected_text)
+
+            # Put extracted text on the image
+            cv2.putText(image, detected_text, (x_min, y_min - 10), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 2)
+
+    return image, extracted_texts
+
+def main(model_path_3, image_path):
+    # Load the YOLO OBB model for detection
+    model_3 = YOLO(model_path_3)
+    
+    # Read the input image
+    image = cv2.imread(image_path)
+    if image is None:
+        print("Error: Could not read image at", image_path)
+        sys.exit(1)
+    
+    # Run inference using model_3 for detection
+    results = model_3(image)
+    
+    # Iterate over the results and draw OBB predictions
+    for r in results:
+        if r.obb is not None:
+            image, extracted_texts = draw_obb(image, r.obb)
+            for i, class_id in enumerate(r.obb.cls.cpu().numpy()):
+                class_name = r.names[int(class_id)]
+                print(f"Detected class ID: {class_id}, Class name: {class_name}")
+            
+            # Print extracted texts from OCR
+            for idx, text in enumerate(extracted_texts):
+                print(f"OCR Extracted Text {idx + 1}: {text}")
+
+    # Display the resulting image with bounding boxes and text
+    cv2.imshow("Detections with OCR", image)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    model_path_3 = "Models/new apparatus.pt"
+    image_path = "test_images/1 (1).jpg"
+    main(model_path_3, image_path)

ocr.py

@@ -0,0 +1,103 @@
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+from ultralytics import YOLO
+from PIL import Image
+
+def visualize_with_obb(image, obb):
+    """Visualizes OBB bounding boxes on the image using Matplotlib."""
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.imshow(image)
+
+    if obb is not None:
+        boxes = obb.xyxyxyxy.cpu().numpy()
+        for box in boxes:
+            pts = box.reshape(4, 2)  # Convert to (x, y) points
+            ax.plot([pts[i][0] for i in [0,1,2,3,0]], 
+                    [pts[i][1] for i in [0,1,2,3,0]], 
+                    linestyle='-', linewidth=2, color='lime')
+            
+
+def crop_regions(image, obb, class_ids, names):
+    """Crops regions based on OBB detection and returns (cropped image, x-coordinate, class_name)."""
+    cropped_regions = []
+
+    if obb is not None:
+        boxes = obb.xyxyxyxy.cpu().numpy()
+        for i, box in enumerate(boxes):
+            pts = box.reshape(4, 2).astype(int)
+            x_min, y_min = np.min(pts, axis=0)
+            x_max, y_max = np.max(pts, axis=0)
+            
+            # Get class name for this box
+            class_id = int(class_ids[i])
+            class_name = names[class_id]
+
+            cropped = image.crop((x_min, y_min, x_max, y_max))
+            cropped_regions.append((cropped, x_min, class_name))  # Store class_name with cropped image
+    
+    return cropped_regions
+
+def detect_and_crop(model_3, image):
+    """Runs first detection model (OBB-based) and returns cropped regions with class info."""
+    results = model_3(image)
+    cropped_regions = []
+    
+    for r in results:
+        visualize_with_obb(image, r.obb)  # Display first detection
+        if r.obb is not None:
+            cropped_regions = crop_regions(image, r.obb, r.obb.cls.cpu().numpy(), r.names)
+
+    return cropped_regions
+
+def detect_final_classes(model_4, cropped_regions):
+    """Runs second detection model (OBB-based OCR) and returns detected classes by first class."""
+    class_results = {}  # Dictionary to store results by class
+
+    for cropped, x_min, class_name in cropped_regions:
+        results = model_4(cropped)
+        detected_data = []
+        
+        for r in results:
+            if r.obb is not None:
+                for i, class_id in enumerate(r.obb.cls.cpu().numpy()):
+                    ocr_class_name = r.names[int(class_id)]
+                    box_pts = r.obb.xyxyxyxy.cpu().numpy()[i].reshape(4, 2)
+                    x_center = np.mean(box_pts[:, 0])
+
+                    detected_data.append((ocr_class_name, x_center))
+
+        # Sort detected characters by x-center (left to right)
+        detected_data.sort(key=lambda x: x[1])
+        
+        # Process to place '.' after second digit if needed
+        final_classes = [
+            "." if cls == "dot" else "°" if cls == "degree" else cls  
+            for cls, _ in detected_data
+        ]
+        
+        # Store result by first detection class
+        if class_name not in class_results:
+            class_results[class_name] = []
+        class_results[class_name] = final_classes
+
+    return class_results
+
+def main(model_path_3, model_path_4, image_path):
+    """Main function to run both detections using OBB models and visualize results."""
+    model_3 = YOLO(model_path_3)  
+    model_4 = YOLO(model_path_4)  
+
+    image = Image.open(image_path).convert("RGB")
+
+    # First detection to identify and crop regions by class
+    cropped_regions = detect_and_crop(model_3, image)
+    
+    # Second detection to read values from each cropped region
+    class_results = detect_final_classes(model_4, cropped_regions)
+
+    # Display results for each class separately
+    print("Detection Results by Class:")
+    for class_name, values in class_results.items():
+        print(f"  {class_name}: {''.join(values)}")
+

requirements.txt

@@ -0,0 +1,62 @@
+annotated-types==0.7.0
+certifi==2024.12.14
+charset-normalizer==3.4.1
+click==8.1.8
+colorama==0.4.6
+contourpy==1.1.1
+cycler==0.12.1
+easyocr==1.7.2
+fastapi==0.95.2
+filelock==3.16.1
+fonttools==4.55.3
+fsspec==2024.12.0
+h11==0.14.0
+idna==3.10
+imageio==2.35.1
+Jinja2==3.1.5
+kiwisolver==1.4.7
+lazy_loader==0.4
+MarkupSafe==2.1.5
+matplotlib==3.7.5
+mpmath==1.3.0
+networkx==3.1
+ninja==1.11.1.3
+numpy==1.24.4
+opencv-python==4.11.0.86
+opencv-python-headless==4.11.0.86
+packaging==24.2
+pandas==2.0.3
+pillow==10.4.0
+pipdeptree==2.24.0
+psutil==6.1.1
+py-cpuinfo==9.0.0
+pyclipper==1.3.0.post6
+pydantic==1.10.9
+pydantic_core==2.27.2
+pyparsing==3.1.4
+pytesseract==0.3.13
+python-bidi==0.6.3
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2024.2
+PyYAML==6.0.2
+requests==2.32.3
+scikit-image==0.21.0
+scipy==1.10.1
+seaborn==0.13.2
+shapely==2.0.6
+six==1.17.0
+sniffio==1.3.1
+starlette==0.27.0
+sympy==1.13.1
+tifffile==2023.7.10
+torch==2.4.1
+torchvision==0.19.1
+tqdm==4.67.1
+typing_extensions==4.12.2
+tzdata==2024.2
+ultralytics==8.3.65
+ultralytics-thop==2.0.14
+urllib3==2.2.3
+uvicorn==0.33.0
+easyocr==1.7.2