API : Python SDK

Le Chloros Python SDK fournit un accès programmatique au moteur de traitement d'images Chloros, permettant l'automatisation, la personnalisation des flux de travail et une intégration transparente avec vos applications Python et vos pipelines de recherche.

Principales fonctionnalités

• 🐍 Python natif - API propre et pythonesque pour le traitement d'images

• 🔧 Accès complet à API - Contrôle total du traitement Chloros

• 🚀 Automatisation - Créez des flux de travail de traitement par lots personnalisés

• 🔗 Intégration - Intégrez Chloros dans les applications Python existantes

• 📊 Prêt pour la recherche - Parfait pour les pipelines d'analyse scientifique

• ⚡ Traitement parallèle - S'adapte à vos cœurs de processeur (Chloros+)

Configuration requise

Configuration requise	Détails
Chloros Desktop	Doit être installé localement
Licence	Chloros+ (forfait payant requis)
Système d'exploitation	Windows 10/11 (64 bits)
Python	Python 3.7 ou supérieur
Mémoire	8 Go de RAM minimum (16 Go recommandés)
Internet	Requis pour l'activation de la licence

Exigences en matière de licence : Python SDK nécessite un abonnement payant à Chloros+ pour accéder à API. Les forfaits standard (gratuits) ne donnent pas accès à API/SDK. Rendez-vous sur https://cloud.mapir.camera/pricing pour passer à un forfait supérieur.

Démarrage rapide

Installation

Installez via pip :

pip install chloros-sdk

Première configuration : avant d'utiliser SDK, activez votre licence Chloros+ en ouvrant Chloros, Chloros (navigateur) ou Chloros CLI et en vous connectant avec vos identifiants. Cette opération ne doit être effectuée qu'une seule fois.

Utilisation de base

Traitez un dossier en quelques lignes :

from chloros_sdk import process_folder

# One-line processing
results = process_folder("C:\\DroneImages\\Flight001")

Contrôle total

Pour les workflows avancés :

from chloros_sdk import ChlorosLocal

# Initialize SDK
chloros = ChlorosLocal()

# Create project
chloros.create_project("MyProject", camera="Survey3N_RGN")

# Import images
chloros.import_images("C:\\DroneImages\\Flight001")

# Configure settings
chloros.configure(
    vignette_correction=True,
    reflectance_calibration=True,
    indices=["NDVI", "NDRE", "GNDVI"]
)

# Process images
chloros.process(mode="parallel", wait=True)

---

Guide d'installation

Conditions préalables

Avant d'installer SDK, assurez-vous que vous disposez des éléments suivants :

1. Chloros Desktop installé (télécharger)

2. Python 3.7+ installé (python.org)

3. Licence Chloros+ active (mise à niveau)

Installation via pip

Installation standard :

pip install chloros-sdk

Avec prise en charge du suivi de la progression :

pip install chloros-sdk[progress]

Installation de développement :

pip install chloros-sdk[dev]

Vérification de l'installation

Vérifiez que SDK est correctement installé :

import chloros_sdk
print(f"Chloros SDK version: {chloros_sdk.__version__}")

---

Première configuration

Activation de la licence

Le SDK utilise la même licence que les Chloros, Chloros (navigateur) et Chloros CLI. Activez-la une fois via l'interface graphique ou CLI :

1. Ouvrez Chloros ou Chloros (navigateur)et connectez-vous à l'onglet Utilisateur . Ou ouvrezCLI.

2. Entrez vos identifiants Chloros+ et connectez-vous

3. La licence est mise en cache localement (elle persiste après les redémarrages)

Configuration unique : après vous être connecté via l'interface graphique ou CLI, SDK utilise automatiquement la licence mise en cache. Aucune authentification supplémentaire n'est nécessaire !

Déconnexion : les utilisateurs SDK peuvent effacer les informations d'identification mises en cache par programmation à l'aide de la méthode logout(). Voir la méthode logout() dans la référence API.

Tester la connexion

Vérifiez que SDK peut se connecter à Chloros :

