Ejercicio: Contador de Monedas con AWS Rekognition ​

# backend/app/models/analysis.py
from sqlalchemy import Column, Integer, String, Float, DateTime
from sqlalchemy.dialects.postgresql import JSONB

class CoinAnalysis(Base):
    __tablename__ = 'coin_analyses'
    
    id = Column(Integer, primary_key=True)
    image_url = Column(String, nullable=False)
    total_value = Column(Float, nullable=False)
    coin_counts = Column(JSONB, nullable=False)
    confidence_score = Column(Float)
    processing_time = Column(Float)
    created_at = Column(DateTime, nullable=False)
    metadata = Column(JSONB)

# backend/app/schemas/analysis.py
class CoinAnalysisCreate(BaseModel):
    image_url: str
    total_value: float
    coin_counts: Dict[str, int]
    confidence_score: Optional[float]
    processing_time: Optional[float]
    metadata: Optional[Dict[str, Any]]

class CoinAnalysisResponse(BaseModel):
    id: int
    image_url: str
    total_value: float
    coin_counts: Dict[str, int]
    confidence_score: float
    created_at: datetime

# backend/tests/unit/test_coin_detector.py
import pytest
from app.services.coin_detector import CoinDetector
from app.services.value_calculator import ValueCalculator

class TestCoinDetector:
    @pytest.fixture
    def detector(self):
        return CoinDetector()

    def test_detect_coins_in_clear_image(self, detector):
        image_path = "tests/fixtures/clear_coins.jpg"
        result = detector.detect_coins(image_path)
        
        assert result.coin_count > 0
        assert result.confidence_score > 0.8
        assert isinstance(result.coin_locations, list)

    def test_handle_poor_lighting(self, detector):
        image_path = "tests/fixtures/dark_coins.jpg"
        result = detector.detect_coins(image_path)
        
        assert result.confidence_score < 0.8
        assert result.warnings == ["Poor lighting detected"]

    def test_calculate_total_value(self):
        calculator = ValueCalculator()
        coins = {
            "25_cent": 4,
            "10_cent": 3,
            "5_cent": 2
        }
        
        total = calculator.calculate_total(coins)
        assert total == 1.45

# backend/tests/integration/test_rekognition.py
class TestRekognitionIntegration:
    @pytest.mark.integration
    def test_end_to_end_detection(self):
        image_path = "tests/fixtures/mixed_coins.jpg"
        
        # Upload image
        s3_client = boto3.client('s3')
        s3_url = upload_to_s3(image_path)
        
        # Process with Rekognition
        rekognition = RekognitionService()
        result = rekognition.analyze_image(s3_url)
        
        # Validate results
        assert result.status == "success"
        assert result.total_value > 0
        assert len(result.detected_coins) > 0

# backend/app/api/endpoints/analysis.py
from fastapi import APIRouter, UploadFile, File
from app.services.coin_detector import CoinDetector
from app.services.value_calculator import ValueCalculator

router = APIRouter()

@router.post("/analyze")
async def analyze_image(
    image: UploadFile = File(...)
) -> Dict[str, Any]:
    # Validar imagen
    if not image.content_type.startswith("image/"):
        raise HTTPException(400, "File must be an image")
    
    try:
        # Procesar imagen
        detector = CoinDetector()
        coins = await detector.detect_coins(image)
        
        # Calcular valor
        calculator = ValueCalculator()
        total_value = calculator.calculate_total(coins)
        
        return {
            "total_value": total_value,
            "coin_counts": coins,
            "confidence_score": detector.confidence_score
        }
    except Exception as e:
        raise HTTPException(500, str(e))

# Backend: FastAPI Setup

# backend/app/core/config.py
from pydantic_settings import BaseSettings
from typing import Optional
import os

