app

Utils/area.py

@@ -0,0 +1,51 @@
+import cv2 
+import numpy as np 
+
+def pixel_to_sqft(pixel_area, resolution_cm=30):
+    
+    area_cm2 = pixel_area * (resolution_cm ** 2)
+    area_m2 = area_cm2 / 10000.0
+    area_ft2 = area_m2 * 10.7639
+    return area_ft2
+
+def process_and_overlay_image(original_image, mask_prediction, output_image_path = None, resolution_cm=30):
+    
+   
+    # Load original image
+    
+    
+    # Convert mask prediction to binary mask
+    mask = mask_prediction.astype(np.uint8) * 255
+    
+    # Find contours in the mask
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # List to hold areas in square feet
+    areas_sqft = []
+
+    for contour in contours:
+        area_pixels = cv2.contourArea(contour)
+        area_sqft = pixel_to_sqft(area_pixels, resolution_cm)
+        areas_sqft.append(area_sqft)
+        
+        # Draw contours on the original image
+        cv2.drawContours(original_image, [contour], -1, (0, 255, 0), int(0.5))  # Green color for contours
+
+        # Calculate and draw centroid
+        M = cv2.moments(contour)
+        if M["m00"] != 0:  
+            cX = int(M["m10"] / M["m00"])
+            cY = int(M["m01"] / M["m00"])
+        else:
+            cX, cY = 0, 0
+
+        cv2.putText(original_image, f'{area_sqft:.0f}', (cX, cY), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1) 
+
+    # Save and display the image with contours
+    #cv2.imwrite(output_image_path, cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB))
+
+    # Display the image using matplotlib
+    return original_image
+    #return (cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB))
+    

Utils/convert_raster.py

@@ -0,0 +1,30 @@
+from osgeo import gdal
+import numpy as np
+import os
+import tempfile
+from PIL import Image
+
+def convert_gtiff_to_8bit(src):
+    dst = src
+    img = gdal.Open(src)
+    driver = gdal.GetDriverByName('GTiff')
+
+    output_image = driver.Create(dst, img.RasterXSize, img.RasterYSize, img.RasterCount, gdal.GDT_Byte, ['PHOTOMETRIC = RGB'])
+    output_image.SetGeoTransform(img.GetGeoTransform())
+    output_image.SetProjection(img.GetProjection())
+
+    max_bands = img.RasterCount
+    for i in range(max_bands):
+        i = i+1
+        band = img.GetRasterBand(i)
+        band_array = band.ReadAsArray()
+
+        min, max = band.ComputeRasterMinMax(1)
+        band_array = np.interp(band_array, (min,max), (0,255)).astype(np.uint8)
+
+        out = output_image.GetRasterBand(i)
+        out.WriteArray(band_array)
+        out.FlushCache()
+    return output_image
+    del output_image
+        

Utils/split_merge.py

@@ -0,0 +1,53 @@
+import cv2
+import os 
+import numpy as np 
+
+patches_folder = '/home/pavan/Desktop/Kus/Stream/Patches'
+pred_patches = '/home/pavan/Desktop/Kus/Stream/Patch_pred'
+os.makedirs(patches_folder, exist_ok=True)
+os.makedirs(pred_patches,exist_ok=True)
+
+
+def split(image, destination = patches_folder, patch_size = 256):
+    img = cv2.imread(image)
+    h,w,_ = img.shape
+    for y in range(0, h, patch_size):
+        for x in range(0, w, patch_size):
+            patch = img[y:y+patch_size, x:x+patch_size]
+
+            
+            patch_filename = f"patch_{y}_{x}.png" 
+            patch_path = os.path.join(destination, patch_filename)
+            cv2.imwrite(patch_path, patch)
+
+def merge(patch_folder , dest_image = 'out.png', image_shape = None):
+    merged = np.zeros(image_shape[:-1] + (3,), dtype=np.uint8)
+    for filename in os.listdir(patch_folder):
+        if filename.endswith(".png"):
+            patch_path = os.path.join(patch_folder, filename)
+            patch = cv2.imread(patch_path)
+            patch_height, patch_width, _ = patch.shape
+
+            # Extract patch coordinates from filename
+            parts = filename.split("_")
+            x, y = None, None
+            for part in parts:
+                if part.endswith(".png"):
+                    x = int(part.split(".")[0])
+                elif part.isdigit():
+                    y = int(part)
+            if x is None or y is None:
+                raise ValueError(f"Invalid filename: {filename}")
+
+            # Check if patch fits within image boundaries
+            if x + patch_width > image_shape[1] or y + patch_height > image_shape[0]:
+                # Adjust patch position to fit within image boundaries
+                if x + patch_width > image_shape[1]:
+                    x = image_shape[1] - patch_width
+                if y + patch_height > image_shape[0]:
+                    y = image_shape[0] - patch_height
+
+            # Merge patch into the main image
+            merged[y:y+patch_height, x:x+patch_width, :] = patch
+
+    cv2.imwrite(dest_image, merged)

image_log.csv

@@ -0,0 +1,21 @@
+S.No,Date,Time,Image ID,Image Filename,Mask Filename
+1,2024-08-27,23:35:06,1724781904,image_1724781904.png,mask_1724781906.png
+2,2024-08-27,23:35:14,1724781912,image_1724781912.png,mask_1724781914.png
+3,2024-08-28,21:36:50,1724861208,image_1724861208.png,mask_1724861210.png
+4,2024-08-28,21:43:36,1724861611,image_1724861611.png,mask_1724861616.png
+5,2024-08-28,21:47:06,1724861823,image_1724861823.png,mask_1724861826.png
+6,2024-08-29,11:23:04,1724910780,image_1724910780.png,mask_1724910784.png
+7,2024-09-04,21:13:10,1725464583,image_1725464583.tif,mask_1725464590.png
+8,2024-09-04,21:14:25,1725464658,image_1725464658.tif,mask_1725464665.png
+9,2024-09-04,21:17:15,1725464832,image_1725464832.tif,mask_1725464835.png
+10,2024-09-04,22:21:21,1725468679,image_1725468679.tif,mask_1725468681.png
+11,2024-09-04,22:45:45,1725470142,image_1725470142.tif,mask_1725470145.png
+12,2024-09-04,22:46:39,1725470196,image_1725470196.tif,mask_1725470199.png
+13,2024-09-04,22:47:30,1725470247,image_1725470247.png,mask_1725470250.png
+14,2024-09-04,22:47:55,1725470272,image_1725470272.jpg,mask_1725470275.png
+15,2024-09-04,22:48:12,1725470289,image_1725470289.png,mask_1725470292.png
+16,2024-09-04,22:49:15,1725470353,image_1725470353.png,mask_1725470355.png
+17,2024-09-04,22:50:32,1725470430,image_1725470430.png,mask_1725470432.png
+18,2024-09-05,00:00:05,1725474603,image_1725474603.tif,mask_1725474605.png
+19,2024-09-05,22:51:32,1725556889,image_1725556889.tif,mask_1725556892.png
+20,2024-09-05,22:56:54,1725557179,image_1725557179.png,mask_1725557214.png