from chloros_sdk import ChlorosLocal

# Initialize SDK (auto-starts backend if needed)
chloros = ChlorosLocal()

# Check status
status = chloros.get_status()
print(f"Backend running: {status['running']}")

---

Référence API

Classe ChlorosLocal

Classe principale pour le traitement d'images Chloros local.

Constructeur

ChlorosLocal(
    api_url="http://localhost:5000",     # Backend URL
    auto_start_backend=True,             # Auto-start backend if not running
    backend_exe=None,                    # Backend path (auto-detected)
    timeout=30,                          # Request timeout (seconds)
    backend_startup_timeout=60           # Backend startup timeout
)

Paramètres :

Paramètre	Type	Valeur par défaut	Description
api_url	str	"http://localhost:5000"	URL du backend local Chloros
auto_start_backend	bool	True	Démarrer automatiquement le backend si nécessaire
backend_exe	str	None (détection automatique)	Chemin d'accès à l'exécutable du backend
timeout	int	30	Délai d'expiration de la requête en secondes
backend_startup_timeout	int	60	Délai d'expiration pour le démarrage du backend (en secondes)

Exemples :

# Default (auto-start backend)
chloros = ChlorosLocal()

# Connect to running backend
chloros = ChlorosLocal(auto_start_backend=False)

# Custom backend path
chloros = ChlorosLocal(backend_exe="C:/Custom/chloros-backend.exe")

# Custom timeout
chloros = ChlorosLocal(timeout=60)

---

Méthodes

create_project(project_name, camera=None)

Créer un nouveau projet Chloros.

Paramètres :

Paramètre	Type	Obligatoire	Description
project_name	str	Oui	Nom du projet
camera	str	Non	Modèle de caméra (par exemple, « Survey3N_RGN », « Survey3W_OCN »)

Renvoie : dict - Réponse de création de projetExemple :

# Basic project
chloros.create_project("DroneField_A")

# With camera template
chloros.create_project("DroneField_A", camera="Survey3N_RGN")

---

import_images(folder_path, recursive=False)

Importe les images d'un dossier.

Paramètres :

Paramètre	Type	Obligatoire	Description
folder_path	str/Path	Oui	Chemin d'accès au dossier contenant les images
recursive	bool	Non	Rechercher dans les sous-dossiers (par défaut : Faux)

Renvoie : dict - Résultats de l'importation avec nombre de fichiersExemple :

# Import from folder
chloros.import_images("C:\\DroneImages\\Flight001")

# Import recursively
chloros.import_images("C:\\DroneImages", recursive=True)

---

configure(**settings)

Configure les paramètres de traitement.

Paramètres :

Paramètre	Type	Par défaut	Description
debayer	str	« Haute qualité (plus rapide) »	Méthode de débayérisation
vignette_correction	bool	True	Activer la correction du vignettage
reflectance_calibration	bool	True	Activer l'étalonnage de la réflectance
indices	liste	None	Indices de végétation à calculer
export_format	str	« TIFF (16 bits) »	Format de sortie
ppk	bool	False	Activer les corrections PPK
custom_settings	dict	None	Paramètres personnalisés avancés

Formats d'exportation :

• "TIFF (16-bit)" - Recommandé pour le SIG/la photogrammétrie

• "TIFF (32-bit, Percent)" - Analyse scientifique

• "PNG (8-bit)" - Inspection visuelle

• "JPG (8-bit)" - Sortie compressée

**Indices disponibles :**NDVI, NDRE, GNDVI, OSAVI, CIG, EVI, SAVI, MSAVI, MTVI2, et plus encore.Exemple :

# Basic configuration
chloros.configure(
    vignette_correction=True,
    reflectance_calibration=True,
    indices=["NDVI", "NDRE"]
)

# Advanced configuration
chloros.configure(
    debayer="High Quality (Faster)",
    vignette_correction=True,
    reflectance_calibration=True,
    ppk=True,
    export_format="TIFF (32-bit, Percent)",
    indices=["NDVI", "NDRE", "GNDVI", "OSAVI", "CIG"]
)

