File size: 7,092 Bytes
fab54be
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7db73fd
fab54be
 
7db73fd
fab54be
 
 
 
 
 
 
 
 
 
7db73fd
fab54be
 
7db73fd
fab54be
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
"""
Model service for loading and running PyTorch Lightning inference.
Implements thread-safe model loading and prediction with torch.no_grad() optimization.
"""

import os
import torch
import pytorch_lightning as pl
import segmentation_models_pytorch as smp
import numpy as np
from src import config

# Global model instance
_model = None


class DynamicEvalModel(pl.LightningModule):
    """
    PyTorch Lightning model wrapper for U-Net++ segmentation.
    Used for water/cloud segmentation tasks.
    """
    
    def __init__(self, **kwargs):
        super().__init__()
        self.save_hyperparameters()
        self.model_params = kwargs.get('model_params', {
            'model_type': 'unetplusplus',
            'encoder_name': 'resnet34',
            'in_channels': 6,
            'out_classes': 2
        })
        self._build_model()

    def _build_model(self):
        """Build the U-Net++ segmentation model."""
        self.model = smp.UnetPlusPlus(
            encoder_name=self.model_params.get('encoder_name', 'resnet34'),
            encoder_weights=None,
            in_channels=self.model_params.get('in_channels', 6),
            classes=self.model_params.get('out_classes', 2),
            activation=None
        )

    def forward(self, x):
        return self.model(x)


def initialize_model():
    """
    Load the PyTorch Lightning model from checkpoint.
    Model is placed on the configured device (GPU/CPU) and set to eval mode.
    """
    global _model
    
    config.logger.info("⏳ Loading model...")
    
    if not os.path.exists(config.CHECKPOINT_PATH):
        config.logger.error(f"❌ Model Checkpoint Not Found: {config.CHECKPOINT_PATH}")
        _model = None
        return None
    
    try:
        _model = DynamicEvalModel.load_from_checkpoint(
            config.CHECKPOINT_PATH,
            strict=False
        )
        _model.to(config.DEVICE)
        _model.eval()
        config.logger.info("✅ Model Loaded Successfully!")
        return _model
    except Exception as e:
        config.logger.error(f"❌ Model Load Failed: {e}")
        _model = None
        return None


def get_model():
    """Retrieve the loaded model instance."""
    return _model