class Settings(BaseSettings):
    PROJECT_NAME: str = "Coin Counter"
    API_V1_STR: str = "/api/v1"
    
    # AWS Configuration
    AWS_ACCESS_KEY_ID: str
    AWS_SECRET_ACCESS_KEY: str
    AWS_REGION: str = "us-east-1"
    S3_BUCKET: str
    
    # Database Configuration
    POSTGRES_SERVER: str
    POSTGRES_USER: str
    POSTGRES_PASSWORD: str
    POSTGRES_DB: str
    SQLALCHEMY_DATABASE_URI: Optional[str] = None
    
    # CORS Configuration
    BACKEND_CORS_ORIGINS: list = ["http://localhost:3000"]
    
    # File Upload Settings
    MAX_FILE_SIZE: int = 5 * 1024 * 1024  # 5MB
    ALLOWED_EXTENSIONS: set = {"jpg", "jpeg", "png"}
    
    # Rekognition Configuration
    REKOGNITION_MIN_CONFIDENCE: float = 80.0
    CUSTOM_LABELS_PROJECT_ARN: Optional[str] = None
    
    class Config:
        case_sensitive = True
        env_file = ".env"

settings = Settings()

# backend/app/db/base.py
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from app.core.config import settings

engine = create_engine(settings.SQLALCHEMY_DATABASE_URI, pool_pre_ping=True)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

# backend/app/models/analysis.py
from sqlalchemy import Column, Integer, String, Float, DateTime, JSON
from sqlalchemy.sql import func
from app.db.base import Base

class Analysis(Base):
    __tablename__ = "analyses"

    id = Column(Integer, primary_key=True, index=True)
    image_path = Column(String, nullable=False)
    total_value = Column(Float, nullable=False)
    coin_details = Column(JSON, nullable=False)
    confidence_score = Column(Float)
    processing_time = Column(Float)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())

# backend/app/api/deps.py
from typing import Generator
from app.db.base import SessionLocal
from fastapi import Depends, HTTPException, status
from fastapi.security import APIKeyHeader

api_key_header = APIKeyHeader(name="X-API-Key")

def get_db() -> Generator:
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

async def verify_api_key(api_key: str = Depends(api_key_header)):
    if api_key != settings.API_KEY:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Could not validate API key"
        )
    return api_key

# backend/main.py
from fastapi import FastAPI
from starlette.middleware.cors import CORSMiddleware
from app.core.config import settings
from app.api.api_v1.api import api_router

app = FastAPI(
    title=settings.PROJECT_NAME,
    openapi_url=f"{settings.API_V1_STR}/openapi.json"
)

# Set up CORS
if settings.BACKEND_CORS_ORIGINS:
    app.add_middleware(
        CORSMiddleware,
        allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

app.include_router(api_router, prefix=settings.API_V1_STR)

# Frontend: Vue 3 Setup

# frontend/src/App.vue
<template>
  <div class="min-h-screen bg-gray-100">
    <nav class="bg-white shadow-sm">
      <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
        <div class="flex justify-between h-16">
          <div class="flex">
            <div class="flex-shrink-0 flex items-center">
              <h1 class="text-xl font-bold text-gray-900">Coin Counter</h1>
            </div>
          </div>
        </div>
      </div>
    </nav>

    <main class="max-w-7xl mx-auto py-6 sm:px-6 lg:px-8">
      <div class="px-4 py-6 sm:px-0">
        <router-view></router-view>
      </div>
    </main>
  </div>
</template>

<script setup>
import { onMounted } from 'vue'
import { useStore } from 'vuex'

const store = useStore()

onMounted(() => {
  // Initialize any required store state
})
</script>

# frontend/src/store/index.js
import { createStore } from 'vuex'

export default createStore({
  state: {
    analyses: [],
    currentAnalysis: null,
    loading: false,
    error: null
  },
  
  mutations: {
    SET_ANALYSES(state, analyses) {
      state.analyses = analyses
    },
    SET_CURRENT_ANALYSIS(state, analysis) {
      state.currentAnalysis = analysis
    },
    SET_LOADING(state, loading) {
      state.loading = loading
    },
    SET_ERROR(state, error) {
      state.error = error
    }
  },
  
  actions: {
    async fetchAnalyses({ commit }) {
      try {
        commit('SET_LOADING', true)
        const response = await api.getAnalyses()
        commit('SET_ANALYSES', response.data)
      } catch (error) {
        commit('SET_ERROR', error.message)
      } finally {
        commit('SET_LOADING', false)
      }
    },
    
    async createAnalysis({ commit }, imageData) {
      try {
        commit('SET_LOADING', true)
        const response = await api.analyzeImage(imageData)
        commit('SET_CURRENT_ANALYSIS', response.data)
        return response.data
      } catch (error) {
        commit('SET_ERROR', error.message)
        throw error
      } finally {
        commit('SET_LOADING', false)
      }
    }
  },
  
  getters: {
    recentAnalyses: state => {
      return state.analyses.slice(0, 5)
    },
    hasError: state => !!state.error
  }
})

# frontend/src/api/index.js
import axios from 'axios'

const api = axios.create({
  baseURL: import.meta.env.VITE_API_URL,
  headers: {
    'Content-Type': 'application/json'
  }
})

api.interceptors.request.use(config => {
  const apiKey = import.meta.env.VITE_API_KEY
  if (apiKey) {
    config.headers['X-API-Key'] = apiKey
  }
  return config
})

export default {
  async analyzeImage(formData) {
    return api.post('/analyze', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    })
  },
  
  async getAnalyses() {
    return api.get('/analyses')
  },
  
  async getAnalysis(id) {
    return api.get(`/analyses/${id}`)
  }
}