latest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b3e02b56c25ad19386b0dbad700e0db322b871a5d281d7f14b7825b963ee163
+size 100116298

model/CBAM/bn.py

@@ -0,0 +1,11 @@
+import torch 
+import torch.nn as nn
+class batch_norm(nn.Module):
+    def __init__(self, inp):
+        super().__init__()
+        self.batch = nn.BatchNorm2d(inp)
+        self.relu = nn.ReLU()
+    def forward(self, x):
+        b = self.batch(x)
+        op = self.relu(b)
+        return op

model/CBAM/cbam.py

@@ -0,0 +1,14 @@
+import torch 
+import torch.nn as nn
+from channel_att import Channel_attention
+from spatial_att import Spatial_attention
+class CBAM(nn.Module):
+    def __init__(self, ch):
+        super().__init__()
+        self.channel = Channel_attention(ch)
+        self.spatial = Spatial_attention()
+
+    def forward(self, x):
+        x1 = self.channel(x)
+        x2 = self.spatial(x1)
+        return x2

model/CBAM/channel_att.py

@@ -0,0 +1,26 @@
+import torch 
+import torch.nn  as nn
+class Channel_attention(nn.Module):
+    def __init__(self,ch, ratio = 8):
+        super().__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.max_pool = nn.AdaptiveMaxPool2d(1)
+
+        self.mlp = nn.Sequential(
+            nn.Linear(ch, ch//ratio, bias = False),
+            nn.ReLU(inplace = True),
+            nn.Linear( ch//ratio,ch, bias = False)
+        )
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        x1 = self.avg_pool(x).squeeze(-1).squeeze(-1)
+        x1 = self.mlp(x1)
+        # x2
+        x2 = self.max_pool(x).squeeze(-1).squeeze(-1)
+        x2 = self.mlp(x2)
+        #concat
+        f = x1+x2
+        f_s = self.sigmoid(f).unsqueeze(-1).unsqueeze(-1)
+        f_final = x * f_s
+        return f_final

model/CBAM/decoder.py

@@ -0,0 +1,13 @@
+import torch 
+import torch.nn as nn
+from residual import residual
+class decoder(nn.Module):
+    def __init__(self, inp, out):
+        super().__init__()
+        self.upsample = nn.Upsample(scale_factor=2, mode = 'bilinear', align_corners = True)
+        self.block = residual(inp+out, out)
+    def forward(self, x, skip):
+        x = self.upsample(x)
+        x = torch.cat([x, skip], axis = 1)
+        x = self.block(x)
+        return x

model/CBAM/residual.py

@@ -0,0 +1,25 @@
+import torch 
+import torch.nn  as nn
+from bn import batch_norm
+from cbam import CBAM
+class residual(nn.Module):
+    def __init__(self, inp, out, stride=1):
+        super().__init__()
+        self.bn1 = batch_norm(inp)
+        self.conv1 = nn.Conv2d(inp, out, kernel_size=3, padding=1, stride=stride)
+        self.bn2 = batch_norm(out)
+        self.conv2 = nn.Conv2d(out, out, kernel_size=3, padding=1, stride=1)
+        # skip connection
+        self.concat = nn.Conv2d(inp, out, kernel_size=1, padding=0, stride=stride)
+        # Add CBAM
+        self.cbam = CBAM(out)
+
+    def forward(self, input):
+        x = self.bn1(input)
+        x = self.conv1(x)
+        x = self.bn2(x)
+        x = self.conv2(x)
+        x = self.cbam(x)  # Apply CBAM
+        skip = self.concat(input)
+        skip = x + skip
+        return skip

model/CBAM/reunet_cbam.py

@@ -0,0 +1,140 @@
+import torch 
+import torch.nn as nn
+
+class Spatial_attention(nn.Module):
+    def __init__(self, kernel = 7):
+        super().__init__()
+        self.conv = nn.Conv2d(2, 1, padding = 3, kernel_size=kernel, bias = False)
+        self.sigmoid = nn.Sigmoid()
+    def forward(self, x):
+        x1 = torch.mean(x, dim=1, keepdim = True)
+        x2, _ = torch.max(x, dim = 1, keepdim = True)
+        f = torch.concat([x1, x2], dim = 1)
+        f_c = self.conv(f)
+        f_s = self.sigmoid(f_c)
+        f_final = x * f_s
+
+        return f_final
+    
+class Channel_attention(nn.Module):
+    def __init__(self,ch, ratio = 8):
+        super().__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.max_pool = nn.AdaptiveMaxPool2d(1)
+
+        self.mlp = nn.Sequential(
+            nn.Linear(ch, ch//ratio, bias = False),
+            nn.ReLU(inplace = True),
+            nn.Linear( ch//ratio,ch, bias = False)
+        )
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        x1 = self.avg_pool(x).squeeze(-1).squeeze(-1)
+        x1 = self.mlp(x1)
+        # x2
+        x2 = self.max_pool(x).squeeze(-1).squeeze(-1)
+        x2 = self.mlp(x2)
+        #concat
+        f = x1+x2
+        f_s = self.sigmoid(f).unsqueeze(-1).unsqueeze(-1)
+        f_final = x * f_s
+        return f_final
+class CBAM(nn.Module):
+    def __init__(self, ch):
+        super().__init__()
+        self.channel = Channel_attention(ch)
+        self.spatial = Spatial_attention()
+
+    def forward(self, x):
+        x1 = self.channel(x)
+        x2 = self.spatial(x1)
+        return x2
+    
+class residual(nn.Module):
+    def __init__(self, inp, out, stride=1):
+        super().__init__()
+        self.bn1 = batch_norm(inp)
+        self.conv1 = nn.Conv2d(inp, out, kernel_size=3, padding=1, stride=stride)
+        self.bn2 = batch_norm(out)
+        self.conv2 = nn.Conv2d(out, out, kernel_size=3, padding=1, stride=1)
+        # skip connection
+        self.concat = nn.Conv2d(inp, out, kernel_size=1, padding=0, stride=stride)
+        # Add CBAM
+        self.cbam = CBAM(out)
+
+    def forward(self, input):
+        x = self.bn1(input)
+        x = self.conv1(x)
+        x = self.bn2(x)
+        x = self.conv2(x)
+        x = self.cbam(x)  # Apply CBAM
+        skip = self.concat(input)
+        skip = x + skip
+        return skip
+    
+class batch_norm(nn.Module):
+    def __init__(self, inp):
+        super().__init__()
+        self.batch = nn.BatchNorm2d(inp)
+        self.relu = nn.ReLU()
+    def forward(self, x):
+        b = self.batch(x)
+        op = self.relu(b)
+        return op
+    
+class decoder(nn.Module):
+    def __init__(self, inp, out):
+        super().__init__()
+        self.upsample = nn.Upsample(scale_factor=2, mode = 'bilinear', align_corners = True)
+        self.block = residual(inp+out, out)
+    def forward(self, x, skip):
+        x = self.upsample(x)
+        x = torch.cat([x, skip], axis = 1)
+        x = self.block(x)
+        return x
+class reunet_cbam(nn.Module):
+    def __init__(self):
+        super().__init__()
+        # encoder 1
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1, stride=1)
+        self.bn1 = batch_norm(64)
+        self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1, stride=1)
+        self.conv3 = nn.Conv2d(3, 64, kernel_size=1, padding=0, stride=1)
+        self.cbam1 = CBAM(64)  # Add CBAM for encoder 1
+        # encoder2
+        self.enc2 = residual(64, 128, stride=2)
+        # encoder3
+        self.enc3 = residual(128, 256, stride=2)
+        # bridge
+        self.bridge = residual(256, 512, stride=2)
+        # decoder
+        self.d1 = decoder(512, 256)
+        self.d2 = decoder(256, 128)
+        self.d3 = decoder(128, 64)
+        
+        # output
+        self.output = nn.Conv2d(64, 1, kernel_size=1, padding=0)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, input):
+        '''enc1'''
+        x = self.conv1(input)
+        x = self.bn1(x)
+        x = self.conv2(x)
+        x = self.cbam1(x)  # Apply CBAM
+        residual = self.conv3(input)
+        skip1 = x + residual
+        '''enc 2 and 3'''
+        skip2 = self.enc2(skip1)
+        skip3 = self.enc3(skip2)
+        '''bridge'''
+        b = self.bridge(skip3)
+        '''decoder'''
+        d1 = self.d1(b, skip3)
+        d2 = self.d2(d1, skip2)
+        d3 = self.d3(d2, skip1)
+        '''output'''
+        output = self.output(d3)
+        output = self.sigmoid(output)
+        return output

model/CBAM/spatial_att.py

@@ -0,0 +1,18 @@
+import torch 
+import torch.nn as nn
+class Spatial_attention(nn.Module):
+    def __init__(self, kernel = 7):
+        super().__init__()
+        self.conv = nn.Conv2d(2, 1, padding = 3, kernel_size=kernel, bias = False)
+        self.sigmoid = nn.Sigmoid()
+    def forward(self, x):
+        x1 = torch.mean(x, dim=1, keepdim = True)
+        x2, _ = torch.max(x, dim = 1, keepdim = True)
+        f = torch.concat([x1, x2], dim = 1)
+        f_c = self.conv(f)
+        f_s = self.sigmoid(f_c)
+        f_final = x * f_s
+
+        return f_final
+        
+        

model/bn.py

@@ -0,0 +1,13 @@
+import torch 
+import torch.nn as nn 
+import torch.functional as F
+
+class batch_norm(nn.Module):
+    def __init__(self, inp):
+        super().__init__()
+        self.batch = nn.BatchNorm2d(inp)
+        self.relu = nn.ReLU()
+    def forward(self, x):
+        b = self.batch(x)
+        op = self.relu(b)
+        return op

model/decoder.py

@@ -0,0 +1,15 @@
+import torch 
+import torch.nn as nn  
+import torch.functional as F
+from bn import batch_norm
+from residual import residual
+class decoder(nn.Module):
+    def __init__(self, inp, out):
+        super().__init__()
+        self.upsample = nn.Upsample(scale_factor=2, mode = 'bilinear', align_corners = True)
+        self.block = residual(inp+out, out)
+    def forward(self, x, skip):
+        x = self.upsample(x)
+        x = torch.cat([x, skip], axis = 1)
+        x = self.block(x)
+        return x

model/model.py

@@ -0,0 +1,59 @@
+import torch
+import torch.nn as nn
+import torch.functional as F
+
+from bn import batch_norm
+from residual import residual 
+from decoder import decoder
+
+class reunet(nn.Module):
+    def __init__(self):
+        super().__init__()
+        #encoder 1
+        self.conv1 = nn.Conv2d(3, 64, kernel_size = 3, padding = 1, stride = 1)
+        self.bn1 = batch_norm(64)
+        self.conv2 = nn.Conv2d(64,64, kernel_size =3, padding = 1, stride = 1)
+        self.conv3 = nn.Conv2d(3, 64, kernel_size = 1, padding = 0, stride = 1)
+
+        #encoder2
+        self.enc2 = residual(64, 128, stride = 2)
+        #encoder3
+        self.enc3 = residual(128,256, stride = 2)
+
+        #bridge
+        self.bridge = residual(256,512, stride = 2)
+
+        #decoder
+        self.d1 = decoder(512, 256)
+        self.d2 = decoder(256, 128)
+        self.d3 = decoder(128,64)
+        
+        #output
+        self.output = nn.Conv2d(64,1,kernel_size = 1, padding = 0)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, input):
+        '''enc1'''
+        x = self.conv1(input)
+        x = self.bn1(x)
+        x = self.conv2(x)
+        residual = self.conv3(input)
+        skip1 = x+residual
+
+        '''enc 2 and 3'''
+        skip2 = self.enc2(skip1)
+        skip3 = self.enc3(skip2)
+
+        '''bridge'''
+        b = self.bridge(skip3)
+        '''decoder'''
+        d1 = self.d1(b, skip3)
+        d2 = self.d2(d1, skip2)
+        d3 = self.d3(d2, skip1)
+        '''output'''
+
+        
+        output = self.output(d3)
+        output = self.sigmoid(output)
+        return output
+        

