Initial Docker configuration for Hugging Face

.gitattributes

@@ -0,0 +1 @@
+best.pt filter=lfs diff=lfs merge=lfs -text

DEPLOYMENT_HF.md

@@ -0,0 +1,60 @@
+# Documentation du Déploiement Backend sur Hugging Face (Docker)
+
+Cette documentation explique les modifications apportées au dossier `backend` pour permettre son déploiement sur Hugging Face Spaces en utilisant Docker.
+
+## 1. Fichiers Ajoutés
+
+### `Dockerfile`
+Le fichier `Dockerfile` est le cœur de la configuration Docker. Il effectue les actions suivantes :
+- Utilise une image de base Python 3.10.
+- Installe les dépendances système nécessaires à OpenCV (`libgl1-mesa-glx`, `libglib2.0-0`).
+- Installe les dépendances Python listées dans `requirements.txt`.
+- Configure le port par défaut sur `7860` (obligatoire pour Hugging Face Spaces).
+- Exécute les migrations de base de données au démarrage.
+
+### `README_HF.md`
+Ce fichier contient les métadonnées YAML nécessaires à Hugging Face pour identifier le SDK (Docker) et le port de l'application. 
+**Note :** Pour que Hugging Face reconnaisse ces métadonnées, ce contenu doit être présent dans le fichier `README.md` à la racine du dépôt sur Hugging Face.
+
+## 2. Modifications de Configuration
+
+### Port de l'Application
+Hugging Face Spaces expose l'application sur le port **7860**. Le `Dockerfile` est configuré pour lancer le serveur Django sur ce port spécifique :
+`python manage.py runserver 0.0.0.0:7860`
+
+### Gestion des Fichiers Statiques et Media
+Dans un environnement Docker éphémère comme Hugging Face Spaces :
+- Les fichiers media (images uploadées) seront stockés localement dans le conteneur mais seront perdus au redémarrage du Space.
+- Pour une utilisation en production réelle, un stockage externe (comme AWS S3 ou Google Cloud Storage) serait recommandé.
+
+## 3. Procédure d'Upload
+
+Pour uploader le backend sur votre Space `SATCAP-OCEANS_DOCKER` :
+
+1. **Initialiser Git (si ce n'est pas déjà fait)** :
+   ```bash
+   cd backend
+   git init
+   ```
+
+2. **Ajouter le remote Hugging Face** :
+   ```bash
+   git remote add hf https://huggingface.co/spaces/CosmoLABHub/SATCAP-OCEANS_DOCKER
+   ```
+
+3. **Préparer le README** :
+   Copiez le contenu de `README_HF.md` dans un fichier nommé `README.md` (Hugging Face a besoin du nom exact `README.md`).
+
+4. **Pousser vers Hugging Face** :
+   ```bash
+   git add .
+   git commit -m "Configuration Docker pour Hugging Face"
+   git push hf main --force
+   ```
+
+## 4. Utilisation comme API
+
+Une fois le Space "Running", l'URL de l'API sera :
+`https://cosmolabhub-satcap-oceans-docker.hf.space/api/detect/`
+
+Vous pouvez utiliser cette URL dans votre frontend pour envoyer des requêtes de détection.

Dockerfile

@@ -0,0 +1,37 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+ENV PORT 7860
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project
+COPY . /app/
+
+# Create media and static directories
+RUN mkdir -p /app/media /app/static
+
+# Run migrations (using SQLite for simplicity in Space)
+RUN python manage.py migrate
+
+# Expose the port Gradio/Hugging Face expects
+EXPOSE 7860
+
+# Start the application using Gunicorn or directly with manage.py
+# Hugging Face Spaces for Docker expects the app to run on port 7860
+CMD ["python", "manage.py", "runserver", "0.0.0.0:7860"]

README.md

@@ -0,0 +1,35 @@
+---
+title: SATCAP-OCEANS Backend
+emoji: 🚀
+colorFrom: blue
+colorTo: gray
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+# SATCAP-OCEANS Backend (API)
+
+Ce dépôt contient le backend Django du projet SATCAP-OCEANS, configuré pour être déployé sur Hugging Face Spaces via Docker.
+
+## Configuration pour Hugging Face
+
+Le backend a été modifié pour fonctionner dans un environnement Docker sur Hugging Face :
+- **Port** : L'application écoute sur le port `7860` (requis par Hugging Face).
+- **Base de données** : Utilise SQLite par défaut pour la portabilité.
+- **Dockerfile** : Inclus pour l'installation automatique des dépendances système (OpenCV, etc.) et Python.
+
+## Utilisation de l'API
+
+Une fois déployé, vous pouvez accéder à l'API via l'URL de votre Space.
+
+### Endpoints principaux :
+- `POST /api/detect/` : Envoyer une image pour détection.
+- `GET /api/history/` : Récupérer l'historique des détections.
+
+## Déploiement
+
+Pour mettre à jour ce Space :
+1. Ajoutez ce dépôt comme remote : `git remote add hf_docker https://huggingface.co/spaces/CosmoLABHub/SATCAP-OCEANS_DOCKER`
+2. Poussez les changements : `git push hf_docker main`

README_HF.md

@@ -0,0 +1,35 @@
+---
+title: SATCAP-OCEANS Backend
+emoji: 🚀
+colorFrom: blue
+colorTo: gray
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+# SATCAP-OCEANS Backend (API)
+
+Ce dépôt contient le backend Django du projet SATCAP-OCEANS, configuré pour être déployé sur Hugging Face Spaces via Docker.
+
+## Configuration pour Hugging Face
+
+Le backend a été modifié pour fonctionner dans un environnement Docker sur Hugging Face :
+- **Port** : L'application écoute sur le port `7860` (requis par Hugging Face).
+- **Base de données** : Utilise SQLite par défaut pour la portabilité.
+- **Dockerfile** : Inclus pour l'installation automatique des dépendances système (OpenCV, etc.) et Python.
+
+## Utilisation de l'API
+
+Une fois déployé, vous pouvez accéder à l'API via l'URL de votre Space.
+
+### Endpoints principaux :
+- `POST /api/detect/` : Envoyer une image pour détection.
+- `GET /api/history/` : Récupérer l'historique des détections.
+
+## Déploiement
+
+Pour mettre à jour ce Space :
+1. Ajoutez ce dépôt comme remote : `git remote add hf_docker https://huggingface.co/spaces/CosmoLABHub/SATCAP-OCEANS_DOCKER`
+2. Poussez les changements : `git push hf_docker main`

api/admin.py

@@ -0,0 +1,66 @@
+from django.contrib import admin
+from django.utils.html import format_html
+from .models import Detection
+from .utils import run_detection
+import json
+
+@admin.register(Detection)
+class DetectionAdmin(admin.ModelAdmin):
+    list_display = ('id', 'thumbnail', 'user', 'object_count', 'top_labels', 'created_at')
+    list_filter = ('created_at', 'user')
+    search_fields = ('results', 'user__username')
+    readonly_fields = ('thumbnail_large', 'formatted_results', 'created_at')
+    actions = ['re_analyze_detections']
+
+    def thumbnail(self, obj):
+        if obj.image:
+            return format_html('<img src="{}" style="width: 50px; height: auto; border-radius: 4px;" />', obj.image.url)
+        return "No Image"
+    thumbnail.short_description = 'Preview'
+
+    def thumbnail_large(self, obj):
+        if obj.image:
+            return format_html('<img src="{}" style="max-width: 100%; height: auto; border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);" />', obj.image.url)
+        return "No Image"
+    thumbnail_large.short_description = 'Image View'
+
+    def object_count(self, obj):
+        return len(obj.results) if obj.results else 0
+    object_count.short_description = 'Objects Found'
+
+    def top_labels(self, obj):
+        if not obj.results:
+            return "-"
+        labels = [item['label'] for item in obj.results]
+        unique_labels = list(set(labels))
+        return ", ".join(unique_labels[:3]) + ("..." if len(unique_labels) > 3 else "")
+    top_labels.short_description = 'Main Detections'
+
+    def formatted_results(self, obj):
+        return format_html('<pre style="background: #f4f4f4; padding: 10px; border-radius: 4px; max-height: 400px; overflow: auto;">{}</pre>', 
+                           json.dumps(obj.results, indent=2))
+    formatted_results.short_description = 'Analysis Data (JSON)'
+
+    @admin.action(description='Re-analyze selected detections with AI')
+    def re_analyze_detections(self, request, queryset):
+        count = 0
+        for obj in queryset:
+            if obj.image:
+                detections = run_detection(obj.image.path)
+                obj.results = detections
+                obj.save()
+                count += 1
+        self.message_user(request, f"Successfully re-analyzed {count} images.")
+
+    fieldsets = (
+        ('General Information', {
+            'fields': ('user', 'image', 'created_at')
+        }),
+        ('Visual Analysis', {
+            'fields': ('thumbnail_large',)
+        }),
+        ('Detailed Results', {
+            'fields': ('formatted_results',),
+            'classes': ('collapse',)
+        }),
+    )

api/migrations/0001_initial.py

@@ -0,0 +1,27 @@
+# Generated by Django 6.0 on 2026-01-03 17:13
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Detection',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('image', models.ImageField(upload_to='detections/')),
+                ('results', models.JSONField()),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+    ]