# docker-compose.yml
version: '3.8'

services:
  backend:
    build: ./backend
    ports:
      - "8000:8000"
    environment:
      - POSTGRES_SERVER=db
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=coin_counter
    depends_on:
      - db
    volumes:
      - ./backend:/app

  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
      - /app/node_modules
    environment:
      - VITE_API_URL=http://localhost:8000/api/v1

  db:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=coin_counter

volumes:
  postgres_data:

# backend/app/services/rekognition_service.py
import boto3
import logging
from typing import Dict, Any, List, Optional
from PIL import Image
import io
from botocore.exceptions import ClientError
from app.core.config import settings

logger = logging.getLogger(__name__)

class RekognitionService:
    def __init__(self):
        self.client = boto3.client(
            'rekognition',
            aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
            aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
            region_name=settings.AWS_REGION
        )
        self.s3_client = boto3.client(
            's3',
            aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
            aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
            region_name=settings.AWS_REGION
        )

    async def analyze_image(self, image_bytes: bytes) -> Dict[str, Any]:
        try:
            # Detectar objetos en la imagen
            response = self.client.detect_custom_labels(
                Image={'Bytes': image_bytes},
                ProjectVersionArn=settings.CUSTOM_LABELS_PROJECT_ARN,
                MinConfidence=settings.REKOGNITION_MIN_CONFIDENCE
            )

            # Procesar detecciones
            coins = self._process_detections(response['CustomLabels'])
            
            # Calcular dimensiones y posiciones relativas
            image = Image.open(io.BytesIO(image_bytes))
            dimensions = {'width': image.width, 'height': image.height}
            
            return {
                'coins': coins,
                'dimensions': dimensions,
                'confidence_score': self._calculate_average_confidence(coins),
                'detection_metadata': self._generate_metadata(response, dimensions)
            }

        except ClientError as e:
            logger.error(f"AWS Rekognition error: {str(e)}")
            raise
        except Exception as e:
            logger.error(f"Error analyzing image: {str(e)}")
            raise

    def _process_detections(
        self,
        detections: List[Dict[str, Any]]
    ) -> List[Dict[str, Any]]:
        processed_coins = []
        
        for detection in detections:
            if self._is_coin(detection):
                coin_info = {
                    'type': self._determine_coin_type(detection),
                    'value': self._get_coin_value(detection['Name']),
                    'confidence': detection['Confidence'],
                    'location': self._extract_location(detection['Geometry']),
                    'size': self._calculate_size(detection['Geometry']),
                    'rotation': self._calculate_rotation(detection.get('Pose', {}))
                }
                processed_coins.append(coin_info)

        return processed_coins

    def _is_coin(self, detection: Dict[str, Any]) -> bool:
        coin_labels = {'penny', 'nickel', 'dime', 'quarter', 'half_dollar', 'dollar'}
        return detection['Name'].lower() in coin_labels

    def _determine_coin_type(self, detection: Dict[str, Any]) -> str:
        # Mapeo de etiquetas a tipos de monedas
        coin_mapping = {
            'penny': '0.01',
            'nickel': '0.05',
            'dime': '0.10',
            'quarter': '0.25',
            'half_dollar': '0.50',
            'dollar': '1.00'
        }
        return coin_mapping.get(detection['Name'].lower(), 'unknown')

    def _get_coin_value(self, coin_type: str) -> float:
        value_mapping = {
            'penny': 0.01,
            'nickel': 0.05,
            'dime': 0.10,
            'quarter': 0.25,
            'half_dollar': 0.50,
            'dollar': 1.00
        }
        return value_mapping.get(coin_type.lower(), 0.0)

    def _extract_location(self, geometry: Dict[str, Any]) -> Dict[str, float]:
        bbox = geometry['BoundingBox']
        return {
            'x': bbox['Left'],
            'y': bbox['Top'],
            'width': bbox['Width'],
            'height': bbox['Height']
        }

    def _calculate_size(self, geometry: Dict[str, Any]) -> float:
        # Calcular área relativa del objeto
        return geometry['BoundingBox']['Width'] * geometry['BoundingBox']['Height']

    def _calculate_rotation(self, pose: Dict[str, Any]) -> Optional[float]:
        return pose.get('Rotation', 0.0)

    def _calculate_average_confidence(
        self,
        coins: List[Dict[str, Any]]
    ) -> float:
        if not coins:
            return 0.0
        return sum(coin['confidence'] for coin in coins) / len(coins)

    def _generate_metadata(
        self,
        response: Dict[str, Any],
        dimensions: Dict[str, int]
    ) -> Dict[str, Any]:
        return {
            'image_dimensions': dimensions,
            'detection_count': len(response['CustomLabels']),
            'timestamp': response['ResponseMetadata']['HTTPHeaders']['date'],
            'request_id': response['ResponseMetadata']['RequestId']
        }

