added navigation control to map

io-app-backend/app.py

@@ -10,8 +10,9 @@ app = Flask(__name__, static_folder='static', static_url_path='')
 
 CORS(app)
 
-# --- ENDPOINTY API ---
-
+# =========================================
+# API ENDPOINTS
+# =========================================
 @app.route('/api/config', methods=['GET'])
 def get_config():
     return jsonify({
@@ -22,7 +23,7 @@ def get_config():
 def analyze_endpoint():
     try:
         data = request.json
-        print(f"📡 Otrzymano żądanie: {data}")
+        print(f"[REQUEST] Received request: {data}")
 
         location = data.get('location', {})
         lat = location.get('lat')
@@ -40,8 +41,8 @@ def analyze_endpoint():
                 'error': 'Missing coordinates (lat/lng)'
             }), 400
 
-        print(f"🚀 Uruchamiam analizę dla: [{lat}, {lng}]")
-        print(f"⚙️ Parametry: Buffer={buffer_km}km, Chmury<{max_cloud_cover}%, Historia={days_back}dni")
+        print(f"[RUNNING] Starting analysis for: [{lat}, {lng}]")
+        print(f"[PARAMETERS] Buffer={buffer_km}km, MaxCloudCover<{max_cloud_cover}%, HistoryDays={days_back}")
 
         result = analyze(
             location_data=[lat, lng],
@@ -77,26 +78,26 @@ def analyze_endpoint():
             }
         }
 
-        print(f"✅ Wysyłam wynik do frontendu")
+        print(f"[SUCCESS] Sending result to frontend")
         return jsonify(response)
 
     except Exception as e:
-        print(f"❌ Błąd podczas analizy: {str(e)}")
+        print(f"[ERROR] Error during analysis: {str(e)}")
         traceback.print_exc()
         return jsonify({'success': False, 'error': str(e)}), 500
 
 @app.route('/api/advanced-analyze', methods=['POST'])
 def advanced_analyze_endpoint():
     """
-    Endpoint dla zaawansowanej analizy porównawczej z metrykami.
-    Uruchamia porównanie dwóch wybranych modeli i zwraca:
-    - Obrazy obu modeli (RGB, raw, final)
-    - Maski spektralne
-    - Metryki porównawcze
+    Endpoint for advanced comparative analysis with metrics.
+    Compares two selected models and returns:
+    - Images from both models (RGB, raw, final)
+    - Spectral masks
+    - Comparative metrics
     """
     try:
         data = request.json
-        print(f"📡 Otrzymano żądanie zaawansowanej analizy: {data}")
+        print(f"[REQUEST] Received advanced analysis request: {data}")
 
         location = data.get('location', {})
         lat = location.get('lat')
@@ -113,11 +114,11 @@ def advanced_analyze_endpoint():
                 'error': 'Missing coordinates (lat/lng)'
             }), 400
 
-        print(f"🚀 Uruchamiam zaawansowaną analizę dla: [{lat}, {lng}]")
-        print(f"📊 Porównanie: {model_a} vs {model_b}")
-        print(f"📏 Buffer: {buffer_km} km")
+        print(f"[RUNNING] Starting advanced analysis for: [{lat}, {lng}]")
+        print(f"[COMPARISON] {model_a} vs {model_b}")
+        print(f"[BUFFER] {buffer_km} km")
 
-        # Uruchamia evaluate_system.run_evaluation_with_models()
+        # Run evaluate_system.run_evaluation_with_models()
         eval_result = run_evaluation_with_models(lat, lng, buffer_km, model_a, model_b)
 
         if 'error' in eval_result:
@@ -126,35 +127,35 @@ def advanced_analyze_endpoint():
                 'error': eval_result.get('error')
             }), 404
 
-        # Konwertujemy mapy na obrazy (używając terramindFunctions)
-        print("🖼️ Konwertowanie map na obrazy...")
+        # Convert maps to images (using terramindFunctions)
+        print("[CONVERTING] Converting maps to images...")
         import base64
         import io
         from PIL import Image
         import numpy as np
 
-        # Mapy z corrections i bez corrections
-        model_a_map = eval_result['maps']['modelA']  # Z corrections
-        model_a_map_raw = eval_result['maps']['modelA_raw']  # Bez corrections
-        model_b_map = eval_result['maps']['modelB']  # Z corrections
-        model_b_map_raw = eval_result['maps']['modelB_raw']  # Bez corrections
+        # Maps with corrections and without corrections
+        model_a_map = eval_result['maps']['modelA']  # With corrections
+        model_a_map_raw = eval_result['maps']['modelA_raw']  # Without corrections
+        model_b_map = eval_result['maps']['modelB']  # With corrections
+        model_b_map_raw = eval_result['maps']['modelB_raw']  # Without corrections
         raw_data = eval_result['raw_data']
         input_tensor = eval_result['input_tensor']
 
-        # Funkcja do konwersji numpy RGB array na base64
+        # Function to convert numpy RGB array to base64
         def rgb_to_base64(rgb_array):
-            """Konwertuje RGB array na PNG base64"""
+            """Converts RGB array to PNG base64"""
             img = Image.fromarray(rgb_array.astype(np.uint8))
             buf = io.BytesIO()
             img.save(buf, format='PNG')
             buf.seek(0)
             return base64.b64encode(buf.read()).decode('utf-8')
 
-        # RGB z raw_data (używając create_rgb_image z terramindFunctions)
+        # RGB from raw_data (using create_rgb_image from terramindFunctions)
         rgb_image = tm.create_rgb_image(input_tensor)
         rgb_base64 = rgb_to_base64(rgb_image)
 
-        # Mapy segmentacji - raw (bez corrections) i final (z corrections)
+        # Segmentation maps - raw (without corrections) and final (with corrections)
         model_a_raw_segmentation = tm.create_segmentation_image(model_a_map_raw)
         model_a_segmentation = tm.create_segmentation_image(model_a_map)
         model_b_raw_segmentation = tm.create_segmentation_image(model_b_map_raw)
@@ -165,17 +166,17 @@ def advanced_analyze_endpoint():
         model_b_raw_seg_base64 = rgb_to_base64(model_b_raw_segmentation)
         model_b_seg_base64 = rgb_to_base64(model_b_segmentation)
 
-        # Maski spektralne (z indices)
+        # Spectral masks (from indices)
         indices = eval_result['indices']
         masks_dict = {}
 
-        # Generuj maski jak w analyze()
+        # Generate masks like in analyze()
         index_masks = tm.generate_index_masks(indices)
 
         if isinstance(index_masks, dict):
             for mask_name, mask_array in index_masks.items():
                 try:
-                    # Konwertuj maski binarne na 0-255
+                    # Convert binary masks to 0-255
                     mask_binary = mask_array.astype(np.uint8) * 255
                     img_mask = Image.fromarray(mask_binary, mode='L')
                     buf_mask = io.BytesIO()
@@ -183,9 +184,9 @@ def advanced_analyze_endpoint():
                     buf_mask.seek(0)
                     masks_dict[mask_name] = base64.b64encode(buf_mask.read()).decode('utf-8')
                 except Exception as e:
-                    print(f"⚠️ Błąd konwersji maski {mask_name}: {e}")
+                    print(f"[WARNING] Error converting mask {mask_name}: {e}")
 
-        # Formatujemy odpowiedź
+        # Format the response
         response = {
             'success': True,
             'date': eval_result.get('date'),
@@ -195,7 +196,7 @@ def advanced_analyze_endpoint():
             'image_width': eval_result.get('image_width', 512),
             'image_height': eval_result.get('image_height', 512),
 
-            # OBRAZY
+            # IMAGES
             'modelA': {
                 'name': model_a.split('_')[2].upper(),
                 'rgb': f"data:image/png;base64,{rgb_base64}",
@@ -217,18 +218,18 @@ def advanced_analyze_endpoint():
                 }
             },
 
-            # METRYKI
+            # METRICS
             'metrics': eval_result.get('metrics', {})
         }
 
-        print(f"Wysyłam zaawansowaną analizę do frontendu")
-        print(f"   Data zdjęcia: {eval_result.get('date')}")
-        print(f"   Metryki: {list(eval_result.get('metrics', {}).keys())}")
+        print(f"[SUCCESS] Sending advanced analysis to frontend")
+        print(f"   Image date: {eval_result.get('date')}")
+        print(f"   Metrics: {list(eval_result.get('metrics', {}).keys())}")
 
         return jsonify(response)
 
     except Exception as e:
-        print(f"❌ Błąd podczas zaawansowanej analizy: {str(e)}")
+        print(f"[ERROR] Error during advanced analysis: {str(e)}")
         traceback.print_exc()
         return jsonify({
             'success': False,
@@ -238,31 +239,33 @@ def advanced_analyze_endpoint():
 
 @app.route('/api/health', methods=['GET'])
 def health_check():
-    return jsonify({'status': 'ok', 'message': 'Backend działa poprawnie'})
+    return jsonify({'status': 'ok', 'message': 'Backend is working correctly'})
 
 
-# --- SERWOWANIE FRONTENDU ---
+# =========================================
+# FRONTEND SERVING
+# =========================================
 
 @app.route('/')
 def serve_index():
-    """Serwuje główny plik index.html frontendu."""
+    """Serves the main index.html file of the frontend."""
     return send_from_directory(app.static_folder, 'index.html')
 
 @app.route('/<path:path>')
 def serve_static_files(path):
-    """Serwuje pozostałe pliki statyczne (js, css, obrazy)."""
+    """Serves remaining static files (js, css, images)."""
     return send_from_directory(app.static_folder, path)
 
 @app.errorhandler(404)
 def not_found(e):
-    """Obsługa odświeżania strony (React Router) - przekierowuje z powrotem do index.html."""
+    """Handles page refresh (React Router) - redirects back to index.html."""
     return send_from_directory(app.static_folder, 'index.html')
 
 if __name__ == '__main__':
     print("\n" + "="*60)
-    print("🚀 Serwer TerraMind gotowy na Hugging Face!")
+    print("[START] TerraMind server ready on Hugging Face!")
     print("="*60)
-    
-    # Port 7860 jest wymagany przez Hugging Face
+
+    # Port 7860 is required by Hugging Face
     port = int(os.environ.get("FLASK_RUN_PORT", 7860))
     app.run(host='0.0.0.0', port=port, debug=False)

io-app-backend/evaluate_system.py

@@ -1,14 +1,14 @@
 import torch
 import terramindFunctions as tm
 from terratorch import FULL_MODEL_REGISTRY
-from metrics import calculate_precision,calculate_recall,calculate_accuracy, calculate_miou, calculate_final_score, calculate_fw_iou, calculate_dice_score
+from metrics import calculate_precision,calculate_recall,calculate_accuracy, calculate_miou, calculate_fw_iou, calculate_dice_score
 
-# Konfiguracja
+# [CONFIGURATION] Device setup
 DEVICE = tm.device
 
 def load_model(model_name):
-    """Ładuje wybrany model. Jeśli nie istnieje, fallback do Large."""
-    print(f"⏳ Ładowanie modelu: {model_name}...")
+    """Loads selected model from TerraTorch registry. Falls back to Large version if loading fails."""
+    print(f"[LOADING] Loading model: {model_name}...")
     try:
         model = FULL_MODEL_REGISTRY.build(
             model_name,
@@ -20,8 +20,8 @@ def load_model(model_name):
         model.eval()
         return model
     except Exception as e:
-        print(f"⚠️ Błąd ładowania modelu {model_name}: {e}")
-        print(f"   Fallback: próbuję terramind_v1_large_generate...")
+        print(f"[WARNING] Model loading error {model_name}: {e}")
+        print(f"[FALLBACK] Attempting terramind_v1_large_generate...")
         try:
             model = FULL_MODEL_REGISTRY.build(
                 "terramind_v1_large_generate",
@@ -33,199 +33,90 @@ def load_model(model_name):
             model.eval()
             return model
         except Exception as e2:
-            print(f"❌ Błąd ładowania fallback modelu: {e2}")
+            print(f"[ERROR] Fallback model loading error: {e2}")
             return None
 
-def load_teacher_model():
-    """Ładuje model Large (Nauczyciela)."""
-    print(f"⏳ Ładowanie Nauczyciela...")
-    return load_model("terramind_v1_large_generate")
-
-def process_with_model(model, input_tensor, indices):
-    """
-    To jest ta "wspólna logika", o którą pytałeś.
-    Bierze DOWOLNY model (Student lub Teacher) i zwraca gotową mapę po korektach.
-    Używa funkcji z terramindFunctions.py.
-    """
-    # 1. Inferencja (To samo co w analyze)
-    raw_output = tm.run_inference(model, input_tensor)
-
-    # 2. Dekodowanie (To samo co w analyze)
-    class_map = tm.decode_output(raw_output)
-
-    # # 3. Korekty (To samo co w analyze)
-    # # Dzięki temu Teacher też dostanie poprawki wody/roślinności!
-    # final_map = tm.apply_hybrid_corrections(class_map, indices)
-
-    # return final_map
-    return class_map
-
-def run_evaluation(lat, lon, buffer_km=5):
-    print(f"🔍 ROZPOCZYNAM EWALUACJĘ DLA: {lat}, {lon}")
-
-    # 1. POBRANIE DANYCH (Raz dla obu modeli - oszczędność czasu!)
-    dl_result = tm.download_sentinel2(lat, lon, buffer_km, max_cloud_cover=10, days_back=180)
-
-    if dl_result is None:
-        return {"error": "Nie udało się pobrać zdjęć satelitarnych"}
-
-    raw_data, date, scene_id = dl_result
-
-    # 2. PRZYGOTOWANIE WSPÓLNYCH DANYCH
-    input_tensor = tm.prepare_input(raw_data)
-    # Obliczamy indeksy raz i używamy dla obu modeli (spójność)
-    indices = tm.calculate_spectral_indices(input_tensor)
-
-    # ==========================================
-    # STUDENT
-    # ==========================================
-    print("🤖 Przetwarzanie: Student...")
-    student_model = tm.get_model()
-    # 👇 Używamy naszej funkcji pomocniczej
-    student_map = process_with_model(student_model, input_tensor, indices)
-
-    # ==========================================
-    # NAUCZYCIEL
-    # ==========================================
-    print("👨‍🏫 Przetwarzanie: Nauczyciel...")
-    teacher_model = load_teacher_model()
-
-    if teacher_model is None:
-        return {"error": "Błąd modelu Nauczyciela"}
-
-    # 👇 Używamy tej samej funkcji pomocniczej (gwarancja identycznego procesu)
-    teacher_map = process_with_model(teacher_model, input_tensor, indices)
-
-    # Czyszczenie pamięci
-    del teacher_model
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-
-    # ==========================================
-    # OBLICZANIE METRYK (Wewnątrz run_evaluation)
-    # ==========================================
-    print("📊 Liczenie metryk...")
-
-    # 1. Liczymy wszystko osobno
-    acc = calculate_accuracy(student_map, teacher_map)
-    miou, iou_details = calculate_miou(student_map, teacher_map)
-    fw_iou = calculate_fw_iou(student_map, teacher_map)
-    dice = calculate_dice_score(student_map, teacher_map)
-
-    # Wywołujemy nowe funkcje
-    mean_precision, precision_details = calculate_precision(student_map, teacher_map)
-    mean_recall, recall_details = calculate_recall(student_map, teacher_map)
-
-    # 2. Łączymy szczegóły w jeden słownik dla Frontendu
-    # Frontend oczekuje struktury: { "Las": { iou: 90, precision: 85, recall: 95 }, ... }
-    combined_details = {}
-
-    # Bierzemy klucze (nazwy klas) z IoU (bo ono jest zawsze liczone)
-    for class_name in iou_details.keys():
-        combined_details[class_name] = {
-            "iou": iou_details.get(class_name, 0.0),
-            "precision": precision_details.get(class_name, 0.0),
-            "recall": recall_details.get(class_name, 0.0)
-        }
-
-    # 3. Final Score (np. średnia z 4 głównych)
-    final_score = (acc + miou + fw_iou + dice) / 4.0
-
-    return {
-        "status": "success",
-        "metrics": {
-            "accuracy": acc,
-            "miou": miou,
-            "fw_iou": fw_iou,
-            "dice": dice,
-            "mean_precision": mean_precision,
-            "mean_recall": mean_recall,
-            "final_score": final_score,
-            "class_details": combined_details
-        },
-        "maps": {
-            "student": student_map,
-            "teacher": teacher_map
-        },
-        "raw_data": raw_data,
-        "indices": indices,
-        "date": date
-    }
-
 def run_evaluation_with_models(lat, lon, buffer_km=5, model_a_name=None, model_b_name=None):
     """
-    Uruchamia porównanie dwóch wybranych modeli.
-    Parametry:
-    - lat, lon: współrzędne
-    - buffer_km: rozmiar buforu
-    - model_a_name: nazwa pierwszego modelu
-    - model_b_name: nazwa drugiego modelu
+    Runs comparison of two selected models on satellite imagery.
+    Downloads data once and processes both models with spectral corrections.
+    Computes metrics for both raw and corrected outputs.
+
+    Args:
+        lat: latitude coordinate
+        lon: longitude coordinate
+        buffer_km: search radius in kilometers
+        model_a_name: name of first model (default: terramind_v1_small_generate)
+        model_b_name: name of second model (default: terramind_v1_large_generate)
+
+    Returns:
+        dict with comparison metrics, class maps, and imagery data
     """
     if model_a_name is None:
         model_a_name = 'terramind_v1_small_generate'
     if model_b_name is None:
         model_b_name = 'terramind_v1_large_generate'
 
-    print(f"🔍 PORÓWNANIE MODELI DLA: {lat}, {lon}")
+    print(f"[COMPARE] Model comparison for: {lat}, {lon}")
     print(f"   Model A: {model_a_name}")
     print(f"   Model B: {model_b_name}")
 
-    # 1. POBRANIE DANYCH (Raz dla obu modeli - oszczędność czasu!)
+    # [DOWNLOAD] Download data once for both models (time efficient)
     dl_result = tm.download_sentinel2(lat, lon, buffer_km, max_cloud_cover=10, days_back=180)
 
     if dl_result is None:
-        return {"error": "Nie udało się pobrać zdjęć satelitarnych"}
+        return {"error": "Failed to download satellite imagery"}
 
     raw_data, date, scene_id = dl_result
 
-    # Zapisz oryginalny rozmiar przed skalowaniem do 224x224
+    # [DIMENSIONS] Save original image dimensions before scaling to 224x224
     original_height, original_width = raw_data.shape[1], raw_data.shape[2]
-    print(f"📐 Oryginalne wymiary obrazu: {original_width}x{original_height}")
+    print(f"[DIMENSIONS] Original image size: {original_width}x{original_height}")
 
-    # 2. PRZYGOTOWANIE WSPÓLNYCH DANYCH
+    # [PREPARE] Prepare common data for both models
     input_tensor = tm.prepare_input(raw_data)
-    # Obliczamy indeksy raz i używamy dla obu modeli (spójność)
+    # [INDICES] Calculate spectral indices once and use for both models (consistency)
     indices = tm.calculate_spectral_indices(input_tensor)
 
     # ==========================================
-    # MODEL A
+    # [MODEL_A] Model A processing
     # ==========================================
-    print(f"🤖 Przetwarzanie: {model_a_name}...")
+    print(f"[PROCESSING] Processing: {model_a_name}...")
     model_a = load_model(model_a_name)
     if model_a is None:
-        return {"error": f"Błąd ładowania modelu {model_a_name}"}
+        return {"error": f"Error loading model {model_a_name}"}
 
     raw_output_a = tm.run_inference(model_a, input_tensor)
     map_a_raw = tm.decode_output(raw_output_a)
-    # Zastosuj korekty spektralne
+    # [CORRECTIONS] Apply spectral corrections
     map_a, _ = tm.apply_hybrid_corrections(map_a_raw, indices)
     del model_a
 
     # ==========================================
-    # MODEL B
+    # [MODEL_B] Model B processing
     # ==========================================
-    print(f"🤖 Przetwarzanie: {model_b_name}...")
+    print(f"[PROCESSING] Processing: {model_b_name}...")
     model_b = load_model(model_b_name)
     if model_b is None:
-        return {"error": f"Błąd ładowania modelu {model_b_name}"}
+        return {"error": f"Error loading model {model_b_name}"}
 
     raw_output_b = tm.run_inference(model_b, input_tensor)
     map_b_raw = tm.decode_output(raw_output_b)
-    # Zastosuj korekty spektralne
+    # [CORRECTIONS] Apply spectral corrections
     map_b, _ = tm.apply_hybrid_corrections(map_b_raw, indices)
     del model_b
 
-    # Czyszczenie pamięci
+    # [CLEANUP] Memory cleanup
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
 
     # ==========================================
-    # OBLICZANIE METRYK (Porównanie map)
+    # [METRICS] Calculate evaluation metrics
     # ==========================================
-    print("📊 Liczenie metryk...")
+    print("[METRICS] Computing metrics...")
 
-    # METRYKI DLA RAW (bez corrections)
-    print("  → Metryki dla RAW segmentation (bez wskaźników spektralnych)...")
+    # [RAW_METRICS] Metrics for RAW segmentation (without spectral indices)
+    print("  [RAW] Computing metrics for raw segmentation (without spectral indices)...")
     acc_raw = calculate_accuracy(map_a_raw, map_b_raw)
     miou_raw, iou_details_raw = calculate_miou(map_a_raw, map_b_raw)
     fw_iou_raw = calculate_fw_iou(map_a_raw, map_b_raw)
@@ -233,7 +124,7 @@ def run_evaluation_with_models(lat, lon, buffer_km=5, model_a_name=None, model_b
     mean_precision_raw, precision_details_raw = calculate_precision(map_a_raw, map_b_raw)
     mean_recall_raw, recall_details_raw = calculate_recall(map_a_raw, map_b_raw)
 
-    # Łączymy szczegóły dla RAW
+    # [COMBINE_RAW] Combine details for RAW
     combined_details_raw = {}
     for class_name in iou_details_raw.keys():
         combined_details_raw[class_name] = {
@@ -242,21 +133,21 @@ def run_evaluation_with_models(lat, lon, buffer_km=5, model_a_name=None, model_b
             "recall": recall_details_raw.get(class_name, 0.0)
         }
 
-    # METRYKI DLA CORRECTED (z spectral corrections)
-    print("  → Metryki dla CORRECTED segmentation (ze wskaźnikami spektralnymi)...")
+    # [CORRECTED_METRICS] Metrics for CORRECTED segmentation (with spectral corrections)
+    print("  [CORRECTED] Computing metrics for corrected segmentation (with spectral indices)...")
     acc = calculate_accuracy(map_a, map_b)
     miou, iou_details = calculate_miou(map_a, map_b)
     fw_iou = calculate_fw_iou(map_a, map_b)
     dice = calculate_dice_score(map_a, map_b)
 
-    # Wywołujemy nowe funkcje
+    # [NEW_METRICS] Invoke precision and recall functions
     mean_precision, precision_details = calculate_precision(map_a, map_b)
     mean_recall, recall_details = calculate_recall(map_a, map_b)
 
-    # Łączymy szczegóły dla CORRECTED
+    # [COMBINE_CORRECTED] Combine details for CORRECTED
     combined_details = {}
 
-    # Bierzemy klucze (nazwy klas) z IoU (bo ono jest zawsze liczone)
+    # [KEYS] Extract class names from IoU details (always computed)
     for class_name in iou_details.keys():
         combined_details[class_name] = {
             "iou": iou_details.get(class_name, 0.0),
@@ -264,10 +155,6 @@ def run_evaluation_with_models(lat, lon, buffer_km=5, model_a_name=None, model_b
             "recall": recall_details.get(class_name, 0.0)
         }
 
-    # 3. Final Score (np. średnia z 4 głównych)
-    # 3. Final Score (np. średnia z 4 głównych)
-    final_score = (acc + miou + fw_iou + dice) / 4.0
-
     return {
         "status": "success",
         "metrics": {

io-app-backend/metrics.py

@@ -1,16 +1,18 @@
 import numpy as np
-# 👇 Importujemy słownik nazw z Twojego pliku, żeby metryki "rozumiały" klasy
-from terramindFunctions import ESA_CLASSES
-
-
-import numpy as np
+# [IMPORTS] Import ESA class names dictionary for metric interpretation
 from terramindFunctions import ESA_CLASSES
 
 def calculate_precision(pred_map, target_map):
     """
-    PRECYZJA (Precision): "Ile z tego co model wykrył, jest prawdą?"
-    Wzór: TP / (TP + FP)
-    Zwraca: (średnia_precyzja, słownik_detali)
+    Calculates Precision metric: "What percentage of predictions are correct?"
+    Formula: TP / (TP + FP)
+
+    Args:
+        pred_map: numpy array with predicted class codes
+        target_map: numpy array with ground truth class codes
+
+    Returns:
+        tuple of (mean_precision_percent, class_details_dict)
     """
     classes_in_target = np.unique(target_map)
     precision_list = []
@@ -23,16 +25,16 @@ def calculate_precision(pred_map, target_map):
         t_mask = (target_map == cls)
 
         true_positives = np.logical_and(p_mask, t_mask).sum()
-        false_positives = np.logical_and(p_mask, ~t_mask).sum() # Model: TAK, Prawda: NIE
+        false_positives = np.logical_and(p_mask, ~t_mask).sum()  # [FP] Model predicted: YES, Truth: NO
 
         if (true_positives + false_positives) > 0:
             precision = true_positives / (true_positives + false_positives)
         else:
-            precision = 0.0 # Jeśli model nic nie wykrył dla tej klasy, precyzja 0 (lub 1, zależy od definicji, tu bezpiecznie 0)
+            precision = 0.0  # [NOTE] If model didn't detect this class, precision = 0 (safe default)
 
         precision_list.append(precision)
 
-        class_name = ESA_CLASSES.get(cls, f"Klasa {cls}")
+        class_name = ESA_CLASSES.get(cls, f"Class {cls}")
         details[class_name] = precision * 100.0
 
     mean_precision = np.mean(precision_list) * 100.0 if precision_list else 0.0
@@ -41,9 +43,15 @@ def calculate_precision(pred_map, target_map):
 
 def calculate_recall(pred_map, target_map):
     """
-    CZUŁOŚĆ (Recall): "Ile prawdziwych obiektów model znalazł?"
-    Wzór: TP / (TP + FN)
-    Zwraca: (średnia_czułość, słownik_detali)
+    Calculates Recall metric: "What percentage of true objects did the model find?"
+    Formula: TP / (TP + FN)
+
+    Args:
+        pred_map: numpy array with predicted class codes
+        target_map: numpy array with ground truth class codes
+
+    Returns:
+        tuple of (mean_recall_percent, class_details_dict)
     """
     classes_in_target = np.unique(target_map)
     recall_list = []
@@ -56,16 +64,16 @@ def calculate_recall(pred_map, target_map):
         t_mask = (target_map == cls)
 
         true_positives = np.logical_and(p_mask, t_mask).sum()
-        false_negatives = np.logical_and(~p_mask, t_mask).sum() # Model: NIE, Prawda: TAK
+        false_negatives = np.logical_and(~p_mask, t_mask).sum()  # [FN] Model predicted: NO, Truth: YES
 
         if (true_positives + false_negatives) > 0:
             recall = true_positives / (true_positives + false_negatives)
         else:
-            recall = 0.0 # To się nie powinno zdarzyć, bo iterujemy po klasach z targetu
+            recall = 0.0  # [NOTE] Shouldn't happen since iterating over target classes
 
         recall_list.append(recall)
 
-        class_name = ESA_CLASSES.get(cls, f"Klasa {cls}")
+        class_name = ESA_CLASSES.get(cls, f"Class {cls}")
         details[class_name] = recall * 100.0
 
     mean_recall = np.mean(recall_list) * 100.0 if recall_list else 0.0
@@ -73,31 +81,38 @@ def calculate_recall(pred_map, target_map):
 
 def calculate_dice_score(pred_map, target_map):
     """
-    Oblicza współczynnik Dice (F1-Score dla pikseli).
-    Jest to średnia z Dice dla każdej klasy.
-    Wynik Dice jest zazwyczaj wyższy niż IoU dla tych samych danych.
+    Calculates Dice coefficient (F1-Score for pixels).
+    Returns mean Dice score across all classes.
+    Dice score is typically higher than IoU for the same data.
+
+    Args:
+        pred_map: numpy array with predicted class codes
+        target_map: numpy array with ground truth class codes
+
+    Returns:
+        float - mean Dice score as percentage
     """
     classes_in_target = np.unique(target_map)
     dice_list = []
 
     for cls in classes_in_target:
-        # Pomiń klasę 0 (Brak danych)
+        # [SKIP] Skip class 0 (No data / No Data)
         if cls == 0:
             continue
 
-        # Maski binarne
+        # [MASKS] Binary masks for current class
         p_mask = (pred_map == cls)
         t_mask = (target_map == cls)
 
         intersection = np.logical_and(p_mask, t_mask).sum()
 
-        # Liczba pikseli w predykcji i w targecie
+        # [AREAS] Number of pixels in prediction and target
         area_pred = p_mask.sum()
         area_target = t_mask.sum()
 
-        # Zabezpieczenie przed dzieleniem przez zero
+        # [SAFE] Prevent division by zero
         if area_pred + area_target == 0:
-            dice = 1.0 # Oba puste = idealne dopasowanie
+            dice = 1.0  # Both empty = perfect match
         else:
             dice = (2.0 * intersection) / (area_pred + area_target)
 
@@ -111,12 +126,19 @@ def calculate_dice_score(pred_map, target_map):
 
 def calculate_accuracy(pred_map, target_map):
     """
-    Oblicza Pixel Accuracy (procent zgodnych pikseli).
+    Calculates Pixel Accuracy (percentage of correctly classified pixels).
+
+    Args:
+        pred_map: numpy array with predicted class codes
+        target_map: numpy array with ground truth class codes
+
+    Returns:
+        float - pixel accuracy as percentage
     """
     p = pred_map.flatten()
     t = target_map.flatten()
 
-    # Porównujemy tylko tam, gdzie we wzorcu nie ma "Braku danych" (klasa 0)
+    # [VALID] Only compare pixels where target doesn't have "No data" (class 0)
     valid_mask = (t != 0)
 
     if np.sum(valid_mask) == 0:
@@ -129,19 +151,28 @@ def calculate_accuracy(pred_map, target_map):
 
 def calculate_miou(pred_map, target_map, verbose=False):
     """
-    Oblicza mIoU i (opcjonalnie) wypisuje wynik dla każdej klasy z osobna.
+    Calculates mean Intersection over Union (mIoU) metric.
+    Optionally prints per-class results if verbose=True.
+
+    Args:
+        pred_map: numpy array with predicted class codes
+        target_map: numpy array with ground truth class codes
+        verbose: if True, print per-class IoU scores
+
+    Returns:
+        tuple of (mean_iou_percent, class_iou_dict)
     """
-    # Znajdujemy wszystkie klasy obecne we wzorcu (Ground Truth)
+    # [FIND_CLASSES] Find all classes present in ground truth
     classes_in_target = np.unique(target_map)
     iou_list = []
     class_report = {}
 
     for cls in classes_in_target:
-        # Pomiń klasę 0 (Brak danych / No Data)
+        # [SKIP] Skip class 0 (No data / No Data)
         if cls == 0:
             continue
 
-        # Tworzymy maski binarne (gdzie jest dana klasa)
+        # [MASKS] Create binary masks (where this class appears)
         p_mask = (pred_map == cls)
         t_mask = (target_map == cls)
 
@@ -152,8 +183,8 @@ def calculate_miou(pred_map, target_map, verbose=False):
             iou = intersection / union
             iou_list.append(iou)
 
-            # Pobieramy nazwę klasy z Twojego słownika
-            class_name = ESA_CLASSES.get(cls, f"Klasa {cls}")
+            # [CLASS_NAME] Get class name from dictionary
+            class_name = ESA_CLASSES.get(cls, f"Class {cls}")
             class_report[class_name] = iou * 100.0
 
     if len(iou_list) == 0:
@@ -161,63 +192,33 @@ def calculate_miou(pred_map, target_map, verbose=False):
 
     miou = np.mean(iou_list) * 100.0
 
-    # Jeśli verbose=True, wypiszemy szczegóły w konsoli
+    # [VERBOSE] If verbose=True, print details to console
     if verbose:
-        print("\n--- Szczegóły IoU dla klas ---")
+        print("\n[IoU] IoU details per class")
         for name, score in class_report.items():
             print(f"{name:<20}: {score:.2f}%")
 
     return miou, class_report
 
-def calculate_final_score(accuracy, miou, fwiou):
-    """
-    Oblicza ostateczny wynik jako średnią z trzech metryk:
-    1. Pixel Accuracy
-    2. mIoU
-    3. fwIoU
-    """
-    return (accuracy + miou + fwiou) / 3.0
-
-def print_report(accuracy, miou, final_score=None, class_details=None, model_name="Model"):
-    """
-    Wyświetla ładny, czytelny raport w konsoli.
+def calculate_fw_iou(pred_map, target_map):
     """
-    print("=" * 40)
-    print(f" 📊 RAPORT DLA: {model_name}")
-    print("=" * 40)
-
-    if class_details:
-        print(f"{'KLASA':<25} | {'IoU':<10}")
-        print("-" * 40)
-        for name, score in class_details.items():
-            print(f"{name:<25} | {score:.2f}%")
-        print("-" * 40)
-
-    print(f"Pixel Accuracy (Ogólna):  {accuracy:.2f}%")
-    print(f"mIoU (Średnia z klas):    {miou:.2f}%")
+    Calculates Frequency Weighted IoU.
+    Weights depend on class frequency in target image.
+    Provides "fairer" visual results (large forest weighted more than small river).
 
-    if final_score is not None:
-        print("-" * 40)
-        print(f"🏆 FINAL SCORE:           {final_score:.2f} / 100")
-    print("=" * 40 + "\n")
+    Args:
+        pred_map: numpy array with predicted class codes
+        target_map: numpy array with ground truth class codes
 
-
-
-
-# ... (reszta pliku bez zmian) ...
-
-def calculate_fw_iou(pred_map, target_map):
-    """
-    Oblicza Frequency Weighted IoU.
-    Wagi zależą od tego, jak często dana klasa występuje na obrazku (Target).
-    To daje "sprawiedliwszy" wynik wizualny (duży las ma większą wagę niż mała rzeczka).
+    Returns:
+        float - frequency weighted IoU as percentage
     """
     classes_in_target = np.unique(target_map)
 
     fw_iou_sum = 0.0
     total_valid_pixels = 0
 
-    # 1. Liczymy sumę wszystkich ważnych pikseli (bez klasy 0 - brak danych)
+    # [TOTAL] Sum all valid pixels (excluding class 0 - no data)
     for cls in classes_in_target:
         if cls == 0: continue
         total_valid_pixels += np.sum(target_map == cls)
@@ -225,11 +226,11 @@ def calculate_fw_iou(pred_map, target_map):
     if total_valid_pixels == 0:
         return 0.0
 
-    # 2. Liczymy ważone IoU dla każdej klasy
+    # [WEIGHTED] Compute weighted IoU for each class
     for cls in classes_in_target:
         if cls == 0: continue
 
-        # IoU dla danej klasy
+        # [IOU] IoU for this class
         p_mask = (pred_map == cls)
         t_mask = (target_map == cls)
 
@@ -240,10 +241,10 @@ def calculate_fw_iou(pred_map, target_map):
         if union > 0:
             iou = intersection / union
 
-        # Częstość występowania (Waga)
+        # [FREQUENCY] Class frequency (weight)
         frequency = np.sum(t_mask) / total_valid_pixels
 
-        # Dodajemy do sumy: Waga * IoU
+        # [ADD] Add to sum: Weight * IoU
         fw_iou_sum += (frequency * iou)
 
     return fw_iou_sum * 100.0

io-app-backend/plotting_utils.py

@@ -1,429 +0,0 @@
-
-import torch
-import numpy as np
-import textwrap
-import matplotlib.pyplot as plt
-from matplotlib.colors import hex2color, LinearSegmentedColormap
-
-# Plotting utils
-COLORBLIND_HEX = ["#000000", "#3171AD", "#469C76", '#83CA70', "#EAE159", "#C07CB8", "#C19368", "#6FB2E4", "#F1F1F1",
-                  "#C66526"]
-COLORBLIND_RGB = [hex2color(hex) for hex in COLORBLIND_HEX]
-lulc_cmap = LinearSegmentedColormap.from_list('lulc', COLORBLIND_RGB, N=10)
-
-
-def rgb_smooth_quantiles(array, tolerance=0.02, scaling=0.5, default=2000):
-    """
-    array: numpy array with dimensions [C, H, W]
-    returns 0-1 scaled array
-    """
-
-    # Get scaling thresholds for smoothing the brightness
-    limit_low, median, limit_high = np.quantile(array, q=[tolerance, 0.5, 1. - tolerance])
-    limit_high = limit_high.clip(default)  # Scale only pixels above default value
-    limit_low = limit_low.clip(0, 1000)  # Scale only pixels below 1000
-    limit_low = np.where(median > default / 2, limit_low, 0)  # Make image only darker if it is not dark already
-
-    # Smooth very dark and bright values using linear scaling
-    array = np.where(array >= limit_low, array, limit_low + (array - limit_low) * scaling)
-    array = np.where(array <= limit_high, array, limit_high + (array - limit_high) * scaling)
-
-    # Update scaling params using a 10th of the tolerance for max value
-    limit_low, limit_high = np.quantile(array, q=[tolerance/10, 1. - tolerance/10])
-    limit_high = limit_high.clip(default, 20000)  # Scale only pixels above default value
-    limit_low = limit_low.clip(0, 500)  # Scale only pixels below 500
-    limit_low = np.where(median > default / 2, limit_low, 0)  # Make image only darker if it is not dark already
-
-    # Scale data to 0-255
-    array = (array - limit_low) / (limit_high - limit_low)
-
-    return array
-
-
-def s2_to_rgb(data, smooth_quantiles=False):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    if len(data.shape) == 4:
-        # Remove batch dim
-        data = data[0]
-
-    # Select
-    if data.shape[0] > 13:
-        # assuming channel last
-        rgb = data[:, :, [3, 2, 1]]
-    else:
-        # assuming channel first
-        rgb = data[[3, 2, 1]].transpose((1, 2, 0))
-
-    if smooth_quantiles:
-        rgb = rgb_smooth_quantiles(rgb)
-    else:
-        rgb = rgb / 2000
-
-    # to uint8
-    rgb = (rgb * 255).round().clip(0, 255).astype(np.uint8)
-
-    return rgb
-
-
-def s1_to_rgb(data):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    if len(data.shape) == 4:
-        # Remove batch dim
-        data = data[0]
-
-    vv = data[0]
-    vh = data[1]
-    r = (vv + 30) / 40  # scale -30 to +10
-    g = (vh + 40) / 40  # scale -40 to +0
-    b = vv / vh.clip(-40, -1) / 1.5  # VV / VH
-
-    rgb = np.dstack([r, g, b])
-    rgb = (rgb * 255).round().clip(0, 255).astype(np.uint8)
-    return rgb
-
-
-def s1_to_power(data):
-    # Convert dB to power
-    data = 10 ** (data / 10)
-    return data * 10000
-
-
-def s1_power_to_rgb(data):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    if len(data.shape) == 4:
-        # Remove batch dim
-        data = data[0]
-
-    vv = data[0]
-    vh = data[1]
-    r = vv / 500
-    g = vh / 2200
-    b = vv / vh / 2
-
-    rgb = np.dstack([r, g, b])
-    rgb = (rgb * 255).round().clip(0, 255).astype(np.uint8)
-    return rgb
-
-
-def dem_to_rgb(data, cmap='BrBG_r', buffer=5):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    while len(data.shape) > 2:
-        # Remove batch dim etc.
-        data = data[0]
-
-    # Add 10m buffer to highlight flat areas
-    data_min, data_max = data.min(), data.max()
-    data_min -= buffer
-    data_max += buffer
-    data = (data - data_min) / (data_max - data_min + 1e-6)
-
-    rgb = plt.get_cmap(cmap)(data)[:, :, :3]
-    rgb = (rgb * 255).round().clip(0, 255).astype(np.uint8)
-    return rgb
-
-
-def ndvi_to_rgb(data, cmap='RdYlGn'):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    while len(data.shape) > 2:
-        # Remove batch dim etc.
-        data = data[0]
-
-    # Scale NDVI to 0-1
-    data = (data + 1) / 2
-
-    rgb = plt.get_cmap(cmap)(data)[:, :, :3]
-    rgb = (rgb * 255).round().clip(0, 255).astype(np.uint8)
-    return rgb
-
-
-def lulc_to_rgb(data, cmap=lulc_cmap, num_classes=10):
-    while len(data.shape) > 2:
-        if data.shape[0] == num_classes:
-            data = data.argmax(axis=0)  # First dim are class logits
-        else:
-            # Remove batch dim
-            data = data[0]
-
-    rgb = cmap(data)[:, :, :3]
-    rgb = (rgb * 255).round().clip(0, 255).astype(np.uint8)
-    return rgb
-
-
-def coords_to_text(data):
-    if isinstance(data, torch.Tensor):
-        data = data.clone().cpu().numpy()
-    if len(data.shape) > 1:
-        # Remove batch dim etc.
-        data = data[0]
-    if data.shape[0] > 2:
-        # Not coords
-        return str(data)
-    else:
-
-        return f'lon={data[0]:.2f}, lat={data[1]:.2f}'
-
-
-def plot_s2(data, ax=None, smooth_quantiles=False, *args, **kwargs):
-    rgb = s2_to_rgb(data, smooth_quantiles=smooth_quantiles)
-
-    if ax is None:
-        plt.imshow(rgb)
-        plt.axis('off')
-        plt.show()
-    else:
-        ax.imshow(rgb)
-        ax.axis('off')
-
-
-def plot_s1(data, ax=None, power=False, *args, **kwargs):
-    if power:
-        data = s1_to_power(data)
-        rgb = s1_power_to_rgb(data)
-    else:
-        rgb = s1_to_rgb(data)
-
-    if ax is None:
-        plt.imshow(rgb)
-        plt.axis('off')
-        plt.show()
-    else:
-        ax.imshow(rgb)
-        ax.axis('off')
-
-
-def plot_dem(data, ax=None, *args, **kwargs):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    while len(data.shape) > 2:
-        # Remove batch dim etc.
-        data = data[0]
-
-    # Add 10m buffer to highlight flat areas
-    data_min, data_max = data.min(), data.max()
-    data_min -= 5
-    data_max += 5
-    data = (data - data_min) / (data_max - data_min + 1e-6)
-
-    data = (data * 255).round().clip(0, 255).astype(np.uint8)
-
-    if ax is None:
-        plt.imshow(data, vmin=0, vmax=255, cmap='BrBG_r')
-        plt.axis('off')
-        plt.show()
-    else:
-        ax.imshow(data, vmin=0, vmax=255, cmap='BrBG_r')
-        ax.axis('off')
-
-
-def plot_lulc(data, ax=None, num_classes=10, *args, **kwargs):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    while len(data.shape) > 2:
-        if data.shape[0] == num_classes:
-            data = data.argmax(axis=0)  # First dim are class logits
-        else:
-            # Remove batch dim
-            data = data[0]
-
-    if ax is None:
-        plt.imshow(data, vmin=0, vmax=num_classes-1, cmap=lulc_cmap, interpolation='nearest')
-        plt.axis('off')
-        plt.show()
-    else:
-        ax.imshow(data, vmin=0, vmax=num_classes-1, cmap=lulc_cmap, interpolation='nearest')
-        ax.axis('off')
-
-
-def plot_ndvi(data, ax=None, *args, **kwargs):
-    if isinstance(data, torch.Tensor):
-        # to numpy
-        data = data.clone().cpu().numpy()
-    while len(data.shape) > 2:
-        # Remove batch dim etc.
-        data = data[0]
-
-    if ax is None:
-        plt.imshow(data, vmin=-1, vmax=+1, cmap='RdYlGn')
-        plt.axis('off')
-        plt.show()
-    else:
-        ax.imshow(data, vmin=-1, vmax=+1, cmap='RdYlGn')
-        ax.axis('off')
-
-
-def wrap_text(text, ax, font_size):
-    # Get the width of the axis in pixels
-    bbox = ax.get_window_extent()
-    width, height = bbox.width, bbox.height
-
-    # Calculate the number of characters per line
-    char_width = font_size * 0.6  # Approximate width of a character
-    max_chars_per_line = int(width / char_width * 0.75)
-    max_lines = int(height / font_size * 0.5)
-
-    # Wrap the text
-    wrapped_text = textwrap.wrap(text, width=max_chars_per_line)
-
-    if len(wrapped_text) > max_lines:
-        wrapped_text = wrapped_text[:max_lines]
-        wrapped_text[-1] += '...'
-
-    return '\n'.join(wrapped_text)
-
-
-def plot_text(data, ax=None, *args, **kwargs):
-    if isinstance(data, str):
-        text = data
-    elif isinstance(data, torch.Tensor) or isinstance(data, np.ndarray):
-        # assuming coordinates
-        text = coords_to_text(data)
-    else:
-        raise ValueError()
-
-    font_size = 14 if len(text) > 150 else 20
-
-    if ax is None:
-        fig, ax = plt.subplots()
-        wrapped_text = wrap_text(text, ax, font_size)
-        ax.text(0.5, 0.5, wrapped_text, fontsize=font_size, ha='center', va='center', wrap=True)
-        ax.set_xticks([])
-        ax.set_yticks([])
-        plt.show()
-    else:
-        wrapped_text = wrap_text(text, ax, font_size)
-        ax.text(0.5, 0.5, wrapped_text, fontsize=font_size, ha='center', va='center', wrap=True)
-        ax.set_xticks([])
-        ax.set_yticks([])
-
-
-def plot_modality(modality, data, ax=None, **kwargs):
-    if 's2' in modality.lower():
-        plot_s2(data, ax=ax, **kwargs)
-    elif 's1' in modality.lower():
-        plot_s1(data, ax=ax, **kwargs)
-    elif 'dem' in modality.lower():
-        plot_dem(data, ax=ax, **kwargs)
-    elif 'ndvi' in modality.lower():
-        plot_ndvi(data, ax=ax, **kwargs)
-    elif 'lulc' in modality.lower():
-        plot_lulc(data, ax=ax, **kwargs)
-    elif 'coords' in modality.lower() or 'caption' in modality.lower() or 'text' in modality.lower():
-        plot_text(data, ax=ax, **kwargs)
-
-
-
-# Metryki v0.2  (patrz terramind_generation.ipynb na komórke z "print(f"⏳ Ładowanie modelu: {model_name}...")")
-
-def calculate_lulc_score(pred_tensor, target_tensor, num_classes=10):
-    """
-    Porównanie map LULC:
-    - Pixel Accuracy
-    - mIoU
-    - Final Score (0–100)
-
-    Teacher (Large) = proxy ground truth
-    """
-
-    if isinstance(pred_tensor, torch.Tensor):
-        pred_tensor = pred_tensor.detach().cpu()
-    if isinstance(target_tensor, torch.Tensor):
-        target_tensor = target_tensor.detach().cpu()
-
-    if pred_tensor.ndim == 4:
-        pred_tensor = pred_tensor[0]
-    if target_tensor.ndim == 4:
-        target_tensor = target_tensor[0]
-
-    if pred_tensor.ndim == 3:
-        pred_mask = torch.argmax(pred_tensor, dim=0).numpy()
-    else:
-        pred_mask = pred_tensor.numpy()
-
-    if target_tensor.ndim == 3:
-        target_mask = torch.argmax(target_tensor, dim=0).numpy()
-    else:
-        target_mask = target_tensor.numpy()
-
-    accuracy = (pred_mask == target_mask).sum() / pred_mask.size * 100.0
-
-    iou_list = []
-    for c in range(num_classes):
-        pred_c = (pred_mask == c)
-        target_c = (target_mask == c)
-
-        union = np.logical_or(pred_c, target_c).sum()
-        intersection = np.logical_and(pred_c, target_c).sum()
-
-        if union > 0:
-            iou_list.append(intersection / union)
-
-    miou = np.mean(iou_list) * 100.0 if len(iou_list) > 0 else 0.0
-    final_score = 0.3 * accuracy + 0.7 * miou
-
-    return {
-        "pixel_accuracy": accuracy,
-        "miou": miou,
-        "final_score": final_score
-    }
-
-
-def prepare_masks_for_score(*masks):
-    """Prepare one or more label maps for `calculate_lulc_score`.
-
-    Args:
-        *masks: numpy arrays or torch tensors representing label maps (H,W) or (C,H,W) logits.
-
-    Returns:
-        (tensors, num_classes):
-            tensors: list of `torch.LongTensor` remapped to contiguous labels 0..N-1
-            num_classes: number of unique labels across all inputs
-
-    This helper will extract class indices if given logits, compute the union of labels,
-    remap them to 0..N-1 and return torch tensors suitable for `calculate_lulc_score`.
-    """
-    np_masks = []
-    for m in masks:
-        if isinstance(m, torch.Tensor):
-            m = m.detach().cpu()
-            if m.ndim == 4:
-                m = m[0]
-            if m.ndim == 3 and m.shape[0] > 1:
-                m = m.argmax(axis=0).numpy()
-            else:
-                m = m.numpy()
-        elif isinstance(m, np.ndarray):
-            while m.ndim > 2:
-                # remove batch dim
-                m = m[0]
-        else:
-            raise ValueError("Unsupported mask type")
-
-        np_masks.append(np.array(m, dtype=np.int64))
-
-    # union of labels across all masks
-    if len(np_masks) > 1:
-        union = np.unique(np.concatenate([m.ravel() for m in np_masks]))
-    else:
-        union = np.unique(np_masks[0])
-    label_to_idx = {int(l): i for i, l in enumerate(union)}
-
-    remapped_tensors = []
-    for arr in np_masks:
-        flat = arr.ravel()
-        rem = np.vectorize(lambda x: label_to_idx[int(x)])(flat)
-        remapped = rem.reshape(arr.shape).astype(np.int64)
-        remapped_tensors.append(torch.from_numpy(remapped))
-
-    return remapped_tensors, len(union)

io-app-backend/terramindFunctions.py

@@ -1,3 +1,4 @@
+
 import os
 import torch
 import numpy as np
@@ -12,7 +13,7 @@ from PIL import Image
 import gc
 
 # =========================================
-# ⚙️ KONFIGURACJA DOMYŚLNA
+# CONFIGURATION DEFAULTS
 # =========================================
 
 DEFAULT_BUFFER_KM = 5
@@ -24,7 +25,7 @@ TIMESTEPS = 50
 BRIGHTNESS_BOOST = 2.5
 NORMALIZATION_MODE = "offset"
 
-# Progi indeksów spektralnych
+# Spectral index thresholds
 NDWI_THRESHOLD = 0.1
 MNDWI_THRESHOLD = 0.1
 NDVI_THRESHOLD = 0.3
@@ -35,28 +36,24 @@ USE_WATER_CORRECTION = True
 USE_VEGETATION_CORRECTION = True
 USE_BUILDING_CORRECTION = True
 USE_BARE_SOIL_CORRECTION = True
-USE_SNOW_CORRECTION = False
-
-SAVE_RESULTS = True
-OUTPUT_FOLDER = "./wyniki"
 
 # =========================================
-# KLASY ESA WORLDCOVER
+# ESA WORLDCOVER CLASSES
 # =========================================
 
 ESA_CLASSES = {
-    0: "Brak danych",
-    10: "Drzewa / Las",
-    20: "Zarośla",
-    30: "Trawa / Łąki",
-    40: "Uprawy rolne",
-    50: "Zabudowa",
-    60: "Goły grunt",
-    70: "Śnieg i lód",
-    80: "Woda",
-    90: "Tereny podmokłe",
-    95: "Namorzyny",
-    100: "Mchy i porosty"
+    0: "No data",
+    10: "Trees / Forest",
+    20: "Shrubs",
+    30: "Grass / Meadows",
+    40: "Cultivated crops",
+    50: "Buildings",
+    60: "Bare ground",
+    70: "Snow and ice",
+    80: "Water",
+    90: "Wetlands",
+    95: "Mangroves",
+    100: "Lichens and moss"
 }
 
 ESA_COLORS = {
@@ -80,17 +77,30 @@ INDEX_TO_ESA = {
 }
 
 device = 'cuda' if torch.cuda.is_available() else 'cpu'
-print(f"🖥️ Urządzenie: {device}")
+print(f"[DEVICE] Computing device: {device}")
 
 # =========================================
-# 🚀 GLOBALNY CACHE MODELU
+# GLOBAL MODEL CACHE
 # =========================================
 
 _CURRENT_MODEL = None
 _CURRENT_MODEL_NAME = None
 
 def get_model(model_name):
-    """Ładuje model tylko raz i cache'uje go."""
+    """
+    Loads and caches TerraMind model for inference.
+    Implements global cache to avoid loading same model multiple times.
+    Clears memory when switching models.
+
+    Args:
+        model_name: str - model identifier from TerraTorch registry
+
+    Returns:
+        model object ready for inference
+
+    Raises:
+        Exception if model loading fails
+    """
     global _CURRENT_MODEL, _CURRENT_MODEL_NAME
     if _CURRENT_MODEL is not None and _CURRENT_MODEL_NAME == model_name:
         return _CURRENT_MODEL
@@ -99,14 +109,14 @@ def get_model(model_name):
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
         gc.collect()
-        print("🧹 Wyczyszczono pamięć po poprzednim modelu.")
+        print("[CLEANUP] Memory cleared after previous model.")
 
     from terratorch import FULL_MODEL_REGISTRY
-    print("⏳ Ładowanie modelu (tylko pierwszy raz)...")
+    print("[LOADING] Loading model (first time only)...")
 
     try:
         model = FULL_MODEL_REGISTRY.build(
-            model_name,  # Używamy nazwy przekazanej z parametru
+            model_name,  # Use the name passed from parameter
             modalities=["S2L2A"],
             output_modalities=["LULC"],
             pretrained=True,
@@ -115,29 +125,38 @@ def get_model(model_name):
 
         model.eval()
 
-        # Aktualizujemy globalny cache
+        # Update global cache
         _CURRENT_MODEL = model
         _CURRENT_MODEL_NAME = model_name
 
-        print(f"✅ Model {model_name} gotowy do pracy.")
+        print(f"[SUCCESS] Model {model_name} ready for use.")
         return _CURRENT_MODEL
 
     except Exception as e:
-        print(f"❌ Błąd podczas ładowania modelu {model_name}: {e}")
-        # Jeśli się nie uda, spróbujmy załadować domyślny lub rzucić błąd
+        print(f"[ERROR] Error loading model {model_name}: {e}")
+        # If it fails, try loading default or raise error
         raise e
 
 # =========================================
-# FUNKCJE POMOCNICZE
+# HELPER FUNCTIONS
 # =========================================
 
 def get_coordinates_from_name(place_name):
+    """
+    Geocodes place name to geographic coordinates using Nominatim.
+
+    Args:
+        place_name: str - name of the location
+
+    Returns:
+        tuple of (latitude, longitude) or None if not found
+    """
     try:
         from geopy.geocoders import Nominatim
         geolocator = Nominatim(user_agent="terramind_fast")
         location = geolocator.geocode(place_name)
         if location:
-            print(f"📍 {location.address}")
+            print(f"[LOCATION] {location.address}")
             return location.latitude, location.longitude
         return None
     except:
@@ -145,42 +164,56 @@ def get_coordinates_from_name(place_name):
 
 
 def download_sentinel2(lat, lon, buffer_km, max_cloud_cover, days_back):
-    import planetary_computer
+    """
+    Downloads Sentinel-2 L2A satellite data for specified location.
+    Uses Planetary Computer STAC API to find and load cloud-optimized GeoTIFF data.
+
+    Args:
+        lat: latitude coordinate
+        lon: longitude coordinate
+        buffer_km: search radius in kilometers
+        max_cloud_cover: maximum allowed cloud cover percentage
+        days_back: days to search back in time
+
+    Returns:
+        tuple of (stacked_array, date, scene_id) or None if no data found
+    """
     import pystac_client
     import odc.stac
+    import planetary_computer
     import math
     import numpy as np
     from datetime import datetime, timedelta
     from pyproj import Transformer
 
-    print(f"🛰️ Pobieranie danych dla: {lat:.4f}, {lon:.4f} (Promień: {buffer_km}km)")
+    print(f"[DOWNLOAD] Downloading data for: {lat:.4f}, {lon:.4f} (Radius: {buffer_km}km)")
 
-    # 1. Obliczamy współczynnik skali Mercatora dla danej szerokości geograficznej
-    # To koryguje zniekształcenia mapy (w Polsce 1 metr rzeczywisty ≈ 1.6 metra w EPSG:3857)
+    # 1. Calculate Mercator scale factor for given latitude
+    # This corrects map distortion (in Poland 1 meter real ≈ 1.6 meters in EPSG:3857)
     scale_factor = 1.0 / math.cos(math.radians(lat))
 
-    # 2. Przygotowujemy transformatory
+    # 2. Prepare transformers
     to_3857 = Transformer.from_crs("EPSG:4326", "EPSG:3857", always_xy=True)
     to_4326 = Transformer.from_crs("EPSG:3857", "EPSG:4326", always_xy=True)
 
-    # 3. Obliczamy środek w metrach Mercatora
+    # 3. Calculate center in Mercator meters
     center_x, center_y = to_3857.transform(lon, lat)
 
-    # 4. Obliczamy zasięg w metrach Mercatora z uwzględnieniem skali
-    # half_side = (buffer_km * 1000) / 2  <-- Jeśli buffer_km to długość boku
-    # half_side = (buffer_km * 1000)      <-- Jeśli buffer_km to promień (dystans od środka)
-    # Przyjmujemy buffer_km jako promień (zgodnie z Twoją logiką "radius"):
+    # 4. Calculate extent in Mercator meters accounting for scale
+    # half_side = (buffer_km * 1000) / 2  <-- If buffer_km is side length
+    # half_side = (buffer_km * 1000)      <-- If buffer_km is radius (distance from center)
+    # We assume buffer_km as radius (consistent with "radius" logic):
     half_side_mercator = (buffer_km * 1000) * scale_factor
 
     min_x, min_y = center_x - half_side_mercator, center_y - half_side_mercator
     max_x, max_y = center_x + half_side_mercator, center_y + half_side_mercator
 
-    # 5. Konwersja z powrotem na stopnie dla STAC (wymagane przez API)
+    # 5. Convert back to degrees for STAC (required by API)
     west, south = to_4326.transform(min_x, min_y)
     east, north = to_4326.transform(max_x, max_y)
     bbox_geo = [west, south, east, north]
 
-    # --- Wyszukiwanie danych ---
+    # --- Data Search ---
     end_date = datetime.now()
     start_date = end_date - timedelta(days=days_back)
     date_range = f"{start_date.strftime('%Y-%m-%d')}/{end_date.strftime('%Y-%m-%d')}"
@@ -194,18 +227,18 @@ def download_sentinel2(lat, lon, buffer_km, max_cloud_cover, days_back):
         collections=["sentinel-2-l2a"],
         bbox=bbox_geo,
         datetime=date_range,
-        query={"eo:cloud_cover": {"lt": max_cloud_cover}}
+        query={"eo:cloud_cover": {"lte": max_cloud_cover}}
     )
 
     items = list(search.items())
     if not items:
-        print("❌ Brak danych spełniających kryteria")
+        print("[ERROR] No data matching criteria found")
         return None
 
     best_item = sorted(items, key=lambda x: x.properties.get('eo:cloud_cover', 100))[0]
 
-    # 6. Ładowanie danych
-    # bbox_geo (stopnie) definiuje obszar, crs="EPSG:3857" wymusza format map internetowych
+    # 6. Load data
+    # bbox_geo (degrees) defines the area, crs="EPSG:3857" enforces web map format
     data = odc.stac.load(
         [best_item],
         bands=["B01", "B02", "B03", "B04", "B05", "B06",
@@ -215,63 +248,24 @@ def download_sentinel2(lat, lon, buffer_km, max_cloud_cover, days_back):
         resolution=10
     )
 
-    # Mapowanie zmiennych na tablicę numpy
+    # Map variables to numpy array
     stacked = np.stack([data[b].values[0] for b in data.data_vars], axis=0)
 
-    print(f"✅ Pobrano obraz o rozmiarze: {stacked.shape}")
+    print(f"[SUCCESS] Downloaded image size: {stacked.shape}")
     return stacked, best_item.datetime.strftime('%Y-%m-%d'), best_item.id
 
-# def download_sentinel2(lat, lon, buffer_km, max_cloud_cover, days_back):
-#     """Pobiera dane satelitarne uwzględniając parametry przekazane z backendu."""
-#     import planetary_computer
-#     import pystac_client
-#     import odc.stac
-#
-#     print(f"🛰️ Pobieranie danych dla: {lat:.4f}, {lon:.4f} (Buffer: {buffer_km}km, Chmury: <{max_cloud_cover}%)")
-#
-#     delta = buffer_km * 0.01
-#     bbox = [lon - delta, lat - delta, lon + delta, lat + delta]
-#
-#     end_date = datetime.now()
-#     start_date = end_date - timedelta(days=days_back)
-#     date_range = f"{start_date.strftime('%Y-%m-%d')}/{end_date.strftime('%Y-%m-%d')}"
-#
-#     catalog = pystac_client.Client.open(
-#         "https://planetarycomputer.microsoft.com/api/stac/v1",
-#         modifier=planetary_computer.sign_inplace
-#     )
-#
-#     search = catalog.search(
-#         collections=["sentinel-2-l2a"],
-#         bbox=bbox,
-#         datetime=date_range,
-#         query={"eo:cloud_cover": {"lt": max_cloud_cover}}
-#     )
-#
-#     items = list(search.items())
-#     if not items:
-#         print("❌ Brak danych spełniających kryteria")
-#         return None
-#
-#     items_sorted = sorted(items, key=lambda x: x.properties.get('eo:cloud_cover', 100))
-#     best_item = items_sorted[0]
-#     date = best_item.datetime.strftime('%Y-%m-%d')
-#     cloud = best_item.properties.get('eo:cloud_cover', 0)
-#
-#     print(f"📅 Znaleziono zdjęcie: {date} (chmury: {cloud:.1f}%)")
-#     print(f"   📌 ID sceny: {best_item.id}")
-#     print(f"   📦 BBOX żądany: {bbox}")
-#
-#     bands = ["B01", "B02", "B03", "B04", "B05", "B06",
-#              "B07", "B08", "B8A", "B09", "B11", "B12"]
-#
-#     data = odc.stac.load([best_item], bands=bands, bbox=bbox, resolution=10)
-#     stacked = np.stack([data[b].values[0] for b in bands], axis=0)
-#
-#     print(f"   📐 Rozmiar danych: {stacked.shape}")
-#     return stacked, date, best_item.id
-
+# Input data format: (12, H, W) numpy array (12 Sentinel-2 bands)
 def prepare_input(data_12ch):
+    """
+    Preprocesses raw satellite data tensor for model inference.
+    Normalizes, resizes, and converts to PyTorch tensor.
+
+    Args:
+        data_12ch: numpy array of shape (12, H, W) with 12 Sentinel-2 bands
+
+    Returns:
+        torch.Tensor of shape (1, 12, 224, 224) ready for model inference
+    """
     tensor = torch.from_numpy(data_12ch.astype(np.float32))
     tensor = torch.nan_to_num(tensor, nan=0.0)
 
@@ -291,7 +285,17 @@ def prepare_input(data_12ch):
     return transform(tensor).unsqueeze(0)
 
 def run_inference(model, input_tensor):
-    print(f"🔄 Uruchamianie modelu AI...")
+    """
+    Executes AI model inference on preprocessed satellite data.
+
+    Args:
+        model: TerraMind neural network model
+        input_tensor: torch.Tensor of shape (1, 12, 224, 224)
+
+    Returns:
+        torch.Tensor containing LULC (Land Use Land Cover) predictions
+    """
+    print(f"[RUNNING] Running AI model...")
     with torch.no_grad():
         output = model(
             {"S2L2A": input_tensor.to(device)},
@@ -301,6 +305,16 @@ def run_inference(model, input_tensor):
     return output["LULC"].detach()
 
 def decode_output(lulc_tensor):
+    """
+    Converts model output tensor to class map with ESA WorldCover labels.
+    Maps class indices to standardized ESA class codes.
+
+    Args:
+        lulc_tensor: Model output tensor (4D or 3D depending on inference mode)
+
+    Returns:
+        numpy.ndarray with ESA class codes (0-100)
+    """
     if lulc_tensor.ndim == 4 and lulc_tensor.shape[1] > 1:
         class_indices = lulc_tensor.argmax(dim=1)[0].cpu().numpy()
         if class_indices.max() <= 11:
@@ -312,6 +326,16 @@ def decode_output(lulc_tensor):
     return class_map
 
 def calculate_spectral_indices(input_tensor):
+    """
+    Calculates spectral indices from Sentinel-2 multispectral bands.
+    Includes: NDWI, MNDWI, AWEI, NDVI, EVI, NDBI, BSI.
+
+    Args:
+        input_tensor: torch.Tensor containing 12 Sentinel-2 bands
+
+    Returns:
+        dict with spectral indices as numpy arrays
+    """
     blue = input_tensor[0, 1].cpu().numpy() / 10000.0
     green = input_tensor[0, 2].cpu().numpy() / 10000.0
     red = input_tensor[0, 3].cpu().numpy() / 10000.0
@@ -331,39 +355,55 @@ def calculate_spectral_indices(input_tensor):
 
     return indices
 
-# 🆕 Funkcja generująca maski dla każdego wskaźnika
 def generate_index_masks(indices):
     """
-    Tworzy binarne maski dla każdego wskaźnika spektralnego.
-    Zwraca dict z maskami jako numpy arrays (True/False).
+    Generates binary masks for each spectral vegetation and water index.
+    Uses predefined thresholds to create masks for water, vegetation, buildings, bare soil.
+
+    Args:
+        indices: dict with spectral indices (ndwi, mndwi, awei, ndvi, evi, ndbi, bsi)
+
+    Returns:
+        dict with 7 binary masks as numpy boolean arrays
     """
     masks = {}
 
-    # Maska wody (NDWI)
+    # Water mask (NDWI)
     masks['water_ndwi'] = indices['ndwi'] > NDWI_THRESHOLD
 
-    # Maska wody (MNDWI)
+    # Water mask (MNDWI)
     masks['water_mndwi'] = indices['mndwi'] > MNDWI_THRESHOLD
 
-    # Maska wody (AWEI)
+    # Water mask (AWEI)
     masks['water_awei'] = indices['awei'] > 0
 
-    # Maska roślinności (NDVI)
+    # Vegetation mask (NDVI)
     masks['vegetation_ndvi'] = indices['ndvi'] > NDVI_THRESHOLD
 
-    # Maska roślinności (EVI)
+    # Vegetation mask (EVI)
     masks['vegetation_evi'] = indices['evi'] > 0.3
 
-    # Maska zabudowy (NDBI)
+    # Buildings mask (NDBI)
     masks['buildings_ndbi'] = (indices['ndbi'] > NDBI_THRESHOLD) & (indices['ndvi'] < 0.2)
 
-    # Maska gołego gruntu (BSI)
+    # Bare soil mask (BSI)
     masks['baresoil_bsi'] = (indices['bsi'] > BSI_THRESHOLD) & (indices['ndvi'] < 0.1)
 
     return masks
 
 def apply_hybrid_corrections(class_map, indices):
-    """Zwraca mapę z korektami ORAZ mapy pośrednie."""
+    """
+    Applies hybrid corrections to raw model output using spectral indices.
+    Corrects water, vegetation, buildings, and bare soil classifications.
+    Creates correction layers showing where corrections were applied.
+
+    Args:
+        class_map: numpy array with ESA class codes from raw model
+        indices: dict with calculated spectral indices
+
+    Returns:
+        tuple of (corrected_class_map, correction_layers_dict)
+    """
     hybrid_map = class_map.copy()
     correction_layers = {}
 
@@ -394,11 +434,21 @@ def apply_hybrid_corrections(class_map, indices):
     return hybrid_map, correction_layers
 
 # =========================================
-# 🆕 FUNKCJE WIZUALIZACJI MASEK
+# NEW: MASK VISUALIZATION FUNCTIONS
 # =========================================
 
 def create_rgb_image(input_tensor, brightness=BRIGHTNESS_BOOST):
-    """Tworzy obraz RGB z tensora wejściowego."""
+    """
+    Creates natural color RGB image from Sentinel-2 multispectral tensor.
+    Uses red, green, blue bands with brightness scaling and normalization.
+
+    Args:
+        input_tensor: torch.Tensor with 12 Sentinel-2 bands
+        brightness: float - brightness multiplier (default 2.5)
+
+    Returns:
+        numpy.ndarray (H, W, 3) uint8 RGB image
+    """
     red = input_tensor[0, 3].cpu().numpy()
     green = input_tensor[0, 2].cpu().numpy()
     blue = input_tensor[0, 1].cpu().numpy()
@@ -415,7 +465,16 @@ def create_rgb_image(input_tensor, brightness=BRIGHTNESS_BOOST):
     return rgb_uint8
 
 def create_segmentation_image(class_map):
-    """Tworzy kolorową mapę segmentacji."""
+    """
+    Converts class map to colored segmentation visualization.
+    Maps ESA class codes to predefined RGB colors for display.
+
+    Args:
+        class_map: numpy array with ESA class codes (0-100)
+
+    Returns:
+        numpy.ndarray (H, W, 3) uint8 RGB image with class colors
+    """
     h, w = class_map.shape
     rgb = np.zeros((h, w, 3), dtype=np.uint8)
 
@@ -425,60 +484,37 @@ def create_segmentation_image(class_map):
 
     return rgb
 
-# def create_segmentation_image(class_map, alpha=180):
-#     """
-#     Tworzy kolorową mapę segmentacji z kanałem alfa.
-#     alpha: 0 (całkowicie przezroczysty) do 255 (nieprzezroczysty)
-#     """
-#     h, w = class_map.shape
-#     # Tworzymy tablicę RGBA (4 kanały)
-#     rgba = np.zeros((h, w, 4), dtype=np.uint8)
-#
-#     for class_id, color in ESA_COLORS.items():
-#         mask = class_map == class_id
-#         rgba[mask, :3] = color  # Kopiujemy R, G, B
-#         rgba[mask, 3] = alpha  # Ustawiamy przezroczystość dla tej klasy
-#
-#     return rgba
-
 def create_mask_visualization(mask, color=[255, 0, 0]):
     """
-    Tworzy wizualizację maski binarnej.
+    Creates colored visualization of binary mask.
+    Renders mask pixels in specified color with gray background for contrast.
 
     Args:
-        mask: numpy array bool (True/False)
-        color: kolor dla True pikseli [R, G, B]
+        mask: numpy boolean array (True/False)
+        color: list [R, G, B] for True pixels (default red [255, 0, 0])
 
     Returns:
-        numpy array RGB (transparentne tło, kolorowa maska)
+        numpy.ndarray (H, W, 3) uint8 RGB image with mask visualization
     """
     h, w = mask.shape
-    rgb = np.ones((h, w, 3), dtype=np.uint8) * 255  # Białe tło
+    rgb = np.ones((h, w, 3), dtype=np.uint8) * 255  # White background
 
-    rgb[mask] = color  # Zamaluj maskę kolorem
-    rgb[~mask] = [240, 240, 240]  # Szare tło dla lepszej widoczności
+    rgb[mask] = color  # Fill mask with color
+    rgb[~mask] = [240, 240, 240]  # Gray background for better visibility
 
     return rgb
 
-# def create_mask_visualization(mask, color=[255, 0, 0], alpha=180):
-#     """
-#     Tworzy wizualizację maski binarnej na przezroczystym tle.
-#     """
-#     h, w = mask.shape
-#     # 4 kanały: R, G, B, A
-#     rgba = np.zeros((h, w, 4), dtype=np.uint8)
-#
-#     # Piksele należące do maski otrzymują kolor i wybraną przezroczystość
-#     rgba[mask, :3] = color
-#     rgba[mask, 3] = alpha
-#
-#     # Piksele poza maską (~mask) mają już 0 w kanale alfa dzięki np.zeros,
-#     # więc są całkowicie przezroczyste.
-#
-#     return rgba
-
 def calculate_class_percentages(class_map):
-    """Oblicza procentowy udział każdej klasy."""
+    """
+    Calculates pixel count and percentage coverage for each ESA class.
+    Includes class names and statistics for result reporting.
+
+    Args:
+        class_map: numpy array with ESA class codes
+
+    Returns:
+        dict with class statistics {class_id: {name, count, percentage}}
+    """
     total_pixels = class_map.size
     percentages = {}
 
@@ -494,116 +530,137 @@ def calculate_class_percentages(class_map):
     return percentages
 
 def image_to_base64(image_array):
-    """Konwertuje numpy array do base64 string (dla frontendu)."""
+    """
+    Encodes numpy image array to base64-encoded PNG string for transmission.
+
+    Args:
+        image_array: numpy.ndarray containing image data
+
+    Returns:
+        str - base64-encoded PNG image suitable for HTML/JSON transmission
+    """
     img = Image.fromarray(image_array)
     buffer = BytesIO()
     img.save(buffer, format='PNG')
     return base64.b64encode(buffer.getvalue()).decode('utf-8')
 
 # =========================================
-# GŁÓWNA FUNKCJA ANALITYCZNA
+# MAIN ANALYTICAL FUNCTION
 # =========================================
 
 def analyze(location_data, buffer_km=DEFAULT_BUFFER_KM, max_cloud_cover=DEFAULT_MAX_CLOUD_COVER,
             days_back=DEFAULT_DAYS_BACK, show_visualization=False, save_files=False, model_name="terramind_v1_large_generate"):
     """
-    Główna funkcja wywoływana przez Flask.
+    Main analysis pipeline for land cover classification and spectral analysis.
+    Downloads Sentinel-2 data, runs AI model, applies corrections, generates visualizations.
+
+    Args:
+        location_data: list/tuple [lat, lon] or str place name
+        buffer_km: int - search radius in kilometers (default 5)
+        max_cloud_cover: int - maximum cloud percentage (default 10)
+        days_back: int - days to search back (default 180)
+        show_visualization: bool - display plots (not used in API)
+        save_files: bool - save results to disk (not used in API)
+        model_name: str - TerraMind model name
 
     Returns:
-        dict z wszystkimi obrazami (RGB, surowy model, maski wskaźników, finał)
+        dict with success status, images (base64), masks, statistics, metadata
+
+    Example:
+        result = analyze([50.0540, 19.9352], buffer_km=5, max_cloud_cover=20)
     """
 
     lat, lon = None, None
     title = "Unknown"
 
-    # 1. Rozpoznanie typu danych
+    # 1. Recognize data type
     if isinstance(location_data, list) or isinstance(location_data, tuple):
         lat, lon = location_data
         title = f"{lat:.4f}N, {lon:.4f}E"
     elif isinstance(location_data, str):
         coords = get_coordinates_from_name(location_data)
         if not coords:
-            print("❌ Nie znaleziono współrzędnych dla podanej nazwy.")
+            print("[ERROR] Coordinates not found for given name.")
             return None
         lat, lon = coords
         title = location_data
     else:
-        print("❌ Nieprawidłowy format lokalizacji")
+        print("[ERROR] Invalid location format")
         return None
 
     print(f"\n{'='*60}")
-    print(f"🌍 ROZPOCZĘCIE ANALIZY: {title}")
+    print(f"[START] ANALYSIS START: {title}")
     print(f"{'='*60}")
-    print(f"📍 Współrzędne: {lat:.6f}, {lon:.6f}")
-    print(f"📏 Promień: {buffer_km} km")
-    print(f"☁️ Max zachmurzenie: {max_cloud_cover}%")
-    print(f"📅 Dni wstecz: {days_back}")
+    print(f"[LOCATION] Coordinates: {lat:.6f}, {lon:.6f}")
+    print(f"[RADIUS] Radius: {buffer_km} km")
+    print(f"[CLOUDS] Max cloud cover: {max_cloud_cover}%")
+    print(f"[HISTORY] Days back: {days_back}")
     print(f"{'='*60}\n")
 
-    # 2. Pobranie danych
+    # 2. Download data
     result = download_sentinel2(lat, lon, buffer_km, max_cloud_cover, days_back)
     if result is None:
         return None
     data, date, scene_id = result
 
-    # Zapisz oryginalny rozmiar przed skalowaniem
+    # Save original size before scaling
     original_height, original_width = data.shape[1], data.shape[2]
 
-    # 3. Przetwarzanie i AI
+    # 3. Process and run AI
     input_tensor = prepare_input(data)
-    print(f"🔢 Rozmiar tensora wejściowego: {input_tensor.shape}")
+    print(f"[TENSOR] Input tensor size: {input_tensor.shape}")
 
     model = get_model(model_name)
     lulc_output = run_inference(model, input_tensor)
 
-    # 4. Dekodowanie (SUROWY model - bez korekcji)
+    # 4. Decode (RAW model - without corrections)
     class_map_raw = decode_output(lulc_output)
 
-    # 5. Oblicz wskaźniki spektralne
+    # 5. Calculate spectral indices
     indices = calculate_spectral_indices(input_tensor)
 
-    # 6. Generuj maski dla wskaźników
+    # 6. Generate masks for indices
     index_masks = generate_index_masks(indices)
 
-    # 7. Zastosuj korekty (finalna mapa)
+    # 7. Apply corrections (final map)
     class_map_final, correction_layers = apply_hybrid_corrections(class_map_raw, indices)
 
     # =========================================
-    # 🎨 GENEROWANIE WSZYSTKICH OBRAZÓW
+    # GENERATING ALL VISUALIZATIONS
     # =========================================
 
-    print("🎨 Generowanie wizualizacji...")
+    print("[VISUALIZATION] Generating visualizations...")
 
-    # 1. RGB (satelitarny)
+    # 1. RGB (satellite)
     rgb_image = create_rgb_image(input_tensor)
 
-    # 2. Surowy TerraMind (bez korekcji)
+    # 2. Raw TerraMind (without corrections)
     raw_segmentation = create_segmentation_image(class_map_raw)
 
-    # 3. Finalna segmentacja (z korektami)
+    # 3. Final segmentation (with corrections)
     final_segmentation = create_segmentation_image(class_map_final)
 
-    # 4. Maski wskaźników
+    # 4. Index masks
     mask_images = {}
     mask_colors = {
-        'water_ndwi': [0, 150, 255],      # Niebieski
-        'water_mndwi': [0, 100, 200],     # Ciemny niebieski
-        'water_awei': [100, 200, 255],    # Jasny niebieski
-        'vegetation_ndvi': [0, 150, 0],   # Zielony
-        'vegetation_evi': [50, 200, 50],  # Jasny zielony
-        'buildings_ndbi': [255, 0, 0],    # Czerwony
-        'baresoil_bsi': [180, 140, 100],  # Brązowy
+        'water_ndwi': [0, 150, 255],      # Blue
+        'water_mndwi': [0, 100, 200],     # Dark blue
+        'water_awei': [100, 200, 255],    # Light blue
+        'vegetation_ndvi': [0, 150, 0],   # Green
+        'vegetation_evi': [50, 200, 50],  # Light green
+        'buildings_ndbi': [255, 0, 0],    # Red
+        'baresoil_bsi': [180, 140, 100],  # Brown
     }
 
     for mask_name, mask in index_masks.items():
         color = mask_colors.get(mask_name, [128, 128, 128])
         mask_images[mask_name] = create_mask_visualization(mask, color)
 
-    # 5. Statystyki
+    # 5. Statistics
     statistics = calculate_class_percentages(class_map_final)
 
     # =========================================
-    # 📦 PRZYGOTOWANIE WYNIKU
+    # PREPARING RESULT
     # =========================================
 
     frontend_result = {
@@ -615,44 +672,44 @@ def analyze(location_data, buffer_km=DEFAULT_BUFFER_KM, max_cloud_cover=DEFAULT_
         'scene_id': scene_id,
         'statistics': statistics,
 
-        # OBRAZY GŁÓWNE
+        # MAIN IMAGES
         'rgb_base64': image_to_base64(rgb_image),
         'raw_segmentation_base64': image_to_base64(raw_segmentation),
         'segmentation_base64': image_to_base64(final_segmentation),
 
-        # MASKI WSKAŹNIKÓW
+        # INDEX MASKS
         'masks': {
             mask_name: image_to_base64(mask_img)
             for mask_name, mask_img in mask_images.items()
         },
 
-        # Dla kompatybilności z frontendem
+        # For frontend compatibility
         'class_map': class_map_final.tolist(),
 
-        # Wymiary oryginalnego obrazu
+        # Original image dimensions
         'image_width': original_width,
         'image_height': original_height
     }
 
-    print("✅ Analiza zakończona sukcesem!")
+    print("[SUCCESS] Analysis completed successfully!")
 
     return frontend_result
 
 if __name__ == "__main__":
     print("\n" + "="*70)
-    print("🧪 TRYB TESTOWY - terramindFunctions.py")
+    print("[TEST] TEST MODE - terramindFunctions.py")
     print("="*70)
 
     result = analyze([50.0540, 19.9352], buffer_km=3, max_cloud_cover=10, days_back=60)
 
     if result:
         print("\n" + "="*70)
-        print("📦 WYGENEROWANE OBRAZY:")
+        print("[RESULT] GENERATED IMAGES:")
         print("="*70)
-        print(f"  ✅ RGB: {len(result['rgb_base64'])} chars")
-        print(f"  ✅ Surowy TerraMind: {len(result['raw_segmentation_base64'])} chars")
-        print(f"  ✅ Finalna segmentacja: {len(result['segmentation_base64'])} chars")
-        print(f"  ✅ Maski wskaźników: {len(result['masks'])} sztuk")
+        print(f"  [OK] RGB: {len(result['rgb_base64'])} chars")
+        print(f"  [OK] Raw TerraMind: {len(result['raw_segmentation_base64'])} chars")
+        print(f"  [OK] Final segmentation: {len(result['segmentation_base64'])} chars")
+        print(f"  [OK] Index masks: {len(result['masks'])} pieces")
         for mask_name in result['masks'].keys():
             print(f"      - {mask_name}")
         print("="*70)

io-app-front/README.md

@@ -1,73 +0,0 @@
-# React + TypeScript + Vite
-
-This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
-
-Currently, two official plugins are available:
-
-- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
-- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
-
-## React Compiler
-
-The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
-
-## Expanding the ESLint configuration
-
-If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
-
-```js
-export default defineConfig([
-  globalIgnores(['dist']),
-  {
-    files: ['**/*.{ts,tsx}'],
-    extends: [
-      // Other configs...
-
-      // Remove tseslint.configs.recommended and replace with this
-      tseslint.configs.recommendedTypeChecked,
-      // Alternatively, use this for stricter rules
-      tseslint.configs.strictTypeChecked,
-      // Optionally, add this for stylistic rules
-      tseslint.configs.stylisticTypeChecked,
-
-      // Other configs...
-    ],
-    languageOptions: {
-      parserOptions: {
-        project: ['./tsconfig.node.json', './tsconfig.app.json'],
-        tsconfigRootDir: import.meta.dirname,
-      },
-      // other options...
-    },
-  },
-])
-```
-
-You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
-
-```js
-// eslint.config.js
-import reactX from 'eslint-plugin-react-x'
-import reactDom from 'eslint-plugin-react-dom'
-
-export default defineConfig([
-  globalIgnores(['dist']),
-  {
-    files: ['**/*.{ts,tsx}'],
-    extends: [
-      // Other configs...
-      // Enable lint rules for React
-      reactX.configs['recommended-typescript'],
-      // Enable lint rules for React DOM
-      reactDom.configs.recommended,
-    ],
-    languageOptions: {
-      parserOptions: {
-        project: ['./tsconfig.node.json', './tsconfig.app.json'],
-        tsconfigRootDir: import.meta.dirname,
-      },
-      // other options...
-    },
-  },
-])
-```

io-app-front/index.html

@@ -2,9 +2,11 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>TerraMind Spectral Gaze</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Google+Sans:ital,opsz,wght@0,17..18,400..700;1,17..18,400..700&display=swap" rel="stylesheet">
+    <title>TerraEye</title>
   </head>
   <body>
     <div id="root"></div>

io-app-front/src/App.jsx

@@ -1,26 +1,34 @@
 import { useState } from "react"
 import AnalysisPanel from './components/AnalysisPanel/AnalysisPanel'
 import MapView from './components/MapView/MapView'
-import { MantineProvider } from '@mantine/core'
+import { MantineProvider, createTheme } from '@mantine/core'
 import '@mantine/core/styles.css'
 
+const theme = createTheme({
+  fontFamily: 'Google Sans, sans-serif',
+  headings: {
+    fontFamily: 'Google Sans, sans-serif',
+  },
+});
+
 function App() {
   const [selectedLocation, setSelectedLocation] = useState(null);
   const [analysisResult, setAnalysisResult] = useState(null);
   const [layersConfig, setLayersConfig] = useState({
-    firstLayer: 'rgb',      // Warstwa bazowa
-    secondLayer: 'image',    // Warstwa nakładana (overlay)
+    firstLayer: 'rgb',
+    secondLayer: 'image',
   });
+
   const handleAnalysisComplete = (data) => {
     setAnalysisResult(data);
   };
+
   const handleLocationChange = (locationData) => {
     setSelectedLocation(locationData);
   };
 
   return (
-    <MantineProvider forceColorScheme='dark'>
-
+    <MantineProvider forceColorScheme='dark' theme={ theme }>
       <AnalysisPanel
         selectedLocation={selectedLocation}
         onLocationSelect={handleLocationChange}
@@ -29,16 +37,14 @@ function App() {
         onLayersChange={setLayersConfig}
         analysisResult={analysisResult}
       />
-
       <MapView
         selectedLocation={selectedLocation}
-        onLocationSelect={handleLocationChange} // Mapa może też zmieniać lokalizację (kliknięcie)
+        onLocationSelect={handleLocationChange}
         analysisResult={analysisResult}
         layersConfig={layersConfig}
       />
-
     </MantineProvider>
-  );
+  )
 }
 
 export default App

io-app-front/src/components/AdvancedAnalysisModal/AdvancedAnalysisModal.jsx

@@ -55,14 +55,13 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
     >
       <Stack gap="xl" h="100%">
 
-        {/* --- STAN: WYBÓR MODELI --- */}
         {!results && (
           <Center h={500}>
             <Stack align="center" gap="xl" w="100%" maw={600}>
               <Text size="lg" fw={500} c="dimmed" lts={1}>SELECT MODELS TO COMPARE</Text>
               <Group grow w="100%">
-                <Select label="Model A" data={modelOptions} value={modelA} onChange={setModelA} disabled={isLoading} />
-                <Select label="Model B" data={modelOptions} value={modelB} onChange={setModelB} disabled={isLoading} />
+                <Select label="Model A" data={modelOptions} allowDeselect={false} value={modelA} onChange={setModelA} disabled={isLoading} />
+                <Select label="Model B" data={modelOptions} allowDeselect={false} value={modelB} onChange={setModelB} disabled={isLoading} />
               </Group>
               <Button fullWidth size="lg" color="blue" onClick={() => onRunCompare(modelA, modelB)} loading={isLoading}>
                 START ANALYSIS
@@ -71,30 +70,25 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
           </Center>
         )}
 
-        {/* --- STAN: WYNIKI (2 KOLUMNY) --- */}
         {results && !isLoading && (
           <div className={classes.dualLayout}>
 
-            {/* LEWA KOLUMNA */}
             <div className={classes.modelColumn}>
               <div className={classes.columnHeader}>{getModelLabel(modelA)}</div>
 
               <div className={classes.imagesGrid}>
-                {/* 1. RGB */}
                 <ImageCard
                   src={results.modelA.rgb}
                   title="Satellite RGB"
                   subtitle=""
                   borderColor="#1971c2"
                 />
-                {/* 2. Raw */}
                 <ImageCard
                   src={results.modelA.raw_segmentation}
                   title="Raw Output"
                   subtitle=""
                   borderColor="#f08c00"
                 />
-                {/* 3. Final */}
                 <ImageCard
                   src={results.modelA.image}
                   title="Output(with Spectral Indices)"
@@ -104,26 +98,22 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
               </div>
             </div>
 
-            {/* PRAWA KOLUMNA */}
             <div className={classes.modelColumn}>
               <div className={classes.columnHeader}>{getModelLabel(modelB)}</div>
 
               <div className={classes.imagesGrid}>
-                {/* 1. RGB */}
                 <ImageCard
                   src={results.modelB.rgb}
                   title="Satellite RGB"
                   subtitle=""
                   borderColor="#1971c2"
                 />
-                {/* 2. Raw */}
                 <ImageCard
                   src={results.modelB.raw_segmentation}
                   title="Raw Output"
                   subtitle=""
                   borderColor="#f08c00"
                 />
-                {/* 3. Final */}
                 <ImageCard
                   src={results.modelB.image}
                   title="Output(with Spectral Indices)"
@@ -133,7 +123,6 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
               </div>
             </div>
 
-            {/* MASKI (NA DOLE) */}
             <div className={classes.masksSection}>
               <div className={classes.masksHeader}>Spectral Indices Masks</div>
               <div className={classes.masksGrid}>
@@ -155,16 +144,13 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
               </div>
             </div>
 
-            {/* METRYKI */}
             {results.metrics && (
               <div className={classes.metricsSection}>
 
-                {/* METRYKI DLA RAW SEGMENTATION */}
                 {results.metrics.raw && (
                   <div className={classes.metricsSubsection}>
                     <div className={classes.metricsHeader}>Metrics - Raw Segmentation (without Spectral Indices)</div>
 
-                    {/* Główne metryki */}
                     <div className={classes.mainMetricsGrid}>
                       <MetricCard
                         label="Pixel Accuracy"
@@ -204,7 +190,6 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
                       />
                     </div>
 
-                    {/* Metryki dla każdej klasy - RAW */}
                     {results.metrics.raw.class_details && Object.keys(results.metrics.raw.class_details).length > 0 && (
                       <div className={classes.classDetailsSection}>
                         <div className={classes.classDetailsHeader}>Per-Class Metrics</div>
@@ -234,12 +219,10 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
                   </div>
                 )}
 
-                {/* METRYKI DLA CORRECTED SEGMENTATION */}
                 {results.metrics.corrected && (
                   <div className={classes.metricsSubsection}>
                     <div className={classes.metricsHeader}>Metrics - Corrected Segmentation (with Spectral Indices)</div>
 
-                    {/* Główne metryki */}
                     <div className={classes.mainMetricsGrid}>
                       <MetricCard
                         label="Pixel Accuracy"
@@ -279,7 +262,6 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
                       />
                     </div>
 
-                    {/* Metryki dla każdej klasy - CORRECTED */}
                     {results.metrics.corrected.class_details && Object.keys(results.metrics.corrected.class_details).length > 0 && (
                       <div className={classes.classDetailsSection}>
                         <div className={classes.classDetailsHeader}>Per-Class Metrics</div>
@@ -319,7 +301,6 @@ export default function AdvancedAnalysisModal({ opened, onClose, onRunCompare, i
   );
 }
 
-// KOMPONENT KARTY (Czysty, z Twoimi stylami ramki)
 function ImageCard({ src, title, subtitle, borderColor }) {
   return (
     <div className={classes.imageCard}>
@@ -332,7 +313,6 @@ function ImageCard({ src, title, subtitle, borderColor }) {
   );
 }
 
-// KOMPONENT KARTY METRYK
 function MetricCard({ label, value, unit, color, highlight = false }) {
   return (
     <div className={classes.metricCard} style={{

io-app-front/src/components/AdvancedAnalysisModal/AdvancedAnalysisModal.module.css

@@ -1,6 +1,4 @@
-/* --- GŁÓWNY MODAL --- */
 .modalContent {
-    /* Ciemne, szklane tło */
     background-color: rgba(15, 15, 18, 0.95) !important;
     backdrop-filter: blur(40px) saturate(180%) !important;
     border: 1px solid rgba(255, 255, 255, 0.08) !important;
@@ -21,17 +19,15 @@
 .modalBody { background: transparent !important; padding: 0 32px 32px 32px !important; }
 .modalTitle { font-size: 1.25rem; font-weight: 700; letter-spacing: 0.5px; color: white; }
 
-/* --- UKŁAD DWUKOLUMNOWY (GRID) --- */
 .dualLayout {
     display: grid;
-    grid-template-columns: 1fr 1fr; /* Dwie równe kolumny */
-    gap: 32px; /* Odstęp między Modelem A i B */
+    grid-template-columns: 1fr 1fr;
+    gap: 32px;
     align-items: start;
 }
 
-/* Pojedyncza sekcja modelu (lewa lub prawa) */
 .modelColumn {
-    background-color: rgba(255, 255, 255, 0.03); /* Bardzo subtelne tło kolumny */
+    background-color: rgba(255, 255, 255, 0.03);
     border: 1px solid rgba(255, 255, 255, 0.06);
     border-radius: 12px;
     padding: 24px;
@@ -49,15 +45,12 @@
     border-bottom: 1px solid rgba(255, 255, 255, 0.1);
 }
 
-/* --- GRID OBRAZÓW (Dokładnie jak w Twoim przykładzie) --- */
 .imagesGrid {
     display: grid;
-    /* To wymusza minimalną szerokość 280px. */
     grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
     gap: 20px;
 }
 
-/* --- KARTA OBRAZU --- */
 .imageCard {
     text-align: center;
     background: rgba(0, 0, 0, 0.2);
@@ -78,13 +71,12 @@
     margin-bottom: 10px;
 }
 
-/* Ramka obrazka */
 .cardFrame {
     width: 100%;
     background-color: #000;
     border-radius: 8px;
     border-width: 2px;
-    border-style: solid; /* Kolor z propsa */
+    border-style: solid;
     overflow: hidden;
     box-shadow: 0 4px 20px rgba(0,0,0,0.4);
 }
@@ -102,9 +94,8 @@
     color: rgba(255, 255, 255, 0.5);
 }
 
-/* --- SEKCJA MASEK (Dół) --- */
 .masksSection {
-    grid-column: 1 / -1; /* Rozciągnij na obie kolumny */
+    grid-column: 1 / -1;
     background-color: rgba(255, 255, 255, 0.02);
     border: 1px solid rgba(255, 255, 255, 0.06);
     border-radius: 12px;
@@ -121,7 +112,6 @@
     text-transform: uppercase;
 }
 
-/* Grid masek (Twoje 250px) */
 .masksGrid {
     display: grid;
     grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
@@ -129,7 +119,7 @@
 }
 
 .maskCard {
-    border: 1px solid; /* Kolor z propsa */
+    border: 1px solid;
     border-radius: 8px;
     overflow: hidden;
     background: rgba(0, 0, 0, 0.3);
@@ -141,7 +131,7 @@
     padding: 8px 12px;
     font-size: 0.8rem;
     font-weight: 700;
-    color: white; /* Tło z propsa */
+    color: white;
 }
 
 .maskImg {
@@ -171,9 +161,8 @@
     display: inline-block;
 }
 
-/* --- SEKCJA METRYK --- */
 .metricsSection {
-    grid-column: 1 / -1; /* Rozciągnij na obie kolumny */
+    grid-column: 1 / -1;
     background-color: rgba(255, 255, 255, 0.02);
     border: 1px solid rgba(255, 255, 255, 0.06);
     border-radius: 12px;
@@ -181,7 +170,6 @@
     margin-top: 20px;
 }
 
-/* Podsekcja metryk (raw/corrected) */
 .metricsSubsection {
     margin-bottom: 32px;
 }
@@ -201,7 +189,6 @@
     letter-spacing: 0.5px;
 }
 
-/* Grid głównych metryk */
 .mainMetricsGrid {
     display: grid;
     grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
@@ -249,7 +236,6 @@
     font-weight: 500;
 }
 
-/* --- SEKCJA METRYK PER-CLASS --- */
 .classDetailsSection {
     margin-top: 24px;
     border-top: 1px solid rgba(255, 255, 255, 0.06);

io-app-front/src/components/AnalysisOptions/AnalysisOptions.jsx

@@ -55,11 +55,12 @@ export default function AnalysisOptions({ values, onChange }) {
 
       <Select
         label="Model Version"
+        allowDeselect={false}
         data={[
-          { value: 'terramind_v1_large_generate', label: 'Terramind v1 Large' },
-          { value: 'terramind_v1_base_generate', label: 'Terramind v1 Base' },
-          { value: 'terramind_v1_small_generate', label: 'Terramind v1 Small' },
           { value: 'terramind_v1_tiny_generate', label: 'Terramind v1 Tiny' },
+          { value: 'terramind_v1_small_generate', label: 'Terramind v1 Small' },
+          { value: 'terramind_v1_base_generate', label: 'Terramind v1 Base' },
+          { value: 'terramind_v1_large_generate', label: 'Terramind v1 Large' },
         ]}
         value={values.model}
         onChange={(val) => handleChange('model', val)}

io-app-front/src/components/AnalysisOptions/AnalysisOptions.module.css

@@ -8,7 +8,7 @@
 .inputLabel {
     font-size: 13px !important;
     font-weight: 600 !important;
-    color: #868e96 !important; /* odpowiednik dimmed */
+    color: #868e96 !important;
     margin-bottom: 5px;
 }
 

io-app-front/src/components/AnalysisPanel/AnalysisPanel.jsx

@@ -37,7 +37,7 @@ function AnalysisPanel({
   return (
     <div className={styles.sidebar}>
       <div className={styles.scrollArea}>
-        <Title order={3} c="white" mb="md">TerraMind Spectral Gaze</Title>
+        <Title order={3} c="white" mb="md">TerraEye</Title>
 
         <SearchBar onLocationSelect={onLocationSelect} />
 

io-app-front/src/components/LayerOpacitySlider/LayerOpacitySlider.module.css

@@ -1,7 +1,7 @@
 .floatingContainer {
     position: absolute;
     bottom: 40px;
-    left: 50%;
+    left: calc(31% + 500px);
     transform: translateX(-50%);
     width: 600px;
     z-index: 20;
@@ -20,3 +20,4 @@
 .sliderWidth {
     width: 100%;
 }
+

io-app-front/src/components/SearchBar/SearchBar.module.css

@@ -2,6 +2,7 @@
     background-color: #25262b;
     color: #fff;
     border-color: #373a40;
+    border-radius: 20px;
 }
 
 .searchInput:focus {

io-app-front/src/hooks/useMap.js

@@ -36,6 +36,14 @@ export const useMap = (mapContainerRef, mapboxAccessToken, selectedLocation, ana
       'bottom-right'
     );
 
+    mapRef.current.addControl(
+      new mapboxgl.NavigationControl({
+        showZoom: true,
+        showCompass: false
+      }),
+      'bottom-right'
+    );
+
     return () => {
       mapRef.current?.remove();
       markerRef.current?.remove();

io-app-front/src/utils/mapUtils.js

@@ -41,7 +41,20 @@ export const CLASS_METADATA = {
   'Tereny podmokłe': { label: 'Flooded vegetation', color: 'rgb(0, 150, 160)' },
   'Namorzyny': { label: 'Mangroves', color: 'rgb(0, 207, 117)' },
   'Mchy i porosty': { label: 'Moss & Lichen', color: 'rgb(250, 230, 160)' },
-  'Brak danych': { label: 'No Data', color: 'rgb(100, 100, 100)' }
+  'Brak danych': { label: 'No Data', color: 'rgb(100, 100, 100)' },
+  // English labels returned by backend
+  'No data': { label: 'No data', color: 'rgb(100, 100, 100)' },
+  'Trees / Forest': { label: 'Trees / Forest', color: 'rgb(0, 100, 0)' },
+  'Shrubs': { label: 'Shrubs', color: 'rgb(255, 187, 34)' },
+  'Grass / Meadows': { label: 'Grass / Meadows', color: 'rgb(255, 255, 76)' },
+  'Cultivated crops': { label: 'Cultivated crops', color: 'rgb(240, 150, 255)' },
+  'Buildings': { label: 'Buildings', color: 'rgb(250, 0, 0)' },
+  'Bare ground': { label: 'Bare ground', color: 'rgb(180, 180, 180)' },
+  'Snow and ice': { label: 'Snow and ice', color: 'rgb(240, 240, 240)' },
+  'Water': { label: 'Water', color: 'rgb(0, 100, 200)' },
+  'Wetlands': { label: 'Wetlands', color: 'rgb(0, 150, 160)' },
+  'Mangroves': { label: 'Mangroves', color: 'rgb(0, 207, 117)' },
+  'Lichens and moss': { label: 'Lichens and moss', color: 'rgb(250, 230, 160)' }
 };
 
 export const getMetadata = (className) => {