api/models.py

@@ -0,0 +1,12 @@
+from django.db import models
+from django.contrib.auth.models import User
+
+class Detection(models.Model):
+    user = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True)
+    image = models.ImageField(upload_to='detections/')
+    results = models.JSONField() # Stores the list of detected objects
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    def __str__(self):
+        count = len(self.results) if self.results else 0
+        return f"Detection {self.id} ({count} objects) - {self.created_at.strftime('%Y-%m-%d %H:%M')}"

api/serializers.py

@@ -0,0 +1,7 @@
+from rest_framework import serializers
+from .models import Detection
+
+class DetectionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Detection
+        fields = '__all__'

api/stats_views.py

@@ -0,0 +1,22 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from .models import Detection
+from django.db.models import Count
+from collections import Counter
+
+class StatsView(APIView):
+    def get(self, request):
+        detections = Detection.objects.all()
+        total_detections = detections.count()
+        
+        # Count labels across all detections
+        label_counts = Counter()
+        for det in detections:
+            for item in det.results:
+                label_counts[item['label']] += 1
+        
+        return Response({
+            "total_images_analyzed": total_detections,
+            "total_objects_detected": sum(label_counts.values()),
+            "label_distribution": dict(label_counts)
+        })

api/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+from .views import DetectView, DetectionHistoryView
+from .stats_views import StatsView
+
+urlpatterns = [
+    path('detect/', DetectView.as_view(), name='detect'),
+    path('history/', DetectionHistoryView.as_view(), name='history'),
+    path('stats/', StatsView.as_view(), name='stats'),
+]