# backend/app/services/coin_analyzer.py
from typing import Dict, Any, List
import numpy as np
from dataclasses import dataclass
from PIL import Image
import io

@dataclass
class CoinAnalysis:
    total_value: float
    coin_count: Dict[str, int]
    confidence_score: float
    dimensions: Dict[str, Any]
    detections: List[Dict[str, Any]]

class CoinAnalyzer:
    def __init__(self, rekognition_service):
        self.rekognition_service = rekognition_service
        self.size_thresholds = {
            'penny': {'min': 0.008, 'max': 0.012},
            'nickel': {'min': 0.012, 'max': 0.016},
            'dime': {'min': 0.007, 'max': 0.011},
            'quarter': {'min': 0.014, 'max': 0.018}
        }

    async def analyze_coins(self, image_bytes: bytes) -> CoinAnalysis:
        # Obtener detecciones de Rekognition
        rekognition_results = await self.rekognition_service.analyze_image(image_bytes)
        
        # Validar y refinar detecciones
        refined_detections = self._refine_detections(rekognition_results['coins'])
        
        # Calcular valor total
        total_value = sum(coin['value'] for coin in refined_detections)
        
        # Contar monedas por tipo
        coin_counts = self._count_coins(refined_detections)
        
        return CoinAnalysis(
            total_value=total_value,
            coin_count=coin_counts,
            confidence_score=rekognition_results['confidence_score'],
            dimensions=rekognition_results['dimensions'],
            detections=refined_detections
        )

    def _refine_detections(
        self,
        detections: List[Dict[str, Any]]
    ) -> List[Dict[str, Any]]:
        refined = []
        
        for detection in detections:
            # Validar por tamaño
            if self._validate_coin_size(detection):
                # Verificar solapamiento
                if not self._check_overlap(detection, refined):
                    refined.append(detection)
                    
        return refined

    def _validate_coin_size(self, detection: Dict[str, Any]) -> bool:
        coin_type = detection['type']
        size = detection['size']
        
        thresholds = self.size_thresholds.get(coin_type)
        if not thresholds:
            return True
            
        return thresholds['min'] <= size <= thresholds['max']

    def _check_overlap(
        self,
        detection: Dict[str, Any],
        existing_detections: List[Dict[str, Any]]
    ) -> bool:
        for existing in existing_detections:
            if self._calculate_iou(
                detection['location'],
                existing['location']
            ) > 0.3:  # 30% overlap threshold
                return True
        return False

    def _calculate_iou(
        self,
        box1: Dict[str, float],
        box2: Dict[str, float]
    ) -> float:
        # Calcular coordenadas de intersección
        x1 = max(box1['x'], box2['x'])
        y1 = max(box1['y'], box2['y'])
        x2 = min(box1['x'] + box1['width'], box2['x'] + box2['width'])
        y2 = min(box1['y'] + box1['height'], box2['y'] + box2['height'])
        
        # Calcular área de intersección
        if x2 <= x1 or y2 <= y1:
            return 0.0
            
        intersection = (x2 - x1) * (y2 - y1)
        
        # Calcular áreas individuales
        box1_area = box1['width'] * box1['height']
        box2_area = box2['width'] * box2['height']
        
        # Calcular IoU
        union = box1_area + box2_area - intersection
        return intersection / union if union > 0 else 0.0

    def _count_coins(self, detections: List[Dict[str, Any]]) -> Dict[str, int]:
        counts = {}
        for detection in detections:
            coin_type = detection['type']
            counts[coin_type] = counts.get(coin_type, 0) + 1
        return counts