---

process(mode="parallel", wait=True, progress_callback=None)

Traiter les images du projet.

Paramètres :

Paramètre	Type	Par défaut	Description
mode	str	"parallel"	Mode de traitement : « parallel » ou « serial »
wait	bool	True	Attendre la fin
progress_callback	callable	None	Fonction de rappel de progression(progress, msg)
poll_interval	float	2.0	Intervalle d'interrogation pour la progression (secondes)

Renvoie : dict - Résultats du traitement

Mode parallèle : nécessite une licence Chloros+. S'adapte automatiquement à vos cœurs de processeur (jusqu'à 16 processeurs).

Exemple :

# Simple processing
results = chloros.process()

# With progress monitoring
def show_progress(progress, message):
    print(f"[{progress}%] {message}")

chloros.process(
    mode="parallel",
    progress_callback=show_progress,
    wait=True
)

# Fire-and-forget (non-blocking)
chloros.process(wait=False)

---

get_config()

Obtient la configuration actuelle du projet.

Renvoie : dict - Configuration actuelle du projetExemple :

config = chloros.get_config()
print(config['Project Settings'])

---

get_status()

Récupère les informations sur l'état du backend.

Renvoie : dict - État du backendExemple :

status = chloros.get_status()
print(f"Running: {status['running']}")
print(f"URL: {status['url']}")

---

shutdown_backend()

