Upload 4 files

Dockerfile

@@ -1,42 +1,16 @@
-# Use a Python base image with slim variant to reduce size
-FROM python:3.12-slim
-
-# Set environment variables
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    TORCH_HOME=/tmp/.torch
-
-# Install system dependencies required for OpenCV
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libgl1-mesa-glx \
-    libglib2.0-0 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Set the working directory
+# Usa una imagen base de Python
+FROM python:3.12.7
+# Establece el directorio de trabajo
 WORKDIR /code
 
-# Copy the requirements file
+# Copia los archivos necesarios al contenedor
 COPY ./requirements.txt /code/requirements.txt
-
-# Install dependencies
 RUN pip install --no-cache-dir -r /code/requirements.txt
+RUN pip install fastapi uvicorn
 
-# Copy the application code
-COPY . /code
-
-# Create a non-root user
-RUN groupadd -r appuser && useradd -r -g appuser appuser
-
-# Change ownership of /code to the non-root user
-RUN chown -R appuser:appuser /code
-
-# Switch to the non-root user
-USER appuser
+COPY . .
 
-# Expose the port the app runs on
-EXPOSE 7860
+RUN chmod -R 777 /code
 
-# Command to run the application
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+# Comando para ejecutar la aplicación
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,144 +1,67 @@
 from fastapi import FastAPI, File, UploadFile, HTTPException, Query
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from typing import List
+import cv2
 from PIL import Image
-from io import BytesIO
 import numpy as np
-import torch
-from torchvision.models import detection
-from torchvision.transforms import functional as F
-import gradio as gr
-from typing import List, Dict
+from io import BytesIO
 
-# FastAPI app
 app = FastAPI()
 
-# Make sure torch knows where to cache models
-import os
-os.environ['TORCH_HOME'] = '/tmp/.torch'
-
-# Load model with error handling
-try:
-    # Use the new 'weights' parameter instead of 'pretrained'
-    print("Loading object detection model...")
-    model = detection.fasterrcnn_resnet50_fpn(weights="DEFAULT")
-    model.eval()
-    print("Model loaded successfully")
-except Exception as e:
-    print(f"Error loading model: {e}")
-    # Fallback to non-pretrained model if loading fails
-    print("Attempting to load model without pretrained weights...")
-    model = detection.fasterrcnn_resnet50_fpn(weights=None)
-    model.eval()
-    print("Using model without pretrained weights")
-
-# Load COCO class labels
-COCO_LABELS = [
-    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
-    'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
-    'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
-    'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag',
-    'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite',
-    'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
-    'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana',
-    'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',
-    'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'dining table',
-    'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
-    'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock',
-    'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
-]
-
-def predict_objects(image, target_label="book", confidence_threshold=0.5):
-    """Predicts objects in the given image and filters for a specific label."""
-    if image is None:
-        return []
-
-    # Convert to RGB if needed
-    if image.mode != "RGB":
-        image = image.convert("RGB")
+def detect_cat(image, draw_rectangles=False):
+    existe = "NO"
+    print("resultado: ", image.shape)
     
-    img_tensor = F.to_tensor(image).unsqueeze(0)
+    # Load the cat face cascade classifier
+    cat_cascade = cv2.CascadeClassifier('haarcascade_frontalcatface.xml')
     
-    with torch.no_grad():
-        prediction = model(img_tensor)[0]
-
-    detected_objects = []
-    for i in range(len(prediction['labels'])):
-        score = prediction['scores'][i].item()
-        label_index = prediction['labels'][i].item()
-        label = COCO_LABELS[label_index]
-        
-        # Check if score exceeds threshold and label matches target (if target is not empty)
-        if score > confidence_threshold and (not target_label or label == target_label):
-            bbox = [int(b) for b in prediction['boxes'][i].tolist()]
-            detected_objects.append({'label': label, 'bbox': bbox, 'score': score})
-
-    return detected_objects
+    # Convert to grayscale
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    # Detect cat faces
+    cats = cat_cascade.detectMultiScale(
+        gray,
+        scaleFactor=1.1,
+        minNeighbors=3,
+        minSize=(30, 30)
+    )
+    
+    # Draw rectangles around detected cats if requested
+    if draw_rectangles:
+        for (x, y, w, h) in cats:
+            cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
+    
+    # Return more detailed information
+    return {
+        "found": "SI" if len(cats) > 0 else "NO",
+        "count": len(cats),
+        "locations": cats.tolist() if len(cats) > 0 else []
+    }
 
 @app.post('/predict/')