api/utils.py

@@ -0,0 +1,60 @@
+import cv2
+import numpy as np
+import os
+from django.conf import settings
+from ultralytics import YOLO
+
+# Global model variable
+_model = None
+
+def get_model():
+    global _model
+    if _model is None:
+        MODEL_PATH = os.path.join(settings.BASE_DIR, 'best.pt')
+        try:
+            _model = YOLO(MODEL_PATH)
+        except Exception as e:
+            print(f"Error loading model: {e}")
+    return _model
+
+def run_detection(image_path):
+    """
+    Runs YOLO detection on an image file path and returns a list of detections.
+    """
+    model = get_model()
+    if model is None:
+        return []
+
+    img = cv2.imread(image_path)
+    if img is None:
+        return []
+
+    results = model(img)
+    detections = []
+    
+    for r in results:
+        boxes = r.boxes
+        for box in boxes:
+            # Get coordinates in percentage for the frontend
+            x_center, y_center, w, h = box.xywhn[0].tolist()
+            
+            x = (x_center - w/2) * 100
+            y = (y_center - h/2) * 100
+            width = w * 100
+            height = h * 100
+            
+            conf = float(box.conf[0])
+            cls = int(box.cls[0])
+            label = model.names[cls]
+            
+            detections.append({
+                "id": len(detections),
+                "x": x,
+                "y": y,
+                "width": width,
+                "height": height,
+                "label": label,
+                "confidence": conf * 100
+            })
+            
+    return detections

api/views.py