Arrête le backend (s'il a été démarré par SDK).

Exemple :

chloros.shutdown_backend()

---

logout()

Efface les informations d'identification mises en cache du système local.

Description :

Déconnexion programmatique en supprimant les informations d'identification mises en cache. Ceci est utile pour :

• Passer d'un compte Chloros+ à un autre

• Effacer les informations d'identification dans les environnements automatisés

• Des raisons de sécurité (par exemple, supprimer les informations d'identification avant la désinstallation)

Renvoie : dict - Résultat de l'opération de déconnexionExemple :

from chloros_sdk import ChlorosLocal

# Initialize SDK
chloros = ChlorosLocal()

# Clear cached credentials
result = chloros.logout()
print(f"Logout successful: {result}")

# After logout, login required via GUI/CLI/Browser before next SDK use

Réauthentification requise : après avoir appelé logout(), vous devez vous reconnecter via Chloros, Chloros (navigateur) ou Chloros CLI avant d'utiliser SDK.

---

Fonctions pratiques

process_folder(folder_path, **options)

Fonction pratique d'une ligne pour traiter un dossier.

Paramètres :

Paramètre	Type	Par défaut	Description
folder_path	str/Path	Obligatoire	Chemin d'accès au dossier contenant les images
project_name	str	Généré automatiquement	Nom du projet
camera	str	None	Modèle de caméra
indices	list	["NDVI"]	Indices à calculer
vignette_correction	bool	True	Activer la correction du vignettage
reflectance_calibration	bool	True	Activer l'étalonnage de la réflectance
export_format	str	« TIFF (16 bits) »	Format de sortie
mode	str	"parallel"	Mode de traitement
progress_callback	callable	None	Rappel de progression

Renvoie : dict - Résultats du traitementExemple :

from chloros_sdk import process_folder

# Simple one-liner
results = process_folder("C:\\DroneImages\\Flight001")

# With custom settings
results = process_folder(
    "C:\\DroneImages\\Flight001",
    project_name="Field_A_Survey",
    camera="Survey3N_RGN",
    indices=["NDVI", "NDRE", "GNDVI"],
    mode="parallel"
)

# With progress monitoring
def show_progress(progress, message):
    print(f"[{progress}%] {message}")

results = process_folder(
    "C:\\DroneImages\\Flight001",
    progress_callback=show_progress
)

---

Prise en charge du gestionnaire de contexte

Le SDK prend en charge les gestionnaires de contexte pour le nettoyage automatique :

from chloros_sdk import ChlorosLocal

# Auto-cleanup when done
with ChlorosLocal() as chloros:
    chloros.create_project("MyProject")
    chloros.import_images("C:\\Images")
    chloros.configure(indices=["NDVI"])
    chloros.process()
# Backend automatically shut down here

---

Exemples complets

Exemple 1 : traitement de base

Traiter un dossier avec les paramètres par défaut :

from chloros_sdk import process_folder

# Process with default settings
results = process_folder("C:\\Datasets\\Field_A_2025_01_15")

print(f"Processing complete: {results}")

---

Exemple 2 : flux de travail personnalisé

Contrôle total du pipeline de traitement :

from chloros_sdk import ChlorosLocal

# Initialize SDK
chloros = ChlorosLocal()

# Create project with camera template
chloros.create_project("Research_Plot_A", camera="Survey3N_RGN")

# Import images
import_results = chloros.import_images("C:\\Research\\PlotA")
print(f"Imported {len(import_results.get('files', []))} images")

# Configure advanced settings
chloros.configure(
    debayer="High Quality (Faster)",
    vignette_correction=True,
    reflectance_calibration=True,
    ppk=False,
    export_format="TIFF (16-bit)",
    indices=["NDVI", "NDRE", "GNDVI", "OSAVI"]
)

# Process with progress monitoring
def show_progress(progress, message):
    print(f"Progress: {progress}% - {message}")

chloros.process(
    mode="parallel",
    progress_callback=show_progress,
    wait=True
)

print("Processing complete!")

---

Exemple 3 : traitement par lots de plusieurs dossiers

Traiter plusieurs ensembles de données de vol :

from chloros_sdk import ChlorosLocal
from pathlib import Path

# Initialize SDK once
chloros = ChlorosLocal()

# List of flight folders
flights = [
    "C:\\Datasets\\Flight_001",
    "C:\\Datasets\\Flight_002",
    "C:\\Datasets\\Flight_003"
]

for flight_path in flights:
    flight_name = Path(flight_path).name
    print(f"\n{'='*60}")
    print(f"Processing: {flight_name}")
    print('='*60)
    
    try:
        # Create project
        chloros.create_project(flight_name, camera="Survey3N_RGN")
        
        # Import images
        chloros.import_images(flight_path)
        
        # Configure
        chloros.configure(
            vignette_correction=True,
            reflectance_calibration=True,
            indices=["NDVI", "NDRE", "GNDVI"]
        )
        
        # Process
        chloros.process(mode="parallel", wait=True)
        
        print(f"✓ {flight_name} completed successfully")
    
    except Exception as e:
        print(f"✗ {flight_name} failed: {e}")

print("\n" + "="*60)
print("All flights processed!")

---

Exemple 4 : intégration du pipeline de recherche

Intégrer Chloros à l'analyse des données :

from chloros_sdk import ChlorosLocal
import pandas as pd
import matplotlib.pyplot as plt

# Initialize Chloros
chloros = ChlorosLocal()

# Field survey data
surveys = [
    {"name": "Plot_A", "folder": "C:\\Research\\PlotA", "biomass": 4500},
    {"name": "Plot_B", "folder": "C:\\Research\\PlotB", "biomass": 3800},
    {"name": "Plot_C", "folder": "C:\\Research\\PlotC", "biomass": 5200}
]

results = []

for survey in surveys:
    # Process with Chloros
    chloros.create_project(survey['name'])
    chloros.import_images(survey['folder'])
    chloros.configure(indices=["NDVI", "NDRE"])
    chloros.process(mode="parallel", wait=True)
    
    # Get results
    config = chloros.get_config()
    
    # Extract NDVI values (example - adjust based on your needs)
    # In real implementation, you would read the processed TIFF files
    
    results.append({
        'plot': survey['name'],
        'biomass': survey['biomass'],
        # Add your NDVI extraction here
    })

# Statistical analysis
df = pd.DataFrame(results)
print("\nResults:")
print(df)

# Create correlation plot
# plt.scatter(df['ndvi'], df['biomass'])
# plt.xlabel('NDVI')
# plt.ylabel('Biomass (kg/ha)')
# plt.title('NDVI vs Biomass Correlation')
# plt.show()

---

Exemple 5 : Suivi personnalisé de la progression

Suivi avancé de la progression avec journalisation :

from chloros_sdk import ChlorosLocal
from datetime import datetime
import logging

# Setup logging
logging.basicConfig(
    filename=f'processing_{datetime.now():%Y%m%d_%H%M%S}.log',
    level=logging.INFO,
    format='%(asctime)s - %(message)s'
)

# Progress callback with logging
def log_progress(progress, message):
    log_msg = f"[{progress}%] {message}"
    logging.info(log_msg)
    print(log_msg)

# Process with logging
chloros = ChlorosLocal()
chloros.create_project("LoggedProcess")
chloros.import_images("C:\\DroneImages")
chloros.configure(indices=["NDVI", "NDRE"])

logging.info("Starting processing...")
chloros.process(
    mode="parallel",
    progress_callback=log_progress,
    wait=True
)
logging.info("Processing complete!")

---

Exemple 6 : Gestion des erreurs

Gestion robuste des erreurs pour une utilisation en production :

from chloros_sdk import ChlorosLocal
from chloros_sdk.exceptions import (
    ChlorosError,
    ChlorosBackendError,
    ChlorosLicenseError,
    ChlorosProcessingError
)

def process_safely(folder_path):
    """Process with comprehensive error handling"""
    try:
        with ChlorosLocal() as chloros:
            chloros.create_project("SafeProcess")
            chloros.import_images(folder_path)
            chloros.configure(indices=["NDVI"])
            chloros.process()
            
        return True, "Success"
    
    except ChlorosLicenseError as e:
        return False, f"License error: {e}. Upgrade to Chloros+ at cloud.mapir.camera/pricing"
    
    except ChlorosBackendError as e:
        return False, f"Backend error: {e}. Ensure Chloros Desktop is installed."
    
    except ChlorosProcessingError as e:
        return False, f"Processing error: {e}"
    
    except FileNotFoundError as e:
        return False, f"Folder not found: {e}"
    
    except ChlorosError as e:
        return False, f"Chloros error: {e}"
    
    except Exception as e:
        return False, f"Unexpected error: {e}"

# Use the safe function
success, message = process_safely("C:\\DroneImages\\Flight001")
if success:
    print(f"✓ {message}")
else:
    print(f"✗ {message}")

---

Exemple 7 : Gestion des comptes et déconnexion

Gérer les identifiants par programmation :

from chloros_sdk import ChlorosLocal

def switch_account():
    """Clear credentials to switch to a different account"""
    try:
        chloros = ChlorosLocal()
        
        # Clear current credentials
        result = chloros.logout()
        print("✓ Credentials cleared successfully")
        print("Please log in with new account via Chloros, Chloros (Browser), or CLI")
        
        return True
    
    except Exception as e:
        print(f"✗ Logout failed: {e}")
        return False

def secure_cleanup():
    """Remove credentials for security purposes"""
    try:
        chloros = ChlorosLocal()
        chloros.logout()
        print("✓ Credentials removed for security")
        
    except Exception as e:
        print(f"Warning: Cleanup error: {e}")

# Switch accounts
if switch_account():
    print("\nRe-authenticate via Chloros GUI/CLI/Browser before next SDK use")

# Or perform secure cleanup
# secure_cleanup()

---

Exemple 8 : Outil en ligne de commande

Créez un outil CLI personnalisé avec SDK :

#!/usr/bin/env python
"""
Custom Chloros CLI Tool
Process multiple folders from command line
"""

import sys
import argparse
from pathlib import Path
from chloros_sdk import process_folder

def main():
    parser = argparse.ArgumentParser(description='Custom Chloros Processor')
    parser.add_argument('folders', nargs='+', help='Folders to process')
    parser.add_argument('--indices', nargs='+', default=['NDVI'],
                       help='Indices to calculate (default: NDVI)')
    parser.add_argument('--camera', default=None,
                       help='Camera template')
    parser.add_argument('--format', default='TIFF (16-bit)',
                       help='Export format')
    parser.add_argument('--logout', action='store_true',
                       help='Clear cached credentials before processing')
    
    args = parser.parse_args()
    
    # Handle logout if requested
    if args.logout:
        from chloros_sdk import ChlorosLocal
        chloros = ChlorosLocal()
        chloros.logout()
        print("Credentials cleared. Please re-login via Chloros GUI/CLI/Browser.")
        return 0
    
    successful = []
    failed = []
    
    for folder in args.folders:
        folder_path = Path(folder)
        
        if not folder_path.exists():
            print(f"✗ Skipping {folder}: not found")
            failed.append(folder)
            continue
        
        print(f"\nProcessing: {folder_path.name}...")
        
        try:
            process_folder(
                folder_path,
                camera=args.camera,
                indices=args.indices,
                export_format=args.format
            )
            print(f"✓ {folder_path.name} complete")
            successful.append(folder)
        
        except Exception as e:
            print(f"✗ {folder_path.name} failed: {e}")
            failed.append(folder)
    
    # Summary
    print(f"\n{'='*60}")
    print(f"Summary: {len(successful)} successful, {len(failed)} failed")
    
    return 0 if not failed else 1

if __name__ == '__main__':
    sys.exit(main())

Utilisation :

# Process multiple folders
python my_processor.py "C:\Flight001" "C:\Flight002" --indices NDVI NDRE GNDVI

# Clear cached credentials
python my_processor.py --logout

---

Gestion des exceptions

SDK fournit des classes d'exception spécifiques pour différents types d'erreurs :

Hiérarchie des exceptions

ChlorosError                    # Base exception
├── ChlorosBackendError        # Backend startup/connection issues
├── ChlorosLicenseError        # License validation issues
├── ChlorosConnectionError     # Network/connection failures
├── ChlorosProcessingError     # Image processing failures
├── ChlorosAuthenticationError # Authentication failures
└── ChlorosConfigurationError  # Configuration errors

Exemples d'exceptions

from chloros_sdk import ChlorosLocal
from chloros_sdk.exceptions import *

try:
    chloros = ChlorosLocal()
    chloros.process()

except ChlorosLicenseError:
    print("Chloros+ license required. Upgrade at cloud.mapir.camera/pricing")

except ChlorosBackendError:
    print("Backend failed to start. Ensure Chloros Desktop is installed.")

except ChlorosProcessingError as e:
    print(f"Processing failed: {e}")

except ChlorosError as e:
    print(f"General Chloros error: {e}")

---

Sujets avancés

Configuration personnalisée du backend

Utilisez un emplacement ou une configuration de backend personnalisé :

chloros = ChlorosLocal(
    backend_exe="C:\\Custom\\chloros-backend.exe",
    api_url="http://localhost:5001",  # Custom port
    timeout=60,                        # Longer timeout
    backend_startup_timeout=120        # 2 minutes startup
)

Traitement non bloquant

Lancez le traitement et poursuivez d'autres tâches :

# Start processing (non-blocking)
chloros.process(wait=False)

# Do other work here...
print("Processing started in background...")

# Check status later
import time
while True:
    status = chloros.get_config()
    if status.get('processing_complete'):
        break
    time.sleep(5)

print("Processing complete!")

Gestion de la mémoire

Pour les ensembles de données volumineux, effectuez le traitement par lots :

from pathlib import Path

base_folder = Path("C:\\LargeDataset")
batch_size = 100

# Get all image files
images = list(base_folder.glob("*.RAW"))

# Process in batches
for i in range(0, len(images), batch_size):
    batch = images[i:i+batch_size]
    batch_folder = base_folder / f"batch_{i//batch_size}"
    
    # Create batch folder and move images
    # ... (implementation details)
    
    # Process batch
    process_folder(batch_folder)

---

Dépannage

Le backend ne démarre pas

Problème : SDK ne parvient pas à démarrer le backend.Solutions :

1. Vérifiez que Chloros Desktop est installé :

import os
backend_path = r"C:\Program Files\MAPIR\Chloros\resources\backend\chloros-backend.exe"
print(f"Backend exists: {os.path.exists(backend_path)}")

1. Vérifiez que le pare-feu Windows ne bloque pas le programme.

2. Essayez le chemin d'accès manuel au backend :

chloros = ChlorosLocal(backend_exe="C:\\Path\\To\\chloros-backend.exe")

---

Licence non détectéeProblème : SDK signale l'absence de licence.Solutions :

1. Ouvrez Chloros, Chloros (navigateur) ou Chloros CLI et connectez-vous.

2. Vérifiez que la licence est mise en cache :

from pathlib import Path
import os

# Check cache location (Windows)
cache_path = Path(os.getenv('APPDATA')) / 'Chloros' / 'cache'
print(f"Cache exists: {cache_path.exists()}")

1. Si vous rencontrez des problèmes d'identification, effacez les informations d'identification mises en cache et reconnectez-vous :

from chloros_sdk import ChlorosLocal

# Clear cached credentials
chloros = ChlorosLocal()
chloros.logout()

# Then login again via Chloros, Chloros (Browser), or Chloros CLI

1. Contactez l'assistance : [e-mail]

---

Erreurs d'importationProblème : ModuleNotFoundError: No module named 'chloros_sdk'Solutions :

# Verify installation
pip show chloros-sdk

# Reinstall if needed
pip uninstall chloros-sdk
pip install chloros-sdk

# Check Python environment
python -c "import sys; print(sys.path)"

---

Délai d'attente de traitementProblème : Délai d'attente de traitementSolutions :

1. Augmentez le délai d'attente :

chloros = ChlorosLocal(timeout=120)  # 2 minutes

1. Traitez des lots plus petits

2. Vérifiez l'espace disque disponible

3. Surveillez les ressources système

---

Port déjà utiliséProblème : le port 5000 du backend est occupé.Solutions :

# Use different port
chloros = ChlorosLocal(api_url="http://localhost:5001")

Ou recherchez et fermez le processus en conflit :

# PowerShell
Get-NetTCPConnection -LocalPort 5000

---

Conseils de performance

Optimiser la vitesse de traitement

1. Utilisez le mode parallèle (nécessite Chloros+)

chloros.process(mode="parallel")  # Up to 16 workers

1. Réduisez la résolution de sortie (si cela est acceptable)

chloros.configure(export_format="PNG (8-bit)")  # Faster than TIFF

1. Désactivez les index inutiles

# Only calculate needed indices
chloros.configure(indices=["NDVI"])  # Not all indices

1. Traitez sur SSD (et non sur HDD)***

Optimisation de la mémoire

Pour les ensembles de données volumineux :

# Process in batches instead of all at once
# See "Memory Management" in Advanced Topics

---

Traitement en arrière-plan

Libérez Python pour d'autres tâches :

chloros.process(wait=False)  # Non-blocking

# Continue with other work
# ...

---

Exemples d'intégration

Intégration Django

# views.py
from django.http import JsonResponse
from chloros_sdk import process_folder

def process_images_view(request):
    if request.method == 'POST':
        folder_path = request.POST.get('folder_path')
        
        try:
            results = process_folder(folder_path)
            return JsonResponse({'success': True, 'results': results})
        except Exception as e:
            return JsonResponse({'success': False, 'error': str(e)})

Flask API

# app.py
from flask import Flask, request, jsonify
from chloros_sdk import process_folder

app = Flask(__name__)

@app.route('/api/process', methods=['POST'])
def process():
    data = request.get_json()
    folder_path = data.get('folder_path')
    
    try:
        results = process_folder(folder_path)
        return jsonify({'success': True, 'results': results})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

if __name__ == '__main__':
    app.run()

Jupyter Notebook

# notebook.ipynb
from chloros_sdk import ChlorosLocal
import matplotlib.pyplot as plt

# Initialize
chloros = ChlorosLocal()

# Process
chloros.create_project("JupyterTest")
chloros.import_images("C:\\Data")
chloros.configure(indices=["NDVI"])

# Progress in notebook
from IPython.display import clear_output

def notebook_progress(progress, message):
    clear_output(wait=True)
    print(f"Progress: {progress}%")
    print(message)

chloros.process(progress_callback=notebook_progress)

# Visualize results
# ... (your visualization code)

---

FAQ

Q : Le SDK nécessite-t-il une connexion Internet ?

R : Uniquement pour l'activation initiale de la licence. Après vous être connecté via Chloros, Chloros (navigateur) ou Chloros CLI, la licence est mise en cache localement et fonctionne hors ligne pendant 30 jours.***

Q : Puis-je utiliser SDK sur un serveur sans interface graphique ?R : Oui ! Configuration requise :

• Windows Server 2016 ou version ultérieure

• Chloros installé (une seule fois)

• Licence activée sur n'importe quelle machine (licence mise en cache copiée sur le serveur)

---

Q : Quelle est la différence entre Desktop, CLI et SDK ?

Fonctionnalité	Interface graphique Desktop	Ligne de commande CLI	Python SDK
Interface	Point-clic	Commande	Python API
Idéal pour	Travail visuel	Scripting	Intégration
Automatisation	Limitée	Bonne	Excellente
Flexibilité	Basique	Bonne	Maximale
Licence	Chloros+	Chloros+	Chloros+

Q : Puis-je distribuer des applications créées avec SDK ?R : Le code SDK peut être intégré à vos applications, mais :

• Les utilisateurs finaux doivent avoir installé Chloros.

• Les utilisateurs finaux doivent disposer de licences Chloros+ actives.

• La distribution commerciale nécessite une licence OEM.

Contactez [e-mail] pour toute question relative aux licences OEM.

---

Q : Comment mettre à jour SDK ?

pip install --upgrade chloros-sdk

---

Q : Où sont enregistrées les images traitées ?

Par défaut, dans le chemin d'accès au projet :

Project_Path/
└── MyProject/
    └── Survey3N_RGN/          # Processed outputs

---

Q : Puis-je traiter des images à partir de scripts Python s'exécutant selon un calendrier défini ?R : Oui ! Utilisez le planificateur de tâches Windows avec les scripts Python :

# scheduled_processing.py
from chloros_sdk import process_folder

# Process today's flights
results = process_folder("C:\\Flights\\Today")

Planifiez l'exécution quotidienne via le planificateur de tâches.

---

Q : SDK prend-il en charge async/await ?R : La version actuelle est synchrone. Pour un comportement asynchrone, utilisez wait=False ou exécutez dans un thread séparé :

import threading

def process_thread():
    chloros.process()

thread = threading.Thread(target=process_thread)
thread.start()

# Continue with other work...

---

Q : Comment passer d'un compte Chloros+ à un autre ?R : Utilisez la méthode logout() pour effacer les informations d'identification mises en cache, puis reconnectez-vous avec le nouveau compte :

from chloros_sdk import ChlorosLocal

# Clear current credentials
chloros = ChlorosLocal()
chloros.logout()

# Re-login via Chloros, Chloros (Browser), or Chloros CLI with new account

Après vous être déconnecté, authentifiez-vous avec le nouveau compte via l'interface graphique, le navigateur ou CLI avant d'utiliser à nouveau SDK.

---

Obtenir de l'aide

Documentation

• Référence API : cette page

Canaux d'assistance

• E-mail : [e-mail]

• Site Web : https://www.mapir.camera/community/contact

• Tarifs : https://cloud.mapir.camera/pricing

Exemples de code

Tous les exemples répertoriés ici ont été testés et sont prêts à être utilisés en production. Copiez-les et adaptez-les à votre cas d'utilisation.

---

LicenceLogiciel propriétaire - Copyright (c) 2025 MAPIR Inc.

SDK nécessite un abonnement Chloros+ actif. Toute utilisation, distribution ou modification non autorisée est interdite.