-async def predict_api(file: UploadFile = File(...), target_label: str = Query("book")):
-    """FastAPI endpoint to detect objects in an uploaded image."""
+async def predict(
+    file: UploadFile = File(...), 
+    tipo: str = Query(...),
+    draw_boxes: bool = Query(False)
+):
     try:
-        image_bytes = await file.read()
-        image = Image.open(BytesIO(image_bytes))
-        predictions = predict_objects(image, target_label)
-        return {"predictions": predictions}
+        image = Image.open(BytesIO(await file.read()))
+        image = np.asarray(image)
+        prediction = detect_cat(image, draw_rectangles=draw_boxes)
+        
+        if draw_boxes:
+            # Convert back to PIL Image and then to bytes
+            result_image = Image.fromarray(image)
+            img_byte_arr = BytesIO()
+            result_image.save(img_byte_arr, format='PNG')
+            img_byte_arr = img_byte_arr.getvalue()
+            
+            return {
+                "prediction": prediction,
+                "image": img_byte_arr
+            }
+            
+        return {"prediction": prediction}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
-
-def detect_objects(input_image, target_object="book", confidence=0.5):
-    """Gradio interface function for object detection."""
-    if input_image is None:
-        return None, []
-    
-    # Process the image
-    predictions = predict_objects(input_image, target_object, confidence)
-    
-    # Draw bounding boxes on the image
-    img_with_boxes = input_image.copy()
-    import numpy as np
-    from PIL import ImageDraw
-    draw = ImageDraw.Draw(img_with_boxes)
-    
-    results = []
-    for obj in predictions:
-        label = obj['label']
-        score = obj['score']
-        bbox = obj['bbox']
-        
-        # Draw rectangle
-        draw.rectangle(bbox, outline="red", width=3)
-        
-        # Draw label
-        text = f"{label}: {score:.2f}"
-        draw.text((bbox[0], bbox[1] - 10), text, fill="red")
-        
-        # Format results for display
-        results.append(f"{label}: {score:.2f} at position {bbox}")
-    
-    return img_with_boxes, results
-
-# Create Gradio interface
-demo = gr.Interface(
-    fn=detect_objects,
-    inputs=[
-        gr.Image(type="pil", label="Upload Image"),
-        gr.Dropdown(
-            choices=COCO_LABELS[1:],  # Skip background
-            value="book",
-            label="Target Object"
-        ),
-        gr.Slider(minimum=0.1, maximum=0.9, value=0.5, step=0.1, label="Confidence Threshold")
-    ],
-    outputs=[
-        gr.Image(type="pil", label="Detection Result"),
-        gr.JSON(label="Detected Objects")
-    ],
-    title="Object Detection API",
-    description="Upload an image to detect objects. By default, we'll highlight books, but you can select any object type.",
-    examples=[
-        ["https://images.unsplash.com/photo-1507842217343-583bb7270b66?q=80&w=2670&auto=format&fit=crop", "book", 0.5],
-        ["https://images.unsplash.com/photo-1524578271613-d550eacf6090?q=80&w=2670&auto=format&fit=crop", "book", 0.5],
-    ]
-)
-
-# Mount FastAPI app to Gradio for compatibility with both
-app = gr.mount_gradio_app(app, demo, path="/")

requirements.txt

@@ -1,8 +1,7 @@
 fastapi
-uvicorn
-Pillow
-opencv-python
-torch
-torchvision
-gradio>=5.29.0
+numpy
+pydantic
+opencv-python-headless
+uvicorn[standard]
 python-multipart
+pillow