@@ -0,0 +1,49 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from .models import Detection
+from .serializers import DetectionSerializer
+from django.core.files.base import ContentFile
+import cv2
+import numpy as np
+from ultralytics import YOLO
+import os
+from django.conf import settings
+
+from .utils import run_detection
+
+class DetectView(APIView):
+    def post(self, request):
+        if 'image' not in request.FILES:
+            return Response({"error": "No image provided"}, status=status.HTTP_400_BAD_REQUEST)
+        
+        image_file = request.FILES['image']
+        
+        # Save temporarily to run detection or use the file directly
+        # For simplicity and consistency with the utility, we save the object first with empty results
+        # then run detection on the saved file path.
+        
+        detection_obj = Detection.objects.create(
+            image=image_file,
+            results=[],
+            user=request.user if request.user.is_authenticated else None
+        )
+        
+        # Run detection on the saved file
+        detections = run_detection(detection_obj.image.path)
+        
+        # Update results
+        detection_obj.results = detections
+        detection_obj.save()
+        
+        return Response(DetectionSerializer(detection_obj).data, status=status.HTTP_201_CREATED)
+
+class DetectionHistoryView(APIView):
+    def get(self, request):
+        if request.user.is_authenticated:
+            detections = Detection.objects.filter(user=request.user).order_by('-created_at')
+        else:
+            detections = Detection.objects.all().order_by('-created_at')[:10] # Last 10 for guests
+            
+        serializer = DetectionSerializer(detections, many=True)
+        return Response(serializer.data)

best.pt

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

manage.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+import os
+import sys
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'satcap_project.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,57 @@
+asgiref==3.11.0
+certifi==2025.11.12
+charset-normalizer==3.4.4
+contourpy==1.3.3
+cycler==0.12.1
+Django==6.0
+django-cors-headers==4.9.0
+djangorestframework==3.16.1
+filelock==3.20.2
+fonttools==4.61.1
+fsspec==2025.12.0
+idna==3.11
+Jinja2==3.1.6
+kiwisolver==1.4.9
+MarkupSafe==3.0.3
+matplotlib==3.10.8
+mpmath==1.3.0
+networkx==3.6.1
+numpy==2.2.6
+nvidia-cublas-cu12==12.8.4.1
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cufile-cu12==1.13.1.3
+nvidia-curand-cu12==10.3.9.90
+nvidia-cusolver-cu12==11.7.3.90
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nccl-cu12==2.27.5
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvshmem-cu12==3.3.20
+nvidia-nvtx-cu12==12.8.90
+opencv-python==4.12.0.88
+opencv-python-headless==4.12.0.88
+packaging==25.0
+pillow==12.1.0
+polars==1.36.1
+polars-runtime-32==1.36.1
+psutil==7.2.1
+pyparsing==3.3.1
+python-dateutil==2.9.0.post0
+PyYAML==6.0.3
+requests==2.32.5
+scipy==1.16.3
+setuptools==80.9.0
+six==1.17.0
+sqlparse==0.5.5
+sympy==1.14.0
+torch==2.9.1
+torchvision==0.24.1
+triton==3.5.1
+typing_extensions==4.15.0
+ultralytics==8.3.246
+ultralytics-thop==2.0.18
+urllib3==2.6.2

satcap_project/settings.py

@@ -0,0 +1,92 @@
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+SECRET_KEY = 'django-insecure-satcap-oceans-secret-key'
+
+DEBUG = True
+
+ALLOWED_HOSTS = ['*']
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'rest_framework',
+    'corsheaders',
+    'api',
+]
+
+MIDDLEWARE = [
+    'corsheaders.middleware.CorsMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'satcap_project.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'satcap_project.wsgi.application'
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_TZ = True
+
+STATIC_URL = 'static/'
+
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+CORS_ALLOW_ALL_ORIGINS = True # For development
+
+MEDIA_URL = '/media/'
+MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

satcap_project/urls.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+from django.urls import path, include
+from django.conf import settings
+from django.conf.urls.static import static
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('api/', include('api.urls')),
+] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

satcap_project/wsgi.py

@@ -0,0 +1,4 @@
+import os
+from django.core.wsgi import get_wsgi_application
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'satcap_project.settings')
+application = get_wsgi_application()