# backend/app/api/endpoints/analysis.py
from fastapi import APIRouter, UploadFile, File, Depends
from sqlalchemy.orm import Session
from typing import Dict, Any
from app.services.rekognition_service import RekognitionService
from app.services.coin_analyzer import CoinAnalyzer
from app.db.deps import get_db
from app.models.analysis import Analysis

router = APIRouter()

@router.post("/analyze")
async def analyze_image(
    image: UploadFile = File(...),
    db: Session = Depends(get_db)
) -> Dict[str, Any]:
    # Validar imagen
    contents = await image.read()
    if len(contents) > settings.MAX_FILE_SIZE:
        raise HTTPException(400, "File too large")
        
    # Analizar imagen
    rekognition_service = RekognitionService()
    analyzer = CoinAnalyzer(rekognition_service)
    
    try:
        analysis = await analyzer.analyze_coins(contents)
        
        # Guardar resultados
        db_analysis = Analysis(
            image_path=f"uploads/{image.filename}",
            total_value=analysis.total_value,
            coin_details={
                'counts': analysis.coin_count,
                'detections': analysis.detections
            },
            confidence_score=analysis.confidence_score
        )
        
        db.add(db_analysis)
        db.commit()
        db.refresh(db_analysis)
        
        return {
            "id": db_analysis.id,
            "total_value": analysis.total_value,
            "coin_count": analysis.coin_count,
            "confidence_score": analysis.confidence_score,
            "detections": analysis.detections
        }
        
    except Exception as e:
        logger.error(f"Error analyzing image: {str(e)}")
        raise HTTPException(500, "Error analyzing image")

# backend/app/services/image_processor.py
import cv2
import numpy as np
from PIL import Image
import io
from typing import Tuple, Optional, Dict, Any
from dataclasses import dataclass
import logging
from app.core.config import settings

logger = logging.getLogger(__name__)

@dataclass
class ProcessedImage:
    image: np.ndarray
    enhanced: bool
    metadata: Dict[str, Any]
    quality_score: float