def predict_water_mask(tiff_path):
    """
    Run inference on a TIFF image to predict water and cloud masks.
    
    Args:
        tiff_path: Path to the input TIFF file (6-channel optical image)
    
    Returns:
        Clean water mask (numpy array, uint8) or None on failure
    """
    import tifffile as tiff
    import cv2
    from src.services.cv2 import (
        apply_hanning_window, apply_cloud_detection,
        apply_water_detection, apply_morphological_cleanup,
        filter_small_contours
    )
    
    if _model is None or not os.path.exists(tiff_path):
        return None
    
    # Load and prepare image
    image = tiff.imread(tiff_path).astype(np.float32)
    
    if image.ndim == 3 and image.shape[2] == 6:
        image_tensor = np.transpose(image, (2, 0, 1))
    else:
        image_tensor = image.copy()
    
    # Normalize to [0, 1]
    scaled_tensor = np.clip(image_tensor / config.OPTICAL_NORMALIZATION_FACTOR, 0, 1)
    
    # Tiling parameters
    tile_size = config.TILE_SIZE
    overlap_ratio = config.TILE_OVERLAP_RATIO
    stride = int(tile_size * (1 - overlap_ratio))
    c, h, w = scaled_tensor.shape
    
    # Padding for tile overlap
    pad_h = (tile_size - (h % stride)) % stride + (tile_size - stride) if h % stride != 0 else 0
    pad_w = (tile_size - (w % stride)) % stride + (tile_size - stride) if w % stride != 0 else 0
    image_padded = np.pad(scaled_tensor, ((0, 0), (0, pad_h), (0, pad_w)), mode='reflect')
    
    padded_h, padded_w = image_padded.shape[1], image_padded.shape[2]
    
    # Initialize output maps
    prob_map_cloud = np.zeros((padded_h, padded_w), dtype=np.float32)
    prob_map_water = np.zeros((padded_h, padded_w), dtype=np.float32)
    count_map = np.zeros((padded_h, padded_w), dtype=np.float32)
    
    # Generate tile coordinates
    y_steps = list(range(0, padded_h - tile_size + 1, stride))
    x_steps = list(range(0, padded_w - tile_size + 1, stride))
    
    # Hanning window for smooth blending
    window_1d = np.hanning(tile_size)
    window_2d = np.outer(window_1d, window_1d).astype(np.float32)
    
    # Process tiles in batches
    tiles_batch = []
    coords_batch = []
    
    with torch.no_grad():  # Disable gradients for inference
        for y in y_steps:
            for x in x_steps:
                tile = image_padded[:, y:y+tile_size, x:x+tile_size]
                tiles_batch.append(tile)
                coords_batch.append((x, y))
                
                # Process batch when full or at end
                if len(tiles_batch) == config.BATCH_SIZE or (y == y_steps[-1] and x == x_steps[-1]):
                    batch_tensor = torch.from_numpy(np.stack(tiles_batch)).to(config.DEVICE)
                    logits = _model(batch_tensor)
                    probs = torch.sigmoid(logits).cpu().numpy()
                    
                    # Accumulate predictions
                    for i, (bx, by) in enumerate(coords_batch):
                        prob_cloud = probs[i, 0, :, :] * window_2d
                        prob_water = probs[i, 1, :, :] * window_2d
                        
                        prob_map_cloud[by:by+tile_size, bx:bx+tile_size] += prob_cloud
                        prob_map_water[by:by+tile_size, bx:bx+tile_size] += prob_water
                        count_map[by:by+tile_size, bx:bx+tile_size] += window_2d
                    
                    tiles_batch = []
                    coords_batch = []
    
    # Normalize by count map
    final_cloud_prob = (prob_map_cloud / (count_map + 1e-7))[:h, :w]
    final_water_prob = (prob_map_water / (count_map + 1e-7))[:h, :w]
    
    # Extract optical bands for cloud/water detection
    b2 = scaled_tensor[0, :h, :w]
    b3 = scaled_tensor[1, :h, :w]
    b4 = scaled_tensor[2, :h, :w]
    b8 = scaled_tensor[3, :h, :w]
    
    # Calculate brightness and NDWI
    brightness = np.sqrt(b2**2 + b3**2 + b4**2)
    ndwi = (b3 - b8) / (b3 + b8 + 1e-5)
    
    # Apply cloud detection
    base_cloud_mask = ((final_cloud_prob > config.CLOUD_DETECTION_THRESHOLD) & 
                       (brightness > config.BRIGHTNESS_THRESHOLD)).astype(np.uint8)
    
    # Dilate cloud mask for shadow buffering
    cloud_buffer_kernel = np.ones(config.CLOUD_BUFFER_KERNEL_SIZE, np.uint8)
    cloud_and_shadow_mask = cv2.dilate(base_cloud_mask, cloud_buffer_kernel, iterations=1)
    
    # Apply water detection
    raw_water_mask = (final_water_prob > config.NDWI_WATER_THRESHOLD) | (ndwi > config.NDWI_CLOUD_THRESHOLD)
    water_mask = raw_water_mask & (cloud_and_shadow_mask == 0) & (ndwi > config.NDWI_MIN_THRESHOLD)
    clean_mask = water_mask.astype(np.uint8)
    
    # Morphological cleanup
    clean_mask = apply_morphological_cleanup(clean_mask)
    
    # Remove small contours
    clean_mask = filter_small_contours(clean_mask)
    
    return clean_mask * 255