model/residual.py

@@ -0,0 +1,22 @@
+import torch 
+import torch.nn as  nn 
+import torch.functional as F
+from bn import batch_norm
+class residual(nn.Module):
+    def __init__(self, inp, out, stride = 1):
+        super().__init__()
+        self.bn1 = batch_norm(inp)
+        self.conv1 = nn.Conv2d(inp, out, kernel_size=3, padding = 1, stride = stride)
+        self.bn2 = batch_norm(out)
+        self.conv2 = nn.Conv2d(out, out, kernel_size = 3, padding = 1, stride = 1)
+        # skip cpnnection
+        self.concat = nn.Conv2d(inp, out, kernel_size = 1, padding = 0, stride = stride)
+    def forward(self, input):
+        x = self.bn1(input)
+        x = self.conv1(x)
+        x = self.bn2(x)
+        x = self.conv2(x)
+        skip = self.concat(input)
+        skip = x+skip
+
+        return skip

model/t.py

@@ -0,0 +1,2 @@
+from bn import batch_norm
+print(batch_norm)

model/transform.py

@@ -0,0 +1,4 @@
+import torch 
+import torchvision.transforms as T  
+transforms = T.Compose([
+    T.ToTensor(),T.Resize((256,256), antialias=False), T.Lambda(lambda x: x.to(torch.float32))])

