one commit to rule them all

app.py

@@ -0,0 +1,265 @@
+import streamlit as st
+from PIL import Image
+import os
+from deepforest import main
+from deepforest import get_data
+import matplotlib.pyplot as plt
+# from predict import extract_features, predict_similarity, compare_features, extract_features_cp
+import os, re
+import streamlit as st
+import pandas as pd
+from PIL import Image
+import tempfile
+from inference import split_image_from_dataframe
+from datetime import datetime
+from predict import extract_features, predict_similarity, compare_features, extract_features_cp
+import cv2
+from PIL import Image
+import os
+import numpy as np
+import urllib.request
+import glob
+
+# intake library and plugin
+# import intake
+# from intake_zenodo_fetcher import download_zenodo_files_for_entry
+
+# geospatial libraries
+# import geopandas as gpd
+
+# from rasterio.transform import from_origin
+# import rasterio.features
+
+# import fiona
+
+# from shapely.geometry import shape, mapping, box
+# from shapely.geometry.multipolygon import MultiPolygon
+
+# # machine learning libraries
+# from detectron2 import model_zoo
+# from detectron2.engine import DefaultPredictor
+# from detectron2.utils.visualizer import Visualizer, ColorMode
+# from detectron2.config import get_cfg
+# from detectron2.engine import DefaultTrainer
+# # define the URL to retrieve the model
+# fn = 'model_final.pth'
+# url = f'https://zenodo.org/record/5515408/files/{fn}?download=1'
+
+# urllib.request.urlretrieve(url, config['model'] + '/' + fn)
+
+# import geoviews.tile_sources as gts
+
+# import hvplot.pandas
+# import hvplot.xarray
+
+# # hv.extension('bokeh', width=100)
+# cfg = get_cfg()
+
+# # if you want to make predictions using a CPU, run the following line. If using GPU, hash it out.
+# cfg.MODEL.DEVICE='cuda'
+
+# # model and hyperparameter selection
+# cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_101_FPN_3x.yaml"))
+# cfg.DATALOADER.NUM_WORKERS = 2
+# cfg.SOLVER.IMS_PER_BATCH = 2
+# cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1
+
+# ### path to the saved pre-trained model weights
+# cfg.MODEL.WEIGHTS = config['model'] + '/model_final.pth'
+
+# # set confidence threshold at which we predict
+# cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.15
+
+# #### Settings for predictions using detectron config
+
+# predictor = DefaultPredictor(cfg)
+# outputs = predictor(im)
+# v = Visualizer(im[:, :, ::-1], scale=1.5, instance_mode=ColorMode.IMAGE_BW)   # remove the colors of unsegmented pixels
+# v = v.draw_instance_predictions(outputs["instances"].to("cpu"))
+# image = cv2.cvtColor(v.get_image()[:, :, :], cv2.COLOR_BGR2RGB)
+# st.image(image, caption='Segmented Panoramic Image Detecttree', channels ='RGB', use_column_width=True)
+
+
+model = main.deepforest()
+model.use_release()
+
+# Set the page configuration
+st.set_page_config(page_title="Wise-Vision", page_icon=":deciduous_tree:")
+
+# Title and description
+st.title("🌳 Wise-Vision")
+st.subheader("AI + Environment Hackathon 2024")
+
+# Sidebar information
+st.sidebar.title("About")
+st.sidebar.info(
+    """
+    This app is designed for the AI + Environment Hackathon 2024.
+    Upload a panoramic image and specify a folder path to detect tree species in the image.
+    Upload a word file to integrate knowledge into the image.
+    Output will be a panoramic image with identified trees and knowledge symbols.
+    """
+)
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    For more information, contact us at:
+    [rajbhalwankar@protonmail.com]
+    """
+)
+
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# Create a new folder within the script directory for storing cropped images
+timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+output_folder_name = f"output_{timestamp}"
+output_image_folder = os.path.join(script_dir, output_folder_name)
+os.makedirs(output_image_folder, exist_ok=True)
+output_image_folder = os.path.abspath(output_image_folder)
+# Define paths for the image and Excel file within the new folder
+cropped_image_path = os.path.join(output_image_folder, f"panoramic_{timestamp}.png")
+excel_output_path = os.path.join(output_image_folder, f"results_{timestamp}.xlsx")
+
+# Input: Upload panoramic image
+uploaded_image = st.file_uploader("Upload a panoramic image", type=['png', 'jpeg', 'JPG'])
+
+# Input: Folder path for tree species detection
+
+def extract_treespecies_features(folder_path):
+    image_files = [os.path.join(folder_path, f) for f in os.listdir(folder_path) if f.endswith(('png', 'jpg', 'jpeg', '.JPG'))]
+
+    species_feature_list = [{"feature": extract_features(file), "file_name": file} for file in image_files]
+    return species_feature_list
+
+
+# print(species_feature_list[:2])
+def perform_inference(cropped_images, species_feature_list, img_df):
+
+    for img_idx, item in enumerate(cropped_images):
+        image = item["image"]
+        feature_cp = extract_features_cp(image)
+        row_results = []
+        species_result = []
+        emoji = []
+        species_context = []
+        for idx, species in enumerate(species_feature_list):
+            # euclidean_dist, cos_sim = compare_features(feature_cp, species["feature"])
+        # print(f'Euclidean Distance: {euclidean_dist}')
+        # print(f'Cosine Similarity: {cos_sim}')
+
+        # Predict similarity
+            is_similar = predict_similarity(feature_cp, species["feature"], threshold=0.92)
+        # print(species)
+        # print(f'Are the images similar? {"Yes" if is_similar else "No"}')
+
+            result = "Yes" if is_similar else "No"
+
+            if result == "Yes":
+                item[f"result_{idx}"] = result
+                item[f"file_name_{idx}"] = species["file_name"]
+                row_results.append(species["file_name"])
+                # # Regular expression to match the tree species name
+                # species_pattern = r'identified_species\\([^\\]+) -'
+
+                # # Search for the pattern in the file path
+                # match = re.search(species_pattern, species["file_name"])
+
+                # Extract and print the tree species name if found
+              
+                    # species_info = retriever.invoke(f"Scientific name:{tree_species}")
+                    
+                    # ans = generate_image(species_info, client)
+                    # emoji.append(ans)
+                    # text_context = [doc.page_content for doc in species_info]
+                    # text_context = ", ".join(text_context)
+                    # species_context.append(text_context)
+                    # print(ans)
+                    # species_result.append(tree_species)
+    
+        img_df.at[img_idx, "species_identified"] = ", ".join(species_result) if species_result else "No similar species found"            
+        img_df.at[img_idx, "result_file_path"] = ", ".join(row_results) if row_results else ""
+        # img_df.at[img_idx, "emoji"] = ", ".join(emoji) if emoji else ""
+        # img_df.at[img_idx, "retreived context"] = ", ".join(species_context) if species_context else ""
+        
+        
+    return cropped_images
+
+
+# Function to simulate tree species detection
+
+# Display uploaded image and detected tree species
+if uploaded_image is not None:
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.JPG') as temp_file:
+        temp_file.write(uploaded_image.read())
+        temp_file_path = temp_file.name
+    # Open and display the image
+    # image = Image.open(uploaded_image)
+    sample_image_path = get_data(temp_file_path)
+    boxes = model.predict_image(path=sample_image_path, return_plot=False)
+    img_actual = model.predict_image(path=sample_image_path, return_plot=True, color=(137, 0, 0), thickness=9)
+    st.image(img_actual, caption='Segmented Panoramic Image', channels ='RGB', use_column_width=True)
+    st.success("Sample Dataframe:")
+    st.dataframe(boxes.head())
+    plt.imshow(img_actual[:,:,::-1])
+    # plt.show(img[:,:,::-1])
+    plt.savefig(cropped_image_path)
+    # if st.button("Next Step"):
+  
+    accuracy_threshold = st.slider("Accuracy threshold for cropping images:",min_value=0.1, max_value=1.0, value=0.4)
+    images_list = split_image_from_dataframe(boxes, temp_file_path, output_folder_name)
+    image_width = 200
+    st.success("Sample Images:")
+    # Display the images in a row
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.image(images_list[3]["image"], caption="Sample 1", width=image_width)
+
+    with col2:
+        st.image(images_list[4]["image"], caption="Sample 2", width=image_width)
+
+    with col3:
+        st.image(images_list[5]["image"], caption="Sample 3", width=image_width)
+    
+    folder_path = './identified_species'
+
+    species_feature_list = extract_treespecies_features(folder_path)
+    final_result = perform_inference(images_list, species_feature_list, boxes)
+    st.success("Final Data:")
+    st.dataframe(boxes)
+    boxes.to_excel(excel_output_path)
+    for index, row in boxes.iterrows():
+        species_identified = row['species_identified']
+        if species_identified !="No similar species found":
+            cropped_image_path = row['cropped_image_path']
+            result_file_path = row['result_file_path']
+            if type(result_file_path) == list:
+                result_file_path = result_file_path[0]
+                
+
+            result_file_path = result_file_path.split(',')[0]
+            st.write(species_identified)
+            col1, col2 = st.columns(2)
+            with col1:
+                st.image(cropped_image_path, caption='Cropped Image')
+            with col2:
+                st.image(result_file_path, caption='Species Match')
+            
+            
+
+            
+            
+
+    
+    # Detect tree species
+    # detected_species = detect_tree_species(image, folder_path)
+    
+    # Display detected tree species
+    # st.write("### Detected Tree Species:")
+    # for species in detected_species:
+    #     st.write(f"- {species}")
+
+
+

inference.py

@@ -0,0 +1,103 @@
+from deepforest import main
+from deepforest import get_data
+import matplotlib.pyplot as plt
+from predict import extract_features, predict_similarity, compare_features, extract_features_cp
+import os
+import streamlit as st
+model = main.deepforest()
+model.use_release()
+
+# quit()
+# print(img.head())
+import pandas as pd
+from PIL import Image
+
+
+def split_image_from_dataframe(dataframe, panoramic_image, output_folder_name):
+    """
+    Splits an image into multiple images based on coordinates provided in a dataframe.
+
+    Parameters:
+    dataframe (pd.DataFrame): DataFrame containing image path and coordinates.
+    """
+    cropped_images_info = []
+    cropped_image_paths = []
+    for i, row in dataframe.iterrows():
+        image_path = row['image_path']
+        left, top, right, bottom = row['xmin'], row['ymin'], row['xmax'], row['ymax']
+
+        image = Image.open(panoramic_image)
+        
+        cropped_image = image.crop((left, top, right, bottom))
+        cropped_image_dict = {
+            f'image': cropped_image,
+            f'position': (left, top, right, bottom)
+        }
+        cropped_images_info.append(cropped_image_dict)
+        cropped_image_paths.append(f'{output_folder_name}/cropped_image_{i}.png')
+        cropped_image.save(f'{output_folder_name}/cropped_image_{i}.png')  # Save each cropped image
+    
+    dataframe['cropped_image_path'] = cropped_image_paths
+    return cropped_images_info
+
+
+# print(images_list)
+# quit()
+# Load images from folder
+def extract_treespecies_features(folder_path):
+    image_files = [os.path.join(folder_path, f) for f in os.listdir(folder_path) if f.endswith(('png', 'jpg', 'jpeg', '.JPG'))]
+
+    species_feature_list = [{"feature": extract_features(file), "file_name": file} for file in image_files]
+    return species_feature_list
+
+
+# print(species_feature_list[:2])
+def perform_inference(images_list, species_feature_list):
+    for idx, item in enumerate(images_list):
+        image = item["image"]
+        feature_cp = extract_features_cp(image)
+        for idx, species in enumerate(species_feature_list):
+            euclidean_dist, cos_sim = compare_features(feature_cp, species["feature"])
+        # print(f'Euclidean Distance: {euclidean_dist}')
+        # print(f'Cosine Similarity: {cos_sim}')
+
+        # Predict similarity
+            is_similar = predict_similarity(feature_cp, species["feature"], threshold=0.8)
+        # print(species)
+        # print(f'Are the images similar? {"Yes" if is_similar else "No"}')
+
+            result = "Yes" if is_similar else "No"
+            if result == "Yes":
+                item[f"result_{idx}"] = result
+                item[f"file_name_{idx}"] = species["file_name"]
+
+    return images_list
+
+
+
+
+if __name__ == '__main__':
+    pan_image = "D:/Downloads/image/plant_images/plant_images/drone_igapo_flooded_forest/DJI_20240504124024_0037_D.JPG"
+
+    sample_image_path = get_data(pan_image)
+    # img = model.predict_image(path=sample_image_path, return_plot=False)
+    # from PIL import Image
+    # print(img)
+    img_df = ""
+    # img_actual = model.predict_image(path=sample_image_path, return_plot=True, color=(0, 165, 255), thickness=9)
+    img_actual = model.predict_tile(raster_path=sample_image_path, return_plot=True, patch_size=100,patch_overlap=0.25)
+    # im = Image.open('Foto.jpg')
+    # im.save('Foto.png')
+    #predict_image returns plot in BlueGreenRed (opencv style), but matplotlib likes RedGreenBlue, switch the channel order. Many functions in deepforest will automatically perform this flip for you and give a warning.
+    plt.imshow(img_actual[:,:,::-1])
+    # plt.show(img[:,:,::-1])
+    plt.savefig("cropped_test3/panoramic_2.png")
+    quit()
+    images_list = split_image_from_dataframe(img_df, pan_image)
+    folder_path = 'D:/Downloads/image/plant_images/plant_images/drone_igapo_flooded_forest/identified_species'
+
+    species_feature_list = extract_treespecies_features()
+    final_result = perform_inference(images_list, species_feature_list)
+    print(final_result)
+
+

predict.py

@@ -0,0 +1,80 @@
+from keras.applications.vgg16 import VGG16, preprocess_input
+from keras.preprocessing import image
+from keras.models import Model
+import numpy as np
+from scipy.spatial.distance import euclidean
+from sklearn.metrics.pairwise import cosine_similarity
+from PIL import Image 
+from keras.applications.efficientnet import EfficientNetB0
+# Load VGG16 model + higher level layers
+base_model = VGG16(weights='imagenet')
+model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc1').output)
+# Load EfficientNetB0 model + higher level layers
+# base_model = EfficientNetB0(weights='imagenet')
+# model = Model(inputs=base_model.input, outputs=base_model.get_layer('top_activation').output)
+
+def extract_features_cp(pil_img: Image.Image) -> np.ndarray:
+    # Resize the image to the target size
+    pil_img = pil_img.resize((224, 224))  # (224, 224)
+    
+    # Convert the PIL image to a numpy array
+    img_data = image.img_to_array(pil_img)
+    
+    # Expand dimensions to match the input shape required by the model
+    img_data = np.expand_dims(img_data, axis=0)
+    
+    # Preprocess the image data
+    img_data = preprocess_input(img_data)
+    
+    # Predict the features using the model
+    features = model.predict(img_data)
+    
+    # Return the features as a flattened array
+    return features.flatten()
+
+def extract_features(img_path):
+    img = image.load_img(img_path, target_size=(224, 224))  # (224, 224)
+    img_data = image.img_to_array(img)
+    img_data = np.expand_dims(img_data, axis=0)
+    img_data = preprocess_input(img_data)
+    features = model.predict(img_data)
+    return features.flatten()  # Flatten the features to a 1-D vector
+
+def compare_features(features1, features2):
+    # Euclidean distance
+    euclidean_dist = euclidean(features1, features2)
+    
+    # Cosine similarity
+    cos_sim = cosine_similarity([features1], [features2])[0][0]
+    
+    return euclidean_dist, cos_sim
+
+def predict_similarity(features1, features2, threshold=0.5):
+    _, cos_sim = compare_features(features1, features2)
+    similarity_score = cos_sim
+    # print(similarity_score)
+    
+    if similarity_score > threshold:
+        return True
+    else:
+        return False
+
+
+
+if __name__ == '__main__':
+    # Example usage
+    img_path1 = "D:/Downloads/image/rose.jpg"
+    img_path2 = "D:/Downloads/image/rose.jpg"
+
+    # Extract features
+    features1 = extract_features(img_path1)
+    features2 = extract_features(img_path2)
+
+    # Compare features
+    euclidean_dist, cos_sim = compare_features(features1, features2)
+    print(f'Euclidean Distance: {euclidean_dist}')
+    print(f'Cosine Similarity: {cos_sim}')
+
+    # Predict similarity
+    is_similar = predict_similarity(features1, features2, threshold=0.8)
+    print(f'Are the images similar? {"Yes" if is_similar else "No"}')

predict_copy.py

@@ -0,0 +1,110 @@
+from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.models import Model
+import numpy as np
+from scipy.spatial.distance import euclidean
+from sklearn.metrics.pairwise import cosine_similarity
+# Load VGG16 model + higher level layers
+base_model = VGG16(weights='imagenet')
+model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc1').output)
+
+# Define data augmentation
+datagen = ImageDataGenerator(
+    rotation_range=20,
+    width_shift_range=0.2,
+    height_shift_range=0.2,
+    shear_range=0.2,
+    zoom_range=0.2,
+    horizontal_flip=True,
+    fill_mode='nearest'
+)
+
+def extract_features(img):
+    img = img.resize((224, 224))  # Ensure the image is resized to the input size expected by VGG16
+    img_data = image.img_to_array(img)
+    img_data = np.expand_dims(img_data, axis=0)
+    img_data = preprocess_input(img_data)
+    features = model.predict(img_data)
+    return features.flatten()  # Flatten the features to a 1-D vector
+
+def augment_image(img):
+    x = image.img_to_array(img)
+    x = x.reshape((1,) + x.shape)  # Reshape to (1, height, width, channels)
+
+    # Generate batches of augmented images
+    augmented_images = []
+    for batch in datagen.flow(x, batch_size=1):
+        augmented_images.append(image.array_to_img(batch[0]))
+        if len(augmented_images) >= 5:  # Generate 5 augmented images
+            break
+    return augmented_images
+
+def extract_features_with_augmentation(img_path):
+    original_img = image.load_img(img_path)
+    augmented_images = augment_image(original_img)
+    
+    # Extract features from the original image
+    features = [extract_features(original_img)]
+    
+    # Extract features from augmented images
+    for aug_img in augmented_images:
+        features.append(extract_features(aug_img))
+    
+    return np.mean(features, axis=0)  # Return the average feature vector
+
+
+def extract_features_with_augmentation_cp(img_path):
+    pil_img = pil_img.resize((224, 224))  # (224, 224)
+    
+    # Convert the PIL image to a numpy array
+    
+    augmented_images = augment_image(pil_img)
+    
+    # Extract features from the original image
+    features = [extract_features(augmented_images)]
+    
+    # Extract features from augmented images
+    for aug_img in augmented_images:
+        features.append(extract_features(aug_img))
+    
+    return np.mean(features, axis=0)  # Return the average feature vector
+
+
+
+def compare_features(features1, features2):
+    # Euclidean distance
+    euclidean_dist = euclidean(features1, features2)
+    
+    # Cosine similarity
+    cos_sim = cosine_similarity([features1], [features2])[0][0]
+    
+    return euclidean_dist, cos_sim
+
+def predict_similarity(features1, features2, threshold=0.5):
+    _, cos_sim = compare_features(features1, features2)
+    similarity_score = cos_sim
+    # print(similarity_score)
+    
+    if similarity_score > threshold:
+        return True
+    else:
+        return False
+
+if __name__ == '__main__':
+    # Example usage
+    img_path1 = "D:/Downloads/image/rose.jpg"
+    img_path2 = "D:/Downloads/image/rose3.jpg"
+
+    # Extract features
+    features1 = extract_features_with_augmentation(img_path1)
+    features2 = extract_features_with_augmentation(img_path2)
+
+    # Compare features
+    euclidean_dist, cos_sim = compare_features(features1, features2)
+    print(f'Euclidean Distance: {euclidean_dist}')
+    print(f'Cosine Similarity: {cos_sim}')
+
+    # Predict similarity
+    is_similar = predict_similarity(features1, features2, threshold=0.8)
+    print(f'Are the images similar? {"Yes" if is_similar else "No"}')

predict_vit.py

@@ -0,0 +1,66 @@
+import torch
+import clip
+from PIL import Image
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Load the CLIP model
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model, preprocess = clip.load("ViT-B/32", device=device)
+
+def extract_features_cp(pil_img: Image.Image) -> np.ndarray:
+    # Preprocess the PIL image using CLIP's preprocess function
+    img = preprocess(pil_img).unsqueeze(0).to(device)
+    
+    # Extract features using CLIP
+    with torch.no_grad():
+        features = model.encode_image(img)
+    
+    # Normalize the features
+    features = features / features.norm(dim=-1, keepdim=True)
+    
+    # Convert to numpy array and return as a flattened array
+    return features.cpu().numpy().flatten()
+
+def extract_features(img_path):
+    # Load and preprocess the image
+    img = preprocess(Image.open(img_path)).unsqueeze(0).to(device)
+    
+    # Extract features using CLIP
+    with torch.no_grad():
+        features = model.encode_image(img)
+    
+    # Normalize the features
+    features = features / features.norm(dim=-1, keepdim=True)
+    
+    # Convert to numpy array
+    return features.cpu().numpy().flatten()
+
+def compare_features(features1, features2):
+    # Cosine similarity
+    cos_sim = cosine_similarity([features1], [features2])[0][0]
+    
+    return cos_sim
+
+def predict_similarity(features1, features2, threshold=0.5):
+    cos_sim = compare_features(features1, features2)
+    similarity_score = cos_sim
+    
+    return similarity_score > threshold
+
+if __name__ == '__main__':
+    # Example usage
+    img_path1 = 'result.jpg'
+    img_path2 = 'Vochysia.jpg'
+
+    # Extract features
+    features1 = extract_features(img_path1)
+    features2 = extract_features(img_path2)
+
+    # Compare features
+    cos_sim = compare_features(features1, features2)
+    print(f'Cosine Similarity: {cos_sim}')
+
+    # Predict similarity
+    is_similar = predict_similarity(features1, features2, threshold=0.8)
+    print(f'Are the images similar? {"Yes" if is_similar else "No"}')

rag.py

@@ -0,0 +1,84 @@
+from langchain_community.document_loaders import Docx2txtLoader
+from langchain_community.document_transformers import DoctranTextTranslator
+from langchain_core.documents import Document
+from dotenv import load_dotenv
+from langchain_community.retrievers import BM25Retriever
+import openai
+
+# Set your OpenAI API key
+# openai.api_key = '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'
+
+from openai import OpenAI
+from os import getenv
+from langchain_core.documents import Document
+from langchain_text_splitters import CharacterTextSplitter
+
+def setup_retriever():
+    knowledge_file = "E:/Backup_K20pro/Download/treesat_benchmark/Canopy species list and uses (PT)_pt_en.docx"
+    loader = Docx2txtLoader(knowledge_file) 
+    data = loader.load()
+    text_splitter = CharacterTextSplitter(
+    separator="-",
+    chunk_size=600,
+    chunk_overlap=0,
+    length_function=len,
+    is_separator_regex=False,
+)
+    chunks = text_splitter.split_documents(data)
+# print(chunks)
+    retriever = BM25Retriever.from_documents(chunks)
+    retriever.k = 1
+    return retriever
+
+retriever = setup_retriever()
+species = 'Byrsonima'
+species_info = retriever.invoke(f"Scientific name:{species}")
+print(species_info)
+# qa_translator = DoctranTextTranslator(language="english")
+# translated_document = qa_translator.transform_documents(data)
+# print(translated_document)
+
+
+info = 'Scientific name:Licaniasp.\n\nFamily:Chrysobalanaceae\n\nPopular name:They are generally known as caripé or macucu, among other generic names.\n\nHabitat:LicaniaIt is a large genus, with dozens of species distributed in all Amazon habitats, species that are difficult to identify without fertile material.\n\nUses:Some species can be edible, others known as caripé had (have) their bark roasted (presence of silica), macerated and together with clay used in the preparation of ceramics by indigenous populations.'
+# gets API Key from environment variable OPENAI_API_KEY
+def setup_client():
+    client = OpenAI(
+  base_url="https://openrouter.ai/api/v1",
+  api_key=getenv("OPENROUTER_API_KEY"),
+)
+    
+    return client
+
+client = setup_client()
+
+def generate_image(species_info, client):
+    completion = client.chat.completions.create(
+  model="openai/gpt-3.5-turbo",
+  messages=[
+    {
+      "role": "user",
+
+      "content": f"Using the trees species information provided below, Using the information in the 'Uses:' section. Generate 1 useful and informative unicode image to be used to be placed on a drone panoramic image. Tree species info:{species_info}",
+    },
+  ],
+)
+    return completion.choices[0].message.content
+
+
+if __name__ == '__main__':
+    ans = generate_image(species_info, client)
+    print(ans)
+# # Define the prompt and parameters for the request
+# prompt = "Once upon a time"
+# response = openai.Completion.create(
+#     engine="gpt-3.5-turbo",  # Use the GPT-3.5 model
+#     prompt=prompt,
+#     max_tokens=50,  # Adjust the number of tokens based on your requirement
+#     n=1,
+#     stop=None,
+#     temperature=0.7,
+# )
+
+# # Print the generated text
+# generated_text = response.choices[0].text.strip()
+# print(generated_text)

requirements.txt

@@ -0,0 +1,16 @@
+torch
+torchvision
+torchaudio
+geopandas
+rasterio
+fiona
+shapely
+opencv-python
+gradio
+deepforest
+matplotlib
+keras
+tensorflow
+openpyxl
+
+

setup.sh

@@ -0,0 +1,12 @@
+# setup.sh
+sudo apt update
+sudo apt install -y libgdal-dev
+sudo apt install -y gdal-bin
+export CPLUS_INCLUDE_PATH=/usr/include/gdal
+export C_INCLUDE_PATH=/usr/include/gdal
+pip install -r requirements.txt
+pip install GDAL
+pip install git+https://github.com/PatBall1/detectree2.git
+pip install git+https://github.com/openai/CLIP.git
+pip install git+https://github.com/facebookresearch/detectron2.git@5aeb252b194b93dc2879b4ac34bc51a31b5aee13
+pip install detectron2==0.6 -f \ https://dl.fbaipublicfiles.com/detectron2/wheels/cu113/torch1.10/index.html