class ImageProcessor:
    def __init__(self):
        self.target_size = (800, 800)
        self.min_brightness = 0.3
        self.max_brightness = 0.85
        self.min_contrast = 0.4
        self.quality_threshold = 0.6

    async def process_image(
        self,
        image_bytes: bytes
    ) -> Tuple[bytes, Dict[str, Any]]:
        try:
            # Convertir bytes a imagen
            image = self._bytes_to_opencv(image_bytes)
            
            # Evaluar calidad
            quality_score = self._assess_quality(image)
            
            # Preprocesar imagen
            processed = await self._preprocess_image(
                image,
                quality_score < self.quality_threshold
            )
            
            # Convertir resultado a bytes
            output_bytes = self._opencv_to_bytes(processed.image)
            
            return output_bytes, {
                "quality_score": processed.quality_score,
                "enhanced": processed.enhanced,
                "metadata": processed.metadata
            }
            
        except Exception as e:
            logger.error(f"Error processing image: {str(e)}")
            raise

    def _bytes_to_opencv(self, image_bytes: bytes) -> np.ndarray:
        nparr = np.frombuffer(image_bytes, np.uint8)
        return cv2.imdecode(nparr, cv2.IMREAD_COLOR)

    def _opencv_to_bytes(self, image: np.ndarray) -> bytes:
        success, buffer = cv2.imencode('.jpg', image, [
            cv2.IMWRITE_JPEG_QUALITY, 95
        ])
        if not success:
            raise ValueError("Failed to encode image")
        return buffer.tobytes()

    async def _preprocess_image(
        self,
        image: np.ndarray,
        needs_enhancement: bool
    ) -> ProcessedImage:
        metadata = {}
        enhanced = False

        # Redimensionar si es necesario
        if max(image.shape[:2]) > max(self.target_size):
            image = self._resize_image(image)
            metadata["resized"] = True

        if needs_enhancement:
            # Mejorar brillo y contraste
            image = self._enhance_brightness_contrast(image)
            
            # Reducir ruido
            image = cv2.fastNlMeansDenoisingColored(image)
            
            # Mejorar nitidez
            image = self._sharpen_image(image)
            
            enhanced = True
            metadata["enhanced"] = True

        # Normalizar
        image = self._normalize_image(image)
        
        # Evaluar calidad final
        final_quality = self._assess_quality(image)

        return ProcessedImage(
            image=image,
            enhanced=enhanced,
            metadata=metadata,
            quality_score=final_quality
        )

    def _assess_quality(self, image: np.ndarray) -> float:
        scores = []
        
        # Evaluar brillo
        brightness = np.mean(image) / 255
        brightness_score = self._score_in_range(
            brightness,
            self.min_brightness,
            self.max_brightness
        )
        scores.append(brightness_score)
        
        # Evaluar contraste
        contrast = np.std(image) / 255
        contrast_score = self._score_in_range(
            contrast,
            self.min_contrast,
            1.0
        )
        scores.append(contrast_score)
        
        # Evaluar nitidez
        sharpness = self._calculate_sharpness(image)
        scores.append(sharpness)
        
        return np.mean(scores)

    def _score_in_range(
        self,
        value: float,
        min_val: float,
        max_val: float
    ) -> float:
        if value < min_val:
            return value / min_val
        if value > max_val:
            return 1 - ((value - max_val) / (1 - max_val))
        return 1.0

    def _calculate_sharpness(self, image: np.ndarray) -> float:
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
        # Normalizar a un rango 0-1
        return min(laplacian_var / 500, 1.0)

    def _resize_image(self, image: np.ndarray) -> np.ndarray:
        height, width = image.shape[:2]
        
        # Calcular nueva dimensión manteniendo aspecto
        if height > width:
            new_height = self.target_size[0]
            new_width = int(width * (new_height / height))
        else:
            new_width = self.target_size[1]
            new_height = int(height * (new_width / width))
            
        return cv2.resize(
            image,
            (new_width, new_height),
            interpolation=cv2.INTER_AREA
        )

    def _enhance_brightness_contrast(self, image: np.ndarray) -> np.ndarray:
        # Convertir a LAB
        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
        l, a, b = cv2.split(lab)
        
        # Aplicar CLAHE al canal L
        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
        l = clahe.apply(l)
        
        # Combinar canales
        enhanced_lab = cv2.merge([l, a, b])
        
        # Convertir de vuelta a BGR
        return cv2.cvtColor(enhanced_lab, cv2.COLOR_LAB2BGR)

    def _sharpen_image(self, image: np.ndarray) -> np.ndarray:
        kernel = np.array([
            [-1,-1,-1],
            [-1, 9,-1],
            [-1,-1,-1]
        ])
        return cv2.filter2D(image, -1, kernel)

    def _normalize_image(self, image: np.ndarray) -> np.ndarray:
        return cv2.normalize(
            image,
            None,
            alpha=0,
            beta=255,
            norm_type=cv2.NORM_MINMAX
        )

# backend/app/services/perspective_corrector.py
import cv2
import numpy as np
from typing import List, Tuple, Optional