model/unet.py

@@ -0,0 +1,63 @@
+import torch 
+import torch.nn as nn
+class DoubleConv(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(DoubleConv, self).__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False),   
+            nn.BatchNorm2d(out_channels),                                 
+            nn.ReLU(inplace=True),                                          
+            nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False), 
+            nn.BatchNorm2d(out_channels),                                
+            nn.ReLU(inplace=True),                                    
+        )                                                              
+
+    def forward(self, x):
+        return self.conv(x)
+    
+class UNET(nn.Module):
+    def __init__(
+            self, in_channels=3, out_channels=1, features=[64, 128, 256, 512],
+    ):
+        super(UNET, self).__init__()
+        self.ups = nn.ModuleList()
+        self.downs = nn.ModuleList()
+        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
+
+        for feature in features:
+            self.downs.append(DoubleConv(in_channels, feature))
+            in_channels = feature
+
+        for feature in reversed(features):
+            self.ups.append(
+                nn.ConvTranspose2d(
+                    feature*2, feature, kernel_size=2, stride=2,
+                )
+            )
+            self.ups.append(DoubleConv(feature*2, feature))
+
+        self.bottleneck = DoubleConv(features[-1], features[-1]*2)
+        self.final_conv = nn.Conv2d(features[0], out_channels, kernel_size=1)
+
+    def forward(self, x):
+        skip_connections = []
+        for down in self.downs:
+            x = down(x)
+            skip_connections.append(x)
+            x = self.pool(x)
+
+        x = self.bottleneck(x)
+        skip_connections = skip_connections[::-1]
+
+        for idx in range(0, len(self.ups), 2):
+            x = self.ups[idx](x)
+            skip_connection = skip_connections[idx//2]
+
+            if x.shape != skip_connection.shape:
+                x = TF.resize(x, size=skip_connection.shape[2:])
+
+            concat_skip = torch.cat((skip_connection, x), dim=1)
+            x = self.ups[idx+1](concat_skip)
+
+        return self.final_conv(x)
+

requirements.txt

@@ -0,0 +1,546 @@
+absl-py==2.1.0
+accelerate==0.31.0
+access==1.1.9
+aenum==3.1.15
+affine==2.4.0
+aiohttp==3.9.1
+aiosignal==1.3.1
+alabaster==0.7.16
+albumentations==1.3.1
+altair==5.2.0
+annotated-types==0.6.0
+antlr4-python3-runtime==4.9.3
+anyio==4.0.0
+appdirs==1.4.4
+apturl==0.5.2
+arabic-reshaper==3.0.0
+argon2-cffi==23.1.0
+argon2-cffi-bindings==21.2.0
+arrow==1.3.0
+asn1crypto==1.5.1
+astor==0.8.1
+asttokens==2.4.1
+astunparse==1.6.3
+async-lru==2.0.4
+async-timeout==4.0.3
+attrs==23.1.0
+audioread==3.0.1
+awscli==1.22.34
+Babel==2.13.1
+backoff==2.2.1
+bcrypt==3.2.0
+beautifulsoup4==4.12.2
+beniget==0.4.1
+bleach==6.1.0
+blessings==1.7
+blinker==1.4
+boto3==1.34.54
+botocore==1.34.54
+bqplot==0.12.42
+branca==0.7.0
+Brlapi==0.8.3
+Brotli==1.0.9
+build==1.1.1
+cachetools==5.3.2
+cairocffi==1.7.1
+CairoSVG==2.7.1
+Cartopy==0.23.0
+certifi==2023.7.22
+cffi==1.16.0
+chardet==4.0.0
+charset-normalizer==3.3.1
+click==8.1.7
+click-plugins==1.1.1
+clifford==1.4.0
+cligj==0.7.2
+colorama==0.4.4
+coloredlogs==15.0.1
+colour==0.1.5
+comm==0.1.4
+command-not-found==0.3
+contourpy==1.2.0
+coverage==5.3.1
+cryptography==42.0.5
+cssselect2==0.7.0
+csv342==1.0.1
+cupshelpers==1.0
+cycler==0.10.0
+Cython==3.0.7
+data-gradients==0.3.2
+dataclasses-json==0.6.3
+datasets==2.18.0
+dateutils==0.6.12
+dbus-python==1.2.18
+debugpy==1.8.0
+decorator==5.1.1
+defer==1.0.6
+defusedxml==0.7.1
+Deprecated==1.2.14
+deprecation==2.1.0
+devkit==0.0.12
+diffusers==0.28.2
+dill==0.3.8
+distlib==0.3.4
+distro==1.7.0
+distro-info==1.1+ubuntu0.2
+dm-tree==0.1.8
+docopt==0.6.2
+docutils==0.17.1
+dotadevkit==1.3.0
+duckdb==0.10.3
+duplicity==0.8.21
+ee==0.2
+einops==0.3.2
+ephem==4.1.5
+esda==2.5.1
+espeak-phonemizer==1.3.1
+et-xmlfile==1.1.0
+exceptiongroup==1.1.3
+executing==2.0.1
+fasteners==0.14.1
+fastjsonschema==2.18.1
+filelock==3.6.0
+fiona==1.9.5
+Flask==1.1.2
+flatbuffers==23.5.26
+folium==0.15.1
+fonttools==4.46.0
+fqdn==1.5.1
+frozenlist==1.4.1
+fs==2.4.12
+fsspec==2023.12.1
+future==0.18.2
+gast==0.5.4
+GDAL==3.8.4
+gdown==4.7.1
+geoio==1.3.0
+geojson==3.1.0
+geomet==1.1.0
+geopandas==0.14.2
+georasters==0.5.29
+ghp-import==2.1.0
+giddy==2.3.5
+gitdb==4.0.11
+GitPython==3.1.40
+google-api-core==2.16.2
+google-api-python-client==2.116.0
+google-auth==2.27.0
+google-auth-httplib2==0.2.0
+google-auth-oauthlib==1.2.0
+google-cloud-vision==3.7.2
+google-pasta==0.2.0
+googleapis-common-protos==1.62.0
+graphviz==0.20.3
+greenlet==3.0.3
+grpcio==1.62.1
+grpcio-status==1.62.1
+gTTS==2.5.1
+gw_dsl_parser==0.1.48a6
+gyp==0.1
+h11==0.14.0
+h5py==3.10.0
+html2text==2024.2.26
+html5lib==1.1
+httpcore==1.0.2
+httplib2==0.20.2
+httpx==0.26.0
+huggingface-hub==0.23.3
+humanfriendly==10.0
+hydra-core==1.3.2
+idna==2.10
+imagecodecs==2024.1.1
+imagecodes==0.0.1
+imagededup==0.3.2
+imageio==2.33.1
+imagesize==1.4.1
+imgaug==0.4.0
+importlib-metadata==4.6.4
+importlib_resources==6.4.0
+imutils==0.5.4
+inequality==1.0.1
+invisible-watermark==0.2.0
+ipyevents==2.0.2
+ipyfilechooser==0.6.0
+ipykernel==6.26.0
+ipyleaflet==0.18.1
+ipython==8.17.2
+ipython-genutils==0.2.0
+ipytree==0.2.2
+ipywidgets==8.1.1
+isoduration==20.11.0
+itsdangerous==2.1.2
+jedi==0.19.1
+jeepney==0.7.1
+Jinja2==3.1.2
+jmespath==1.0.1
+joblib==1.3.2
+json-tricks==3.16.1
+json5==0.9.14
+jsonpatch==1.33
+jsonpointer==2.4
+jsonschema==4.19.2
+jsonschema-specifications==2023.7.1
+jupyter==1.0.0
+jupyter-console==6.6.3
+jupyter-contrib-core==0.4.2
+jupyter-contrib-nbextensions==0.7.0
+jupyter-events==0.9.0
+jupyter-highlight-selected-word==0.2.0
+jupyter-lsp==2.2.0
+jupyter-nbextensions-configurator==0.6.3
+jupyter-tabnine==1.2.3
+jupyter_client==8.6.0
+jupyter_core==5.5.0
+jupyter_server==2.11.1
+jupyter_server_terminals==0.4.4
+jupyterlab==4.0.7
+jupyterlab-pygments==0.2.2
+jupyterlab-widgets==3.0.9
+jupyterlab_server==2.25.0
+kanaries_track==0.0.5
+keras==2.15.0
+keyring==23.5.0
+kiwisolver==1.4.5
+labelImg==1.8.6
+langchain==0.0.354
+langchain-community==0.0.8
+langchain-core==0.1.6
+langsmith==0.0.77
+language-selector==0.1
+launchpadlib==1.10.16
+lazr.restfulclient==0.14.4
+lazr.uri==1.0.6
+lazy_loader==0.3
+leafmap==0.30.0
+Levenshtein==0.25.1
+libclang==16.0.6
+libpysal==4.10
+librosa==0.10.1
+lightning==2.2.5
+lightning-utilities==0.11.2
+llvmlite==0.42.0
+lockfile==0.12.2
+louis==3.20.0
+lxml==4.9.3
+lz4==3.1.3+dfsg
+macaroonbakery==1.3.1
+Mako==1.1.3
+mapclassify==2.6.1
+Markdown==3.5.2
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+marshmallow==3.20.1
+matplotlib==3.8.3
+matplotlib-inline==0.1.6
+mdurl==0.1.2
+mergedeep==1.3.4
+metview==1.15.0
+mgwr==2.2.1
+mistune==3.0.2
+mkdocs==1.5.3
+ml-dtypes==0.2.0
+momepy==0.7.0
+monotonic==1.6
+more-itertools==8.10.0
+mpl-toolkits.clifford==0.0.3
+mplcursors==0.5.3
+mpmath==1.3.0
+mrcnn==0.2
+msgpack==1.0.7
+mtcnn==0.1.1
+multidict==6.0.4
+multiprocess==0.70.16
+mypy-extensions==1.0.0
+namex==0.0.7
+nbclassic==1.0.0
+nbclient==0.8.0
+nbconvert==7.10.0
+nbformat==5.9.2
+nest-asyncio==1.5.8
+netifaces==0.11.0
+netron==7.8.6
+networkx==3.2.1
+nibabel==5.2.1
+nilearn==0.10.3
+nltk==3.8.1
+notebook==7.0.6
+notebook_shim==0.2.3
+numba==0.59.0
+numpy==1.23.0
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.18.1
+nvidia-nvjitlink-cu12==12.3.101
+nvidia-nvtx-cu12==12.1.105
+oauthlib==3.2.0
+olefile==0.46
+omegaconf==2.3.0
+onnx==1.13.0
+onnxruntime==1.13.1
+onnxsim==0.4.35
+openai==1.6.1
+opencv-contrib-python==4.8.1.78
+opencv-python==4.9.0.80
+opencv-python-headless==4.10.0.84
+openpyxl==3.1.2
+opt-einsum==3.3.0
+oscrypto==1.3.0
+osmnx==1.8.1
+overrides==7.4.0
+OWSLib==0.28.1
+packaging==23.2
+pandas==2.1.4
+pandocfilters==1.5.0
+paramiko==2.9.3
+parsimonious==0.10.0
+parso==0.8.3
+patchify==0.2.3
+pathspec==0.12.1
+patsy==0.5.6
+pbr==5.8.0
+pexpect==4.8.0
+pillow==10.2.0
+pip-tools==7.4.0
+platformdirs==2.6.2
+plotly==5.18.0
+ply==3.11
+pointpats==2.4.0
+pooch==1.8.0
+prometheus-client==0.17.1
+prompt-toolkit==3.0.39
+proto-plus==1.23.0
+protobuf==4.25.3
+psutil==5.9.6
+psycopg2==2.9.2
+ptyprocess==0.7.0
+PuLP==2.8.0
+pure-eval==0.2.2
+py-cpuinfo==9.0.0
+pyarrow==14.0.2
+pyarrow-hotfix==0.6
+pyasn1==0.5.1
+pyasn1-modules==0.3.0
+pycairo==1.20.1
+pycocotools==2.0.6
+pycparser==2.21
+PyCRS==1.0.2
+pycups==2.0.1
+pydantic==2.5.3
+pydantic_core==2.14.6
+pydeck==0.8.1b0
+pyDeprecate==0.3.2
+PyGithub==2.2.0
+Pygments==2.16.1
+PyGObject==3.42.1
+pygrib==2.1.5
+pygwalker==0.4.8.6
+pyHanko==0.21.0
+pyhanko-certvalidator==0.26.3
+PyJWT==2.8.0
+pymacaroons==0.13.0
+PyNaCl==1.5.0
+pyparsing==2.4.7
+pypdf==4.1.0
+pypng==0.20220715.0
+pyproj==3.6.1
+pyproject_hooks==1.0.0
+PyQt5==5.15.6
+PyQt5-sip==12.9.1
+pyqt5ac==1.2.1
+pyRFC3339==1.1
+pyrsistent==0.18.1
+pysal==24.1
+pyseeyou==1.0.2
+pyshp==2.3.1
+PySocks==1.7.1
+pystac==1.9.0
+pystac-client==0.7.5
+pytesseract==0.3.10
+python-apt==2.4.0+ubuntu3
+python-bidi==0.4.2
+python-box==7.1.1
+python-dateutil==2.8.2
+python-debian==0.1.43+ubuntu1.1
+python-dotenv==1.0.0
+python-json-logger==2.0.7
+python-Levenshtein==0.25.1
+python-magic==0.4.27
+python-slugify==8.0.4
+pythran==0.10.0
+pytorch-ignite==0.5.1
+pytorch-lightning==2.2.5
+pyttsx3==2.90
+pytz==2022.1
+PyWavelets==1.5.0
+pyxdg==0.27
+PyYAML==6.0.1
+pyyaml_env_tag==0.1
+pyzmq==25.1.1
+qgis-plugin-ci==2.8.8
+qrcode==7.4.2
+QScintilla==2.11.6
+qtconsole==5.4.4
+QtPy==2.4.1
+quantecon==0.7.2
+qudida==0.0.4
+rapidfuzz==3.9.3
+rasterio==1.3.9
+rasterstats==0.19.0
+referencing==0.30.2
+regex==2024.5.15
+reportlab==3.6.8
+requests==2.31.0
+requests-oauthlib==1.3.1
+requests-toolbelt==1.0.0
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rich==13.7.0
+roboflow==1.1.14
+roman==3.3
+rpds-py==0.10.6
+rsa==4.9
+Rtree==1.2.0
+s3transfer==0.10.0
+safetensors==0.4.3
+scikit-fuzzy==0.4.2
+scikit-image==0.22.0
+scikit-learn==1.3.2
+scipy==1.11.4
+scooby==0.9.2
+seaborn==0.13.0
+SecretStorage==3.3.1
+segment-analytics-python==2.2.3
+segment-anything==1.0
+segregation==2.5
+Send2Trash==1.8.2
+sentinelhub==3.10.2
+sentinelloader @ git+https://github.com/flaviostutz/sentinelloader@b107badeedf4ccc7c9eed74c5663d849348d887a
+sentinelsat==1.2.1
+shapely==2.0.2
+simplejson==3.19.2
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.0
+snowballstemmer==2.2.0
+snuggs==1.4.7
+sounddevice==0.4.6
+soundfile==0.12.1
+soupsieve==2.5
+soxr==0.3.7
+spaghetti==1.7.5.post1
+sparse==0.15.1
+spglm==1.1.0
+Sphinx==4.0.3
+sphinx-rtd-theme==1.3.0
+sphinxcontrib-applehelp==1.0.8
+sphinxcontrib-devhelp==1.0.6
+sphinxcontrib-htmlhelp==2.0.5
+sphinxcontrib-jquery==4.1
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==1.0.7
+sphinxcontrib-serializinghtml==1.1.10
+spint==1.0.7
+splot==1.1.5.post1
+spopt==0.6.0
+spreg==1.4.2
+spvcm==0.3.0
+SQLAlchemy==2.0.25
+sqlglot==24.0.1
+ssh-import-id==5.11
+stack-data==0.6.3
+statsmodels==0.14.1
+streamlit==1.29.0
+stringcase==1.2.0
+super-gradients==3.6.0
+supervision==0.17.1
+svglib==1.5.1
+sympy==1.12
+systemd-python==234
+tenacity==8.2.3
+tensorboard==2.15.2
+tensorboard-data-server==0.7.2
+tensorflow==2.15.0.post1
+tensorflow-estimator==2.15.0
+tensorflow-io-gcs-filesystem==0.36.0
+termcolor==1.1.0
+terminado==0.17.1
+tesseract==0.1.3
+text-unidecode==1.3
+thop==0.1.1.post2209072238
+threadpoolctl==3.2.0
+tifffile==2023.12.9
+tiffile==2018.10.18
+tinycss2==1.2.1
+tinytools==1.1.1
+tkintertable==1.3.3
+tobler==0.11.2
+tokenizers==0.19.1
+toml==0.10.2
+tomli==2.0.1
+tomli_w==1.0.0
+toolz==0.12.0
+torch==2.1.1
+torcheval==0.0.7
+torchinfo==1.8.0
+torchmetrics==0.8.0
+torchvision==0.16.1
+torchviz==0.0.2
+tornado==6.4
+tqdm==4.66.1
+traitlets==5.13.0
+traittypes==0.2.1
+transformers==4.41.2
+transifex-python==3.5.0
+treelib==1.6.1
+trimesh==4.1.7
+triton==2.1.0
+types-python-dateutil==2.8.19.14
+typing-inspect==0.9.0
+typing_extensions==4.8.0
+tzdata==2023.3
+tzlocal==5.2
+tzwhere==3.0.3
+ubuntu-drivers-common==0.0.0
+ubuntu-pro-client==8001
+ufoLib2==0.13.1
+ufw==0.36.1
+ultralytics==8.0.196
+unattended-upgrades==0.1
+unicodedata2==14.0.0
+uri-template==1.3.0
+uritemplate==4.1.1
+uritools==4.0.2
+urllib3==2.0.7
+usb-creator==0.3.7
+utm==0.7.0
+validators==0.22.0
+virtualenv==20.13.0+ds
+wadllib==1.3.6
+wasmtime==21.0.0
+watchdog==3.0.0
+wavio==0.0.8
+wcwidth==0.2.8
+webcolors==1.13
+webencodings==0.5.1
+websocket-client==1.6.4
+Werkzeug==3.0.1
+whitebox==2.3.1
+whiteboxgui==2.3.0
+widgetsnbextension==4.0.9
+wrapt==1.14.1
+xarray==2024.1.1
+xdg==5
+xhtml2pdf==0.2.11
+xkit==0.0.0
+xmltodict==0.13.0
+xxhash==3.4.1
+xyzservices==2023.10.1
+yarl==1.9.4
+zipp==1.0.0

streamlit_app.py

@@ -0,0 +1,257 @@
+import streamlit as st
+import sys
+
+import torch
+from model.CBAM.reunet_cbam import reunet_cbam
+import cv2
+from PIL import Image 
+from model.transform import transforms
+import numpy as np
+from model.unet import UNET
+from area import pixel_to_sqft, process_and_overlay_image
+import matplotlib.pyplot as plt
+import time
+import os
+import csv 
+from datetime import datetime
+from split_merge import split, merge 
+from convert_raster import convert_gtiff_to_8bit
+import shutil
+
+patches_folder = 'data/Patches'
+pred_patches = 'data/Patch_pred'
+os.makedirs(patches_folder, exist_ok=True)
+os.makedirs(pred_patches, exist_ok=True)
+
+# Define the upload directories
+UPLOAD_DIR = "data/uploaded_images"
+MASK_DIR = "data/generated_masks"
+CSV_LOG_PATH = "image_log.csv"
+
+# Create the directories if they don't exist
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(MASK_DIR, exist_ok=True)
+
+model = reunet_cbam()
+model.load_state_dict(torch.load('latest.pth', map_location='cpu')['model_state_dict'])
+model.eval()
+
+def predict(image):
+    with torch.no_grad():
+        output = model(image.unsqueeze(0))
+    return output.squeeze().cpu().numpy()
+
+def log_image_details(image_id, image_filename, mask_filename):
+    file_exists = os.path.exists(CSV_LOG_PATH)
+    
+    current_time = datetime.now()
+    date = current_time.strftime('%Y-%m-%d')
+    time = current_time.strftime('%H:%M:%S')
+    
+    with open(CSV_LOG_PATH, mode='a', newline='') as file:
+        writer = csv.writer(file)
+        if not file_exists:
+            writer.writerow(['S.No', 'Date', 'Time', 'Image ID', 'Image Filename', 'Mask Filename'])
+        
+        # Get the next S.No
+        if file_exists:
+            with open(CSV_LOG_PATH, mode='r') as f:
+                reader = csv.reader(f)
+                sno = sum(1 for row in reader)
+        else:
+            sno = 1
+        
+        writer.writerow([sno, date, time, image_id, image_filename, mask_filename])
+
+def overlay_mask(image, mask, alpha=0.5, rgb=[255, 0, 0]):
+    # Ensure image is 3-channel
+    if len(image.shape) == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+    
+    # Ensure mask is binary and same shape as image
+    mask = mask.astype(bool)
+    if mask.shape[:2] != image.shape[:2]:
+        raise ValueError("Mask and image must have the same dimensions")
+    
+    # Create color overlay
+    color_mask = np.zeros_like(image)
+    color_mask[mask] = rgb
+    
+    # Blend the image and color mask
+    output = cv2.addWeighted(image, 1, color_mask, alpha, 0)
+    
+    return output
+
+def reset_state():
+    st.session_state.file_uploaded = False
+    st.session_state.filename = None
+    st.session_state.mask_filename = None
+    st.session_state.tr_img = None
+    if 'page' in st.session_state:
+        del st.session_state.page
+
+def upload_page():
+    if 'file_uploaded' not in st.session_state:
+        st.session_state.file_uploaded = False
+    
+    if 'filename' not in st.session_state:
+        st.session_state.filename = None
+    
+    if 'mask_filename' not in st.session_state:
+        st.session_state.mask_filename = None
+
+    image = st.file_uploader('Choose a satellite image', type=['jpg', 'png', 'jpeg', 'tiff', 'tif'])
+
+    if image is not None:
+        reset_state()  # Reset the state when a new image is uploaded
+        bytes_data = image.getvalue()
+        
+        timestamp = int(time.time())
+        original_filename = image.name
+        file_extension = os.path.splitext(original_filename)[1].lower()
+        
+        if file_extension in ['.tiff', '.tif']:
+            filename = f"image_{timestamp}.tif"
+        else:
+            filename = f"image_{timestamp}.png"
+        
+        filepath = os.path.join(UPLOAD_DIR, filename)
+        
+        with open(filepath, "wb") as f:
+            f.write(bytes_data)
+        
+        # Check if the uploaded file is a GeoTIFF
+        if file_extension in ['.tiff', '.tif']:
+            st.info('Processing GeoTIFF image...')
+            convert_gtiff_to_8bit(filepath)
+            st.success('GeoTIFF converted to 8-bit image')
+        
+        img = Image.open(filepath)
+        st.image(img, caption='Uploaded Image', use_column_width=True)
+        st.success(f'Image saved as {filename}')
+
+        # Store the full path of the uploaded image
+        st.session_state.filename = filename
+
+        # Convert image to numpy array
+        img_array = np.array(img)
+
+        # Check if image shape is more than 650x650
+        if img_array.shape[0] > 650 or img_array.shape[1] > 650:
+            # Split image into patches
+            split(filepath, patch_size=256)
+
+            # Display buffer while analyzing
+            with st.spinner('Analyzing...'):
+                # Predict on each patch
+                for patch_filename in os.listdir(patches_folder):
+                    if patch_filename.endswith(".png"):
+                        patch_path = os.path.join(patches_folder, patch_filename)
+                        patch_img = Image.open(patch_path)
+                        patch_tr_img = transforms(patch_img)
+                        prediction = predict(patch_tr_img)
+                        mask = (prediction > 0.5).astype(np.uint8) * 255
+                        mask_filename = f"mask_{patch_filename}"
+                        mask_filepath = os.path.join(pred_patches, mask_filename)
+                        Image.fromarray(mask).save(mask_filepath)
+
+                # Merge predicted patches
+                merged_mask_filename = f"generated_masks/mask_{timestamp}.png"
+                merge(pred_patches, merged_mask_filename, img_array.shape)
+
+                # Save merged mask
+                st.session_state.mask_filename = merged_mask_filename
+
+                # Clean up temporary patch files
+                st.info('Cleaning up temporary files...')
+                shutil.rmtree(patches_folder)
+                shutil.rmtree(pred_patches)
+                os.makedirs(patches_folder)  # Recreate empty folders
+                os.makedirs(pred_patches)
+                st.success('Temporary files cleaned up')
+        else:
+            # Predict on whole image
+            st.session_state.tr_img = transforms(img)
+            prediction = predict(st.session_state.tr_img)
+            mask = (prediction > 0.5).astype(np.uint8) * 255
+            mask_filename = f"mask_{timestamp}.png"
+            mask_filepath = os.path.join(MASK_DIR, mask_filename)
+            Image.fromarray(mask).save(mask_filepath)
+            st.session_state.mask_filename = mask_filepath
+
+        st.session_state.file_uploaded = True
+
+    if st.session_state.file_uploaded and st.button('View result'):
+        if st.session_state.filename is None:
+            st.error("Please upload an image before viewing the result.")
+        else:
+            st.success('Image analyzed')
+            st.session_state.page = 'result'
+            st.rerun()
+
+def result_page():
+    st.title('Analysis Result')
+    
+    if 'filename' not in st.session_state or 'mask_filename' not in st.session_state:
+        st.error("No image or mask file found. Please upload and process an image first.")
+        if st.button('Back to Upload'):
+            reset_state()
+            st.rerun()
+        return
+
+    col1, col2 = st.columns(2)
+
+    # Display original image
+    original_img_path = os.path.join(UPLOAD_DIR, st.session_state.filename)
+    if os.path.exists(original_img_path):
+        original_img = Image.open(original_img_path)
+        col1.image(original_img, caption='Original Image', use_column_width=True)
+    else:
+        col1.error(f"Original image file not found: {original_img_path}")
+
+    # Display predicted mask
+    mask_path = st.session_state.mask_filename
+    if os.path.exists(mask_path):
+        mask = Image.open(mask_path)
+        col2.image(mask, caption='Predicted Mask', use_column_width=True)
+    else:
+        col2.error(f"Predicted mask file not found: {mask_path}")
+
+    st.subheader("Overlay with Area of Buildings (sqft)")
+
+    # Display overlayed image
+    if os.path.exists(original_img_path) and os.path.exists(mask_path):
+        original_np = cv2.imread(original_img_path)
+        mask_np = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
+        
+        # Ensure mask is binary
+        _, mask_np = cv2.threshold(mask_np, 127, 255, cv2.THRESH_BINARY)
+
+        # Resize mask to match original image size if necessary
+        if original_np.shape[:2] != mask_np.shape[:2]:
+            mask_np = cv2.resize(mask_np, (original_np.shape[1], original_np.shape[0]))
+
+        # Process and overlay image
+        overlay_img = process_and_overlay_image(original_np, mask_np, 'output.png')
+        
+        st.image(overlay_img, caption='Overlay Image', use_column_width=True)
+    else:
+        st.error("Image or mask file not found for overlay.")
+
+    if st.button('Back to Upload'):
+        reset_state()
+        st.rerun()
+
+def main():
+    st.title('Building area estimation')
+    
+    if 'page' not in st.session_state:
+        st.session_state.page = 'upload'
+
+    if st.session_state.page == 'upload':
+        upload_page()
+    elif st.session_state.page == 'result':
+        result_page()
+
+if __name__ == '__main__':
+    main()