Upload 3 files

demo.py

@@ -0,0 +1,930 @@
+import streamlit as st
+import folium
+from streamlit_folium import folium_static
+import requests
+import tempfile
+import os
+import shutil
+import zipfile
+from PIL import Image
+import numpy as np
+import io
+import gdown
+import pandas as pd
+import time
+from folium import plugins
+from huggingface_hub import hf_hub_download
+from ultralytics.utils.plotting import Annotator
+import torch
+import torch.nn as nn
+from ultralytics import YOLO
+import tensorflow as tf
+import matplotlib
+from tensorflow import keras
+from tensorflow.keras.preprocessing.image import img_to_array, array_to_img
+import matplotlib.pyplot as plt
+import simplekml
+
+
+st.set_page_config(layout="wide")
+
+# url = 'https://drive.google.com/uc?id=1DBl_LcIC3-a09bgGqRPAsQsLCbl9ZPJX'
+if 'button1' not in st.session_state:
+    st.session_state.button1=False
+if 'zoomed_in' not in st.session_state:
+    st.session_state.zoomed_in=True
+if 'num_bk' not in st.session_state:
+    st.session_state.num_bk = 0
+if 'box_lat1' not in st.session_state:
+    st.session_state.box_lat1 = 26.42
+if 'box_lon1' not in st.session_state:
+    st.session_state.box_lon1 = 79.57
+if 'box_lat2' not in st.session_state:
+    st.session_state.box_lat2 = 26.39
+if 'box_lon2' not in st.session_state:
+    st.session_state.box_lon2 = 79.59
+def callback():
+    st.session_state.button1=True
+def callback_map():
+    st.session_state.button1=False
+    st.session_state.india_map = create_map(12)
+    if 'box_lat1' not in st.session_state:
+        st.session_state.box_lat1 = 26.42
+    if 'box_lon1' not in st.session_state:
+        st.session_state.box_lon1 = 79.57
+    if 'box_lat2' not in st.session_state:
+        st.session_state.box_lat2 = 26.39
+    if 'box_lon2' not in st.session_state:
+        st.session_state.box_lon2 = 79.59
+    st.session_state.india_map.location = [(st.session_state.box_lat1+st.session_state.box_lat2)/2,(st.session_state.box_lon1+st.session_state.box_lon2)/2]
+    st.session_state.zoomed_in=True
+    st.session_state.num_bk = 0 
+    plugins.MousePosition().add_to(st.session_state.india_map)
+
+# st.write(st.session_state.box_lat1)
+
+
+# @st.cache_resource(show_spinner = False)
+# def download_model():
+#     url = 'https://drive.google.com/uc?id=17Km_2jHSixQOrq5gqOB0RoaaeQdpNEHm'
+#     output = 'weights.pt'
+#     gdown.download(url, output, quiet=True)
+    # st.write("Downloaded successfully")
+# download_model()
+@st.cache_resource(show_spinner=False)
+def load_model():
+    model_path = hf_hub_download(repo_id="Vannsh/v8x-obb", filename="obb3.pt")
+    model = YOLO(model_path,task='obb')
+    # path = "/Users/vannshjani/Downloads/yolov8_weights.pt"
+    # model = YOLO(path,task='detect')
+    return model
+
+# model = tf.keras.models.load_model('model_resnet_fine_ind.h5')
+mapbox_token = 'pk.eyJ1IjoiYWRpdGktMTgiLCJhIjoiY2xsZ2dlcm9zMHRiMzNkcWF2MmFjZTc3biJ9.axO4l5PRwHHn2H3wEE-cEg'
+
+def get_static_map_image(latitude, longitude, api):
+ # Replace with your Google Maps API Key
+    base_url = 'https://maps.googleapis.com/maps/api/staticmap'
+    params = {
+        'center': f'{latitude},{longitude}',
+        'zoom': 16,  # You can adjust the zoom level as per your requirement
+        'size': '640x640',  # You can adjust the size of the image as per your requirement
+        'maptype': 'satellite',
+        'key': api,
+        'scale': 2,
+    }
+    response = requests.get(base_url, params=params)
+    return response.content
+
+def create_map(zoom_level,location = [20.5937, 78.9629]):
+    india_map = folium.Map(
+        location=location,
+        # location = [26.4,79.58],
+        zoom_start=zoom_level,
+        control_scale=True,
+    )
+
+    # Add Mapbox tiles with 'Mapbox Satellite' style
+    folium.TileLayer(
+        tiles=f"https://api.mapbox.com/styles/v1/mapbox/satellite-streets-v12/tiles/{{z}}/{{x}}/{{y}}?access_token={mapbox_token}",
+        attr="Mapbox Satellite",
+        name="Mapbox Satellite"
+    ).add_to(india_map)
+
+    plugins.MousePosition().add_to(india_map)
+
+    return india_map
+
+def add_locations(lat,lon,india_map):
+    india_map.location = [lat, lon]
+
+    # Add marker for selected latitude and longitude
+    folium.Marker(
+        location=[lat, lon],
+        popup=f"Latitude: {lat}, Longitude: {lon}",
+        icon=folium.Icon(color='blue')
+    ).add_to(india_map)
+
+def generate_kml_content(longs, lats):
+    kml = simplekml.Kml()
+    for lon, lat in zip(longs, lats):
+        kml.newpoint(name="Brick-kiln", coords=[(lon, lat)])
+    return kml.kml()
+def project(lat,long):
+    lat = np.radians(lat)
+    long = np.radians(long)
+    x = (128/np.pi)*(2**17)*(long + np.pi)
+    y = (128/np.pi)*(2**17)*(np.pi - np.log(np.tan(np.pi/4 + lat/2)))
+    return x,y
+def inverse_project(x,y):
+    F  = 128 / np.pi * 2 ** 17
+    lng = (x / F) - np.pi
+    lat = (2 * np.arctan(np.exp(np.pi - y/F)) - np.pi / 2)
+    lng = lng * 180 / np.pi
+    lat = lat * 180 / np.pi
+    return lat, lng
+
+def add_box_to_map(lat1,lon1,lat2,lon2,lat3,lon3,lat4,lon4,cls,map):
+    # if cls==1:
+    #     folium.Polygon([(lat1,lon1), (lat2,lon2), (lat3,lon3), (lat4,lon4)],
+    #            color="blue",
+    #            weight=2,
+    #            fill=False,
+    #            tooltip="Zigzag").add_to(st.session_state.india_map)
+    # else:
+    #     folium.Polygon([(lat1,lon1), (lat2,lon2), (lat3,lon3), (lat4,lon4)],
+    #            color="red",
+    #            weight=2,
+    #            fill=False,
+    #            tooltip="FCBK").add_to(st.session_state.india_map)
+    tooltip_text = "Zigzag" if cls == 1 else "FCBK"
+    color = "blue" if cls == 1 else "red"
+
+    folium.Polygon(
+        locations=[(lat1, lon1), (lat2, lon2), (lat3, lon3), (lat4, lon4)],
+        color=color,
+        weight=2,
+        fill=False,
+        fill_opacity=0,
+        tooltip=tooltip_text
+    ).add_to(map)
+    
+    
+
+
+# def get_new_coords(lat,long,shift):
+#     x,y = project(lat,long)
+#     if shift=="left":
+#         return inverse_project(x-640,y+640)
+#     else:
+#         return inverse_project(x+640,y-640)
+
+
+# def imgs_input_fn(images):
+#     img_size = (640, 640)
+#     img_size_tensor = tf.constant(img_size, dtype=tf.int32)
+#     images = tf.convert_to_tensor(value = images)
+#     images = tf.image.resize(images, size=img_size_tensor)
+#     return images
+
+# def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):
+#     # First, we create a model that maps the input image to the activations
+#     # of the last conv layer as well as the output predictions
+#     grad_model = keras.models.Model(
+#         model.inputs, [model.get_layer(last_conv_layer_name).output, model.output]
+#     )
+#     # Then, we compute the gradient of the top predicted class for our input image
+#     # with respect to the activations of the last conv layer
+#     with tf.GradientTape() as tape:
+#         last_conv_layer_output, preds = grad_model(img_array)
+#         if pred_index is None:
+#             pred_index = tf.argmax(preds[0])
+#         class_channel = preds[:, pred_index]
+
+#     # This is the gradient of the output neuron (top predicted or chosen)
+#     # with regard to the output feature map of the last conv layer
+#     grads = tape.gradient(class_channel, last_conv_layer_output)
+
+#     # This is a vector where each entry is the mean intensity of the gradient
+#     # over a specific feature map channel
+#     pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+
+#     # We multiply each channel in the feature map array
+#     # by "how important this channel is" with regard to the top predicted class
+#     # then sum all the channels to obtain the heatmap class activation
+#     last_conv_layer_output = last_conv_layer_output[0]
+#     heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
+#     heatmap = tf.squeeze(heatmap)
+
+#     # For visualization purpose, we will also normalize the heatmap between 0 & 1
+#     heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)
+#     return heatmap.numpy()
+
+# def save_and_display_gradcam(img_array, heatmap, alpha=0.4):
+#     img = img_array
+#     heatmap = np.uint8(255 * heatmap)
+#     jet = matplotlib.colormaps["jet"]
+#     jet_colors = jet(np.arange(256))[:, :3]
+#     jet_heatmap = jet_colors[heatmap]
+
+#     jet_heatmap = array_to_img(jet_heatmap)
+#     jet_heatmap = jet_heatmap.resize((img.shape[1], img.shape[0]))
+#     jet_heatmap = img_to_array(jet_heatmap)
+
+#     superimposed_img = jet_heatmap * alpha + img
+#     superimposed_img = array_to_img(superimposed_img)
+
+#     return superimposed_img
+
+def main():
+
+    hide_st_style = """
+            <style>
+            body {
+            background-color: black;
+            color: white;
+        }
+            #MainMenu {visibility: hidden;}
+            footer {visibility: hidden;}
+            header {visibility: hidden;}
+            </style>
+            """
+    st.markdown(hide_st_style, unsafe_allow_html=True)
+
+    model = load_model()
+
+    st.title("Brick Kiln Detector")
+    st.write("This app uses a deep learning model to detect brick kilns in satellite images. The app allows you to select certain area on a map and download the images of brick kilns and non-brick kilns in that region.")
+
+    # st.header("Instructions")
+    # st.write("1. Enter the latitude and longitude of the bounding box in the sidebar.\n"
+    #              "2. Click on submit and wait for the results to load.\n"
+    #              "3. Download the images and CSV file using the download buttons below.")
+    
+    
+
+
+    # Initialize variables to store user-drawn polygons
+    drawn_polygons = []
+
+    # Specify the latitude and longitude for the rectangular bounding box
+    st.header("Bounding Box")
+    col1, col2, col3,col4 = st.columns(4)
+    prev_lat1 = st.session_state.box_lat1
+    prev_lat2 = st.session_state.box_lat2
+    prev_lon1 = st.session_state.box_lon1
+    prev_lon2 = st.session_state.box_lon2
+    with col1:
+        st.session_state.box_lat1 = st.number_input("Lat of top-left corner:", value=26.42, step=0.01,format='%f',on_change=callback_map)
+    with col2:
+        st.session_state.box_lon1 = st.number_input("Lon of top-left corner:", value=79.57, step=0.01,on_change=callback_map)
+    with col3:
+        st.session_state.box_lat2 = st.number_input("Lat of bottom-right corner:", value=26.39, step=0.01,on_change=callback_map)
+    with col4:
+        st.session_state.box_lon2 = st.number_input("Lon of bottom-right corner:", value=79.59, step=0.01,on_change=callback_map)
+    if prev_lat1 != st.session_state.box_lat1 or prev_lat2!=st.session_state.box_lat2 or prev_lon1 != st.session_state.box_lon1 or prev_lon2!=st.session_state.box_lon2:
+        callback_map()
+    area = np.abs(st.session_state.box_lat2-st.session_state.box_lat1)*np.abs(st.session_state.box_lon2-st.session_state.box_lon1)
+    area = round(area,5)
+    st.write(f"Area of the bounding box is {area} sq units.")
+    mid_lat = (st.session_state.box_lat1+st.session_state.box_lat2)/2
+    mid_lon = (st.session_state.box_lon1+st.session_state.box_lon2)/2
+    if 'india_map' not in st.session_state:
+        st.session_state.india_map = create_map(12)
+        st.session_state.india_map.location = [mid_lat,mid_lon]
+
+    if area<=0.005:
+        submit_button = st.button("Submit",on_click=callback)
+        
+        # new_box_lat1,new_box_lon1 = get_new_coords(box_lat1,box_lon1,"left")
+        # new_box_lat2,new_box_lon2 = get_new_coords(box_lat2,box_lon2,"right")
+        # box_lat1 = new_box_lat1
+        # box_lon1 = new_box_lon1
+        # box_lat2 = new_box_lat2
+        # box_lon2 = new_box_lon2
+        # Add the rectangular bounding box to the map
+        bounding_box_polygon = folium.Rectangle(
+            bounds=[[st.session_state.box_lat2, st.session_state.box_lon2], [st.session_state.box_lat1, st.session_state.box_lon1]],
+            color='red',
+            fill=True,
+            fill_opacity=0,
+        )
+        bounding_box_polygon.add_to(st.session_state.india_map)
+        drawn_polygons.append(bounding_box_polygon.get_bounds())
+
+        df = pd.DataFrame(columns = ['Sr.No','Latitude', 'Longitude','Confidence'])
+
+        
+        # Display the map as an image using st.image()
+        # folium_static(world_map, width=1500, height=800)
+        folium_static(st.session_state.india_map,width=1200,height=800)
+        
+        ab = st.secrets["Api_key"]
+  
+        
+
+
+        if ab and (submit_button or st.session_state.button1):
+            @st.cache_resource(show_spinner = False)
+            def done_before(df,drawn_polygons):
+                st.session_state.ab = ab
+                image_list = []
+                latitudes = []
+                longitudes = []
+                idx = 0
+                # lat_1 = drawn_polygons[0][0][0]
+                # lon_1 = drawn_polygons[0][0][1]
+                # lat_2 = drawn_polygons[0][1][0]
+                # lon_2 = drawn_polygons[0][1][1]
+                
+                delta_lat = 0.011
+                delta_lon = 0.013
+                latitude = st.session_state.box_lat2
+                longitude = st.session_state.box_lon1
+                lat_ones = []
+                lon_ones = []
+                nlat=0
+                nlong=0
+                while latitude<=st.session_state.box_lat1:
+                    nlat+=1
+                    latitude+=delta_lat
+
+                while longitude<=st.session_state.box_lon2:
+                    nlong+=1
+                    longitude+=delta_lon
+                latitude=st.session_state.box_lat2
+                longitude=st.session_state.box_lon1
+
+                progress_text = 'Please wait while we process your request...'
+                my_bar = st.progress(0, text=progress_text)
+
+                # st.write("Predictions ongoing")
+                indices_of_zeros = []
+                indices_of_ones = []
+                prob_flat_list = []
+                results = []
+                i=0
+                while round(latitude,2)<=st.session_state.box_lat1:
+                    while round(longitude,2)<=st.session_state.box_lon2:
+                        image_data = get_static_map_image(latitude, longitude, ab)
+                        image = Image.open(io.BytesIO(image_data))
+                        # st.write(latitude,longitude)
+                
+                        # Get the size of the image (width, height)
+                        # width, height = image.size
+                    
+                
+
+                        # new_height = height - 20
+                
+                        # Define the cropping box (left, upper, right, lower)
+                        # crop_box = (0, 0, width, new_height)
+                            
+                        # Crop the image
+                        # image = image.crop(crop_box)
+
+                        # new_width = 224
+                        # new_height = 224
+
+                        # Define the resizing box (left, upper, right, lower)
+                        # resize_box = (0, 0, new_width, new_height)
+
+                        # Resize the image
+                        # image = image.resize((new_width, new_height), Image.LANCZOS)
+                        image = image.convert('RGB')
+                        temp_result = model.predict(image)
+                        r = temp_result[0]
+                        if len(r.obb.cls)==0:
+                            indices_of_zeros.append(i)
+                        elif len(r.obb.cls)==1:
+                            indices_of_ones.append(i)
+                            prob_flat_list.append(r.obb.conf.item())
+                            lat_ones.append(latitude)
+                            lon_ones.append(longitude)
+                        else:
+                            indices_of_ones.append(i)
+                            prob_flat_list.append(r.obb.conf)
+                            lat_ones.append(latitude)
+                            lon_ones.append(longitude)
+                        i += 1
+
+
+                        # image_np_array = np.array(image)
+                            
+                        # image_np_array = np.array(image)
+                            
+                        results.append(temp_result[0])
+                        image_list.append(image)
+                        latitudes.append(latitude)
+                        longitudes.append(longitude)
+                
+                            
+                        if idx >1:
+                            idx = 0.95
+                        longitude += delta_lon
+                        my_bar.progress(idx , text=progress_text)
+                        idx+=(3/(4*nlat*nlong))
+                
+                        
+                            
+                        
+                    latitude += delta_lat
+                    longitude = st.session_state.box_lon1
+                
+                    
+
+                # images = np.stack(image_array_list, axis=0)
+                    
+            
+                # images = imgs_input_fn(image_array_list)
+                # predictions_prob = model.predict(images)
+                # predictions = [[1 if element >= 0.5 else 0 for element in sublist] for sublist in predictions_prob]
+            
+                # prob_flat_list = [element for sublist in predictions_prob for element in sublist]
+                # flat_modified_list = [element for sublist in predictions for element in sublist]
+                
+                # indices_of_ones = [index for index, element in enumerate(flat_modified_list) if element == 1]
+                # indices_of_zeros = [index for index, element in enumerate(flat_modified_list) if element == 0]
+   
+                
+
+
+      
+                return indices_of_ones,latitudes,longitudes,image_list,indices_of_zeros,my_bar,results,prob_flat_list,lat_ones,lon_ones
+            indices_of_ones,latitudes,longitudes,image_list,indices_of_zeros,my_bar,results,prob_flat_list,lat_ones,lon_ones=done_before(df,drawn_polygons) 
+
+            # reset = st.button("Reset")
+            
+            # temp_dir1 = tempfile.mkdtemp()  # Create a temporary directory to store the images
+            # st.write(indices_of_ones,prob_flat_list)
+
+            # s_no =1
+            # index = 0
+            # for i in indices_of_ones:
+            #     if isinstance(prob_flat_list[index], torch.Tensor):
+            #         for z in range(len(prob_flat_list[index])):
+            #             truncated_float = int(prob_flat_list[index][z] * 100) / 100
+            #             temp_df = pd.DataFrame({'Sr.No':[s_no],'Latitude': [round(latitudes[i],2)], 'Longitude': [round(longitudes[i],2)],'Confidence':[truncated_float]})
+            #             s_no+=1
+            #             # Concatenate the temporary DataFrame with the main DataFrame
+            #             df = pd.concat([df, temp_df], ignore_index=True)
+            #     else:
+            #         truncated_float = int(prob_flat_list[index] * 100) / 100
+            #         temp_df = pd.DataFrame({'Sr.No':[s_no],'Latitude': [round(latitudes[i],2)], 'Longitude': [round(longitudes[i],2)],'Confidence':[truncated_float]})
+            #         s_no+=1
+            #         df = pd.concat([df, temp_df], ignore_index=True)
+            #     index += 1
+                    # Concatenate the temporary DataFrame with the main DataFrame
+                    
+                
+                    # image_filename = f'kiln_{latitudes[i]}_{longitudes[i]}.png'
+                    # image_path = os.path.join(temp_dir1, image_filename)
+
+                    # pil_image = image_list[i]
+
+                    # pil_image.save(image_path, format='PNG')
+                    # zipf.write(image_path, arcname=image_filename)
+                        
+                
+            
+            # temp_dir2 = tempfile.mkdtemp()  # Create a temporary directory to store the images
+                
+            # with zipfile.ZipFile('images_no_kiln.zip', 'w') as zipf:
+            #     for i in indices_of_zeros:
+            #         image_filename = f'kiln_{latitudes[i]}_{longitudes[i]}.png'
+            #         image_path = os.path.join(temp_dir2, image_filename)
+
+            #         pil_image = image_list[i]
+
+            #         pil_image.save(image_path, format='PNG')
+            #         zipf.write(image_path, arcname=image_filename)
+                        
+        
+            mid_lat = (st.session_state.box_lat1+st.session_state.box_lat2)/2
+            mid_lon = (st.session_state.box_lon1+st.session_state.box_lon2)/2
+            reset = st.button("Reset view")
+            if reset:
+                st.session_state.india_map.location = [mid_lat,mid_lon]
+                    
+
+            count_ones = []
+            count_zeros = []
+            for r in results:
+                if len(r.obb.cls)==0:
+                    count_ones.append(0)
+                    count_zeros.append(1)
+                else:
+                    count_ones.append(len(r.obb.cls))
+                    count_zeros.append(0)
+            n_count_ones = sum(count_ones)
+            n_count_zeros = sum(count_zeros)
+            my_bar.progress(0.99 , text='Please wait while we process your request...')
+            time.sleep(1)
+            my_bar.empty()        
+
+            
+            # st.write("The number of non-brick kilns in the selected region is: ", n_count_zeros)
+            bk_lats = []
+            bk_lons = []
+            new_lats = []
+            new_lons = []
+            conf_list = []
+            conf_new = []
+            class_list = []
+            class_new = []
+            n_zig = 0
+            n_fcbk = 0
+            dictionary = {}
+            boxes_to_take = {}
+            lat_x1 = []
+            lon_y1 = []
+            lat_x2 = []
+            lon_y2 = []
+            lat_x3 = []
+            lon_y3 = []
+            lat_x4 = []
+            lon_y4 = []
+            lat_x1_new = []
+            lon_y1_new = []
+            lat_x2_new = []
+            lon_y2_new = []
+            lat_x3_new = []
+            lon_y3_new = []
+            lat_x4_new = []
+            lon_y4_new = []
+            ind = 0
+            for i in indices_of_ones:
+                r = results[i]
+                boxes = r.obb
+                boxes_to_take[i] = []
+                lat_images = []
+                lon_images = []
+                conf_images = []
+                class_images = []
+                lat1_images = []
+                lon1_images = []
+                lat2_images = []
+                lon2_images = []
+                lat3_images = []
+                lon3_images = []
+                lat4_images = []
+                lon4_images = []
+                for box in boxes:
+                    # print(box.xywhr[0])
+                    x_c,y_c,w,h,r = box.xywhr[0]
+                    x_c = x_c.item()
+                    y_c = y_c.item()
+                    result = project(lat_ones[ind], lon_ones[ind])
+                    delta_y = y_c - 640
+                    delta_x = x_c - 640
+                    lat_value,lng_value = inverse_project(result[0]+delta_x,result[1]+delta_y)
+                    # st.write(box.xyxyxyxy[0][0])
+                    x1_b,y1_b,x2_b,y2_b,x3_b,y3_b,x4_b,y4_b = box.xyxyxyxy[0][0][0],box.xyxyxyxy[0][0][1],box.xyxyxyxy[0][1][0],box.xyxyxyxy[0][1][1],box.xyxyxyxy[0][2][0],box.xyxyxyxy[0][2][1],box.xyxyxyxy[0][3][0],box.xyxyxyxy[0][3][1]
+                    x1_b,y1_b,x2_b,y2_b,x3_b,y3_b,x4_b,y4_b = x1_b.item(),y1_b.item(),x2_b.item(),y2_b.item(),x3_b.item(),y3_b.item(),x4_b.item(),y4_b.item()
+                    delta_x1 = x1_b - 640
+                    delta_y1 = y1_b - 640
+                    delta_x2 = x2_b - 640
+                    delta_y2 = y2_b - 640
+                    delta_x3 = x3_b - 640
+                    delta_y3 = y3_b - 640
+                    delta_x4 = x4_b - 640
+                    delta_y4 = y4_b - 640
+                    lat1,lon1 = inverse_project(result[0]+delta_x1,result[1]+delta_y1)
+                    lat2,lon2 = inverse_project(result[0]+delta_x2,result[1]+delta_y2)
+                    lat3,lon3 = inverse_project(result[0]+delta_x3,result[1]+delta_y3)
+                    lat4,lon4 = inverse_project(result[0]+delta_x4,result[1]+delta_y4)
+                    to_add = True
+                    if len(boxes_to_take[i]) > 0:
+                        for j in range(len(boxes_to_take[i])):
+                            if np.abs(lat_value-lat_images[j]) < 0.0001 and np.abs(lng_value-lon_images[j]) < 0.0001:
+                                to_add = False
+                                if conf_images[j] < box.conf.item():
+                                    lat_images[j] = lat_value
+                                    lon_images[j] = lng_value
+                                    conf_images[j] = box.conf
+                                    class_images[j] = box.cls
+                                    boxes_to_take[j].append(box)
+                                    lat1_images[j] = lat1
+                                    lon1_images[j] = lon1
+                                    lat2_images[j] = lat2
+                                    lon2_images[j] = lon2
+                                    lat3_images[j] = lat3
+                                    lon3_images[j] = lon3
+                                    lat4_images[j] = lat4
+                                    lon4_images[j] = lon4
+                                break
+                    if to_add:
+                        lat_images.append(lat_value)
+                        lon_images.append(lng_value)
+                        conf_images.append(box.conf)
+                        class_images.append(box.cls)
+                        boxes_to_take[i].append(box)
+                        lat1_images.append(lat1)
+                        lon1_images.append(lon1)
+                        lat2_images.append(lat2)
+                        lon2_images.append(lon2)
+                        lat3_images.append(lat3)
+                        lon3_images.append(lon3)
+                        lat4_images.append(lat4)
+                        lon4_images.append(lon4)
+                # st.write(i,boxes_to_take[i])
+                bk_lats.extend(lat_images)
+                bk_lons.extend(lon_images)
+                conf_list.extend(conf_images)
+                class_list.extend(class_images)
+                lat_x1.extend(lat1_images)
+                lon_y1.extend(lon1_images)
+                lat_x2.extend(lat2_images)
+                lon_y2.extend(lon2_images)
+                lat_x3.extend(lat3_images)
+                lon_y3.extend(lon3_images)
+                lat_x4.extend(lat4_images)
+                lon_y4.extend(lon4_images)
+            
+
+                    
+
+                ind += 1
+            # st.write(bk_lats,bk_lons)
+            # st.write(len(bk_lats),len(bk_lons))
+            # st.write(n_count_ones)
+            n_counts_ones_mod = n_count_ones
+            for i in range(len(bk_lats)):
+                if bk_lats[i]>=st.session_state.box_lat2 and bk_lats[i]<=st.session_state.box_lat1 and bk_lons[i]>=st.session_state.box_lon1 and bk_lons[i]<=st.session_state.box_lon2:
+                    new_lats.append(bk_lats[i])
+                    new_lons.append(bk_lons[i])
+                    conf_new.append(conf_list[i])
+                    class_new.append(class_list[i])
+                    lat_x1_new.append(lat_x1[i])
+                    lon_y1_new.append(lon_y1[i])
+                    lat_x2_new.append(lat_x2[i])
+                    lon_y2_new.append(lon_y2[i])
+                    lat_x3_new.append(lat_x3[i])
+                    lon_y3_new.append(lon_y3[i])
+                    lat_x4_new.append(lat_x4[i])
+                    lon_y4_new.append(lon_y4[i])
+                    continue
+                else:
+                    n_counts_ones_mod -= 1
+            # st.write(n_counts_ones_mod)
+            # st.write("new")
+            # st.write(new_lats,new_lons,conf_new,class_new,boxes_to_take)
+            assert len(new_lats) == len(lat_x1_new)
+            if n_counts_ones_mod!=0:
+
+                for i in range(len(class_new)):
+                    if len(class_new[i])==1:
+                        if class_new[i].item()==0:
+                            n_fcbk += 1
+                        else:
+                            n_zig += 1
+                    else:
+                        for j in range(len(class_new[i])):
+                            if class_new[i][j].item()==0:
+                                n_fcbk += 1
+                            else:
+                                n_zig += 1
+
+                dictionary["ZIGZAG"] = n_zig
+                dictionary["FCBK"] = n_fcbk
+                dictionary["Total"] = n_zig+n_fcbk
+                df2 = pd.DataFrame(dictionary,index=[0])
+                df2 = df2.T
+                df2.columns = ['Count']
+                # middle align df2 to be at center of page
+                st.write(":red[Red] bounding boxes represent :red[FCBK] and :blue[Blue] bounding boxes represent :blue[Zigzag].")
+                st.write(df2,use_container_width=True)
+                s_no =1
+                indexs = 0
+                # st.write(len(new_lats),len(conf_new))
+                for i in range(len(new_lats)):
+                    c_var = {0:"FCBK",1:"Zigzag"}
+                    if isinstance(conf_new[indexs], torch.Tensor):
+                        for z in range(len(conf_new[indexs])):
+                            truncated_float = int(conf_new[indexs][z] * 100) / 100
+                            temp_df = pd.DataFrame({'Sr.No':[s_no],'Latitude': [new_lats[i]], 'Longitude': [new_lons[i]],'Confidence':[truncated_float],"Class":[c_var[int(class_new[i][z].item())]]})
+                            s_no+=1
+                            # Concatenate the temporary DataFrame with the main DataFrame
+                            df = pd.concat([df, temp_df], ignore_index=True)
+                    else:
+                        truncated_float = int(conf_new[indexs] * 100) / 100
+                        temp_df = pd.DataFrame({'Sr.No':[s_no],'Latitude': [new_lats[i]], 'Longitude': [new_lons[i]],'Confidence':[truncated_float],"Class":[c_var[int(class_new[i].item())]]})
+                        s_no+=1
+                        df = pd.concat([df, temp_df], ignore_index=True)
+                    indexs += 1
+                csv = df.to_csv(index=False).encode('utf-8')
+                if st.session_state.zoomed_in:
+                    # indices_of_ones = np.array(indices_of_ones)
+                    # latitudes = np.array(latitudes)
+                    # longitudes = np.array(longitudes)
+                    # lat_brick_kilns = lat_ones
+                    # lon_brick_kilns = lon_ones
+                    # indices_of_ones = indices_of_ones.tolist()
+                    # latitudes = latitudes.tolist()
+                    # longitudes = longitudes.tolist()
+                    # num_bk = 0
+                    # mid_lat = (box_lat1+box_lat2)/2
+                    # mid_lon = (box_lon1+box_lon2)/2
+                    # st.write(len(bk_lats),len(lat_x1),len(lat_x1_new),len(new_lats))
+                    st.session_state.india_map=create_map(15,location = [mid_lat,mid_lon])
+                    # rect_fg = folium.FeatureGroup()
+                    poly_fg = folium.FeatureGroup()
+                    # bounding_box_polygon.add_to(rect_fg)
+                    # st.session_state.india_map.add_child(rect_fg)
+                    for Idx in range(len(new_lats)):
+                        lat = new_lats[Idx]
+                        lon = new_lons[Idx]
+                        if lat>=st.session_state.box_lat2 and lat<=st.session_state.box_lat1 and lon>=st.session_state.box_lon1 and lon<=st.session_state.box_lon2:
+                            # continue
+                            # st.write(lat,lon)
+                            st.session_state.num_bk += 1
+                            # add_locations(lat,lon,st.session_state.india_map)
+                            add_box_to_map(lat_x1_new[Idx],lon_y1_new[Idx],lat_x2_new[Idx],lon_y2_new[Idx],lat_x3_new[Idx],lon_y3_new[Idx],lat_x4_new[Idx],lon_y4_new[Idx],class_new[Idx],poly_fg)
+                    st.session_state.india_map.add_child(poly_fg)
+                    st.session_state.zoomed_in = False
+                    st.rerun()
+                # st.write("The number of brick kilns in the selected region is: ", st.session_state.num_bk)
+                # folium_static(india_map)
+                st.markdown("### Download options")
+                # with open('images_kiln.zip', 'rb') as zip_file:
+                #     zip_data = zip_file.read()
+                # st.download_button(
+                #     label="Download Kiln Images",
+                #     data=zip_data,
+                #     file_name='images_kiln.zip',
+                #     mime="application/zip"
+                # )
+                # with open('images_no_kiln.zip', 'rb') as zip_file:
+                #     zip_data = zip_file.read()
+                # st.download_button(
+                #     label="Download Non-Kiln Images",
+                #     data=zip_data,
+                #     file_name='images_no_kiln.zip',
+                #     mime="application/zip"
+                # )
+                st.download_button(label =
+                    "Download CSV of latitude and longitude of brick kilns",
+                    data = csv,
+                    file_name = "lat_long.csv",
+                    mime = "text/csv"
+                    ) 
+                kml_content = generate_kml_content(new_lons, new_lats)
+
+                st.download_button(label =
+                    "Download KML of latitude and longitude of brick kilns",
+                    data = kml_content,
+                    file_name = "points.kml",
+                    mime = 'application/vnd.google-earth.kml+xml'
+                    ) 
+         
+
+                # Cleanup: Remove the temporary directory and zip file
+                # shutil.rmtree(temp_dir1)
+                # os.remove('images_kiln.zip')
+                # shutil.rmtree(temp_dir2)
+                # os.remove('images_no_kiln.zip')
+                
+                # st.write(class_list)
+                # t=st.toggle("plots")
+                # if t:
+                #     ####### Bounding Boxes ########
+                #     st.write("Bounding Box Predictions!")
+                #     st.write("There could be some predictions outside the bounding box as well!")
+                #     ind = 0
+                #     for i in indices_of_ones:
+                #         r = results[i]
+                #         # st.write(len(r.boxes.cls))
+                #         annotator = Annotator(image_list[i])
+                #         # image_lat = []
+                #         # image_lon = []
+                #         boxes = boxes_to_take[i]
+                #         # x_centers = []
+                #         # y_centers = []
+                #         # st.write(len(boxes),len(r.boxes))
+                #         for box in boxes:
+                #             # st.write(box.xywh[0])
+                #             # x_c,y_c,w,h = box.xywh[0]
+                #             # x_c = x_c.item()
+                #             # y_c = y_c.item()
+                #             # result = project(lat_ones[ind], lon_ones[ind])
+                #             # delta_y = y_c - 640
+                #             # delta_x = x_c - 640
+                #             # lat_value,lng_value = inverse_project(result[0]+delta_x,result[1]+delta_y)
+                #             # bk_lats.append(lat_value)
+                #             # bk_lons.append(lng_value)
+                #             # x_centers.append(x_c)
+                #             # y_centers.append(y_c)
+                #             b = box.xyxyxyxy[0]  # get box coordinates in (left, top, right, bottom) format
+                #             c = box.cls
+                #             if c.item() == 1:
+                #                 color = (0, 0, 255)
+                #             else:
+                #                 color = (255, 0, 0)
+                            
+                #             # list_box = b.tolist()
+                #             # st.write(list_box)
+                #             # two_point_list = [[list_box[0],list_box[1]],[list_box[2],list_box[3]]]
+                #             annotator.box_label(b, model.names[int(c)], color=color,rotated=True)
+                #             # write confidence to right of bounding boxes
+                #             # annotator.text((b[0]+75, b[1]+75), f"{round(box.conf.item(),2)}",txt_color=color)
+                #             # annotator.text((b[0]+85, b[1]+85), f"Lat-{b_lat},Lon-{b_lon}")
+
+                #         img = annotator.result()
+                #         # st.write(len(results))
+                #         # if isinstance(prob_flat_list[ind], torch.Tensor):
+                #         #     list_of_probs = prob_flat_list[ind].tolist()
+                #         #     for z in range(len(list_of_probs)):
+                #         #         st.write(f"Latitude: {round(latitudes[i],2)}, Longitude: {round(longitudes[i],2)}, Confidence: {round(list_of_probs[z],2)}")
+                #         # else:
+                #         #     st.write(f"Latitude: {round(latitudes[i],2)}, Longitude: {round(longitudes[i],2)}, Confidence: {round(prob_flat_list[ind],2)}")
+                        
+                #         plt.figure(figsize=(8, 4))
+                #         plt.imshow(img)
+                #         plt.axis('off')
+                #         plt.show()
+                #         # plt.scatter(640, 640, c='r', s=40)
+                #         # plt.scatter(640, 200, c='g', s=40)
+                #         # for i in range(len(x_centers)):
+                #         #     plt.scatter(x_centers[i], y_centers[i], c='b', s=40)
+                #         plt.title(f"Latitude: {round(lat_ones[ind],2)}, Longitude: {round(lon_ones[ind],2)}")
+                #         plt.tight_layout()
+                #         st.pyplot(plt)
+                #         ind += 1
+                
+                # if st.session_state.zoomed_in:
+                #     # indices_of_ones = np.array(indices_of_ones)
+                #     # latitudes = np.array(latitudes)
+                #     # longitudes = np.array(longitudes)
+                #     # lat_brick_kilns = lat_ones
+                #     # lon_brick_kilns = lon_ones
+                #     # indices_of_ones = indices_of_ones.tolist()
+                #     # latitudes = latitudes.tolist()
+                #     # longitudes = longitudes.tolist()
+                #     st.session_state.india_map=create_map(13)
+                #     bounding_box_polygon.add_to(st.session_state.india_map)
+                #     for Idx in range(len(bk_lats)):
+                #         lat = bk_lats[Idx]
+                #         lon = bk_lons[Idx]
+                #         add_locations(lat,lon,st.session_state.india_map)
+                #     st.session_state.zoomed_in = False
+                #     st.experimental_rerun()
+                
+                
+                ############## GradCAM ##############
+                # last_conv_layer_name = "block5_conv3"
+                # st.write("Let's see how well our model is identifying the pattern of brick kilns in the images.")
+                # for idx in indices_of_ones:
+
+                #     st.write("Predicted Probability: ", round(predictions_prob[idx][0],2))
+
+                #     # Load and preprocess the original image
+                #     img_array = images[idx:idx+1]
+
+                #     # Create a figure and axes for the images
+                #     fig, axs = plt.subplots(1, 2, figsize=(10, 5), gridspec_kw={'width_ratios': [1.2, 1.44]})
+
+                #     # Display the original image
+                #     axs[0].imshow(images[idx])
+                #     axs[0].set_title('Original Image',size="xx-large")
+
+                #     # Preprocess the image for GradCAM
+                #     img_array = imgs_input_fn(img_array)
+                    
+                #     # Generate class activation heatmap
+                #     heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name)
+
+                #     # Generate and display the GradCAM superimposed image
+                #     grad_fig = save_and_display_gradcam(images[idx], heatmap)
+                #     grad_plot = axs[1].imshow(grad_fig, cmap='jet', vmin=0, vmax=1)
+                #     axs[1].set_title('GradCAM Superimposed',size="xx-large")
+                #     cbar = plt.colorbar(grad_plot, ax=axs[1], pad=0.02, shrink=0.91)  
+                #     cbar.set_label('Heatmap Intensity')
+                #     cbar.ax.tick_params(labelsize=30)
+                    
+                #     for ax in axs:
+                #         ax.axis('off')
+                #     plt.tight_layout()
+                #     st.pyplot(fig)
+                
+            else:
+                st.write("No Brick Kilns detected in the selected region!")
+                # with open('images_no_kiln.zip', 'rb') as zip_file:
+                #     zip_data = zip_file.read()
+                # st.download_button(
+                #     label="Download Non-Kiln Images",
+                #     data=zip_data,
+                #     file_name='images_no_kiln.zip',
+                #     mime="application/zip"
+                # )
+                # shutil.rmtree(temp_dir2)
+                # os.remove('images_no_kiln.zip')
+
+    else:
+        st.write(":red[The bounding box area is too big. The area should be less than or equal to 0.005 sq units]")
+   
+
+
+    
+
+if __name__ == "__main__":
+    main()

packages.txt

@@ -0,0 +1 @@
+libgl1

requirements (1).txt

@@ -0,0 +1,18 @@
+folium
+gdown
+huggingface-hub
+matplotlib
+numpy
+opencv-python-headless
+pandas
+requests
+scikit-learn
+streamlit-aggrid
+streamlit-folium
+tensorflow
+torch
+streamlit==1.33.0
+ultralytics==8.2.1
+xarray
+simplekml
+dill