class PerspectiveCorrector:
    def __init__(self):
        self.reference_diameter = 19.05  # Diámetro de penny en mm

    def correct_perspective(
        self,
        image: np.ndarray,
        coins: List[dict]
    ) -> Tuple[np.ndarray, List[dict]]:
        try:
            # Encontrar monedas circulares
            circles = self._find_circles(image)
            if not circles:
                return image, coins

            # Calcular transformación de perspectiva
            transform_matrix = self._calculate_perspective_transform(
                image,
                circles
            )
            
            if transform_matrix is None:
                return image, coins

            # Aplicar transformación
            height, width = image.shape[:2]
            corrected_image = cv2.warpPerspective(
                image,
                transform_matrix,
                (width, height)
            )

            # Actualizar coordenadas de monedas
            corrected_coins = self._update_coin_coordinates(
                coins,
                transform_matrix
            )

            return corrected_image, corrected_coins

        except Exception as e:
            logger.error(f"Error correcting perspective: {str(e)}")
            return image, coins

    def _find_circles(
        self,
        image: np.ndarray
    ) -> Optional[np.ndarray]:
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (9, 9), 2)
        
        circles = cv2.HoughCircles(
            blurred,
            cv2.HOUGH_GRADIENT,
            dp=1,
            minDist=50,
            param1=50,
            param2=30,
            minRadius=20,
            maxRadius=100
        )
        
        return circles[0] if circles is not None else None

    def _calculate_perspective_transform(
        self,
        image: np.ndarray,
        circles: np.ndarray
    ) -> Optional[np.ndarray]:
        # Seleccionar 4 círculos más grandes y distantes
        sorted_circles = sorted(
            circles,
            key=lambda x: x[2],
            reverse=True
        )[:4]
        
        if len(sorted_circles) < 4:
            return None

        # Convertir centros a puntos
        points = np.float32([circle[:2] for circle in sorted_circles])
        
        # Calcular rectángulo destino
        rect = cv2.minAreaRect(points)
        box = cv2.boxPoints(rect)
        box = np.int0(box)
        
        # Ordenar puntos
        src_points = self._order_points(points)
        dst_points = self._order_points(box.astype(np.float32))
        
        # Calcular matriz de transformación
        return cv2.getPerspectiveTransform(src_points, dst_points)

    def _order_points(self, points: np.ndarray) -> np.ndarray:
        # Ordenar puntos en orden: top-left, top-right, bottom-right, bottom-left
        rect = np.zeros((4, 2), dtype=np.float32)
        
        s = points.sum(axis=1)
        rect[0] = points[np.argmin(s)]  # top-left
        rect[2] = points[np.argmax(s)]  # bottom-right
        
        d = np.diff(points, axis=1)
        rect[1] = points[np.argmin(d)]  # top-right
        rect[3] = points[np.argmax(d)]  # bottom-left
        
        return rect

    def _update_coin_coordinates(
        self,
        coins: List[dict],
        transform_matrix: np.ndarray
    ) -> List[dict]:
        updated_coins = []
        
        for coin in coins:
            # Obtener coordenadas originales
            x = coin['location']['x']
            y = coin['location']['y']
            
            # Aplicar transformación
            point = np.array([[x, y]], dtype=np.float32)
            transformed_point = cv2.perspectiveTransform(
                point[None, :, :],
                transform_matrix
            )
            
            # Actualizar coordenadas
            coin_copy = coin.copy()
            coin_copy['location']['x'] = float(transformed_point[0][0][0])
            coin_copy['location']['y'] = float(transformed_point[0][0][1])
            
            updated_coins.append(coin_copy)
            
        return updated_coins

# backend/app/api/endpoints/analysis.py
from fastapi import APIRouter, UploadFile, File, Depends, HTTPException
from app.services.image_processor import ImageProcessor
from app.services.perspective_corrector import PerspectiveCorrector
from app.services.coin_analyzer import CoinAnalyzer
import asyncio

router = APIRouter()

@router.post("/analyze")
async def analyze_image(
    image: UploadFile = File(...),
    db: Session = Depends(get_db)
) -> Dict[str, Any]:
    try:
        contents = await image.read()
        
        # Procesar imagen
        image_processor = ImageProcessor()
        perspective_corrector = PerspectiveCorrector()
        analyzer = CoinAnalyzer(rekognition_service)
        
        # Realizar procesamiento en paralelo
        processed_image, processing_metadata = await image_processor.process_image(
            contents
        )
        
        # Analizar monedas
        analysis = await analyzer.analyze_coins(processed_image)
        
        # Corregir perspectiva si es necesario
        if processing_metadata['quality_score'] < 0.8:
            corrected_image, updated_detections = perspective_corrector.correct_perspective(
                cv2.imdecode(
                    np.frombuffer(processed_image, np.uint8),
                    cv2.IMREAD_COLOR
                ),
                analysis.detections
            )
            analysis.detections = updated_detections
        
        return {
            "total_value": analysis.total_value,
            "coin_count": analysis.coin_count,
            "confidence_score": analysis.confidence_score,
            "processing_metadata": processing_metadata,
            "detections": analysis.detections
        }
        
    except Exception as e:
        logger.error(f"Error processing image: {str(e)}")
        raise HTTPException(
            status_code=500,
            detail="Error processing image"
        )