initial

app.py

@@ -0,0 +1,172 @@
+import streamlit as st
+import cv2
+from PIL import Image
+from io import BytesIO
+from ultralytics import YOLO
+import numpy as np
+from streamlit_option_menu import option_menu
+from markup import real_estate_app, real_estate_app_hf
+
+model = YOLO('yolov8n.onnx')
+
+PASSWORD = 'Ethan101'
+
+def authenticate(password):
+    return password == PASSWORD
+
+def tab1():
+    st.header("Human and Vehicle Recognition Demo")  
+    col1, col2 = st.columns([1, 2])
+    with col1:
+        st.image("image.jpg", use_column_width=True)
+    with col2:
+        st.markdown(real_estate_app(), unsafe_allow_html=True)
+    st.markdown(real_estate_app_hf(),unsafe_allow_html=True) 
+
+
+    github_link = '[<img src="https://badgen.net/badge/icon/github?icon=github&label">](https://github.com/ethanrom)'
+    #huggingface_link = '[<img src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue">](https://huggingface.co/ethanrom)'
+
+    st.write(github_link + '&nbsp;&nbsp;&nbsp;', unsafe_allow_html=True)
+
+def tab2():
+    st.header("Test Detection Algorithm")
+    uploaded_file = st.file_uploader('Choose an image', type=['jpg', 'jpeg', 'png'])
+    if uploaded_file is not None:
+        image = Image.open(uploaded_file)
+        image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+
+        col1, col2 = st.columns([2,1])
+        with col2:    
+            iou_threshold = st.slider('IoU Threshold', min_value=0.0, max_value=1.0, value=0.7)
+            conf_threshold = st.slider('Confidence Threshold', min_value=0.0, max_value=1.0, value=0.65)
+            show_labels = st.checkbox('Show Labels', value=False)
+            show_conf = st.checkbox('Show Confidence Scores', value=False)
+            boxes = st.checkbox('Show Boxes', value=True)
+
+        with col1:
+            st.image(image, caption='Input Image', use_column_width=True)
+            
+            if st.button('Apply and Predict'):
+                results = model(
+                    image_cv,
+                    classes=[0,2,7,3,5],
+                    iou=iou_threshold,
+                    conf=conf_threshold,
+                    show_labels=show_labels,
+                    show_conf=show_conf,
+                    boxes=boxes,        
+                    )
+
+                annotated_frame = results[0].plot()
+                annotated_image = Image.fromarray(cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB))
+                st.image(annotated_image, caption='Annotated Image', use_column_width=True)
+
+
+
+def tab3():
+    st.header("Configure and save script")
+    st.write("Please send me a DM to get the password")
+
+    password_input = st.text_input('Enter Password', type='password')
+    if authenticate(password_input):
+
+        source_folder = st.text_input('Source Folder Location')
+        results_folder = st.text_input('Destination Folder Location for Object Detection Results')
+
+        script = f"""
+import os
+import cv2
+from ultralytics import YOLO
+from tqdm import tqdm
+
+model = YOLO('yolov8n.pt')
+
+def detect_cars_humans(image_path):
+    image_cv = cv2.imread(image_path)
+    
+    # Perform object detection
+    results = model(
+        image_cv,
+        classes=[0, 2, 7, 3, 5],
+        iou=0.7,
+        conf=0.65,
+        show_labels=False,
+        show_conf=False,
+        boxes=True
+    )
+
+    if len(results[0].boxes.xyxy) == 0:
+        return
+    
+    # Create the destination folder if it doesn't exist
+    os.makedirs(r"{results_folder}", exist_ok=True)
+    
+    # Save the annotated image in the results folder
+    annotated_image_path = os.path.join(r"{results_folder}", os.path.basename(image_path))
+    cv2.imwrite(annotated_image_path, results[0].plot())
+
+source_folder = r"{source_folder}"
+image_files = [f for f in os.listdir(source_folder) if f.endswith(".png") or f.endswith(".jpg")]
+
+with tqdm(total=len(image_files), desc='Processing Images') as pbar:
+    for filename in image_files:
+        image_path = os.path.join(source_folder, filename)
+        detect_cars_humans(image_path)
+        pbar.update(1)
+"""
+        st.code(script, language='python')
+
+        if st.button('Download Script'):
+            script_filename = 'object_detection_script.py'
+            with open(script_filename, 'w') as file:
+                file.write(script)
+            st.download_button(
+                label='Download Script',
+                data=script_filename,
+                file_name=script_filename
+            )
+
+        if st.button('Download Requirements'):
+            requirements_filename = 'requirements.txt'
+            with open(requirements_filename, 'r') as file:
+                requirements_content = file.read()
+            st.download_button(
+                label='Download Requirements',
+                data=requirements_content,
+                file_name=requirements_filename
+            )
+
+        st.subheader("Instructions:")
+        st.write("1. Set the source folder and destination folder locations.")
+        st.write("2. Click on the 'Download Script' button to download the object detection script.")
+        st.write("3. Click on the 'Download Requirements' button to download the requirements.txt file.")
+        st.write("4. Open a terminal or command prompt and navigate to the project directory.")
+        st.write("5. Run the following command to install the required packages:")
+        st.code("pip install -r requirements.txt")
+        st.write("6. Finally, run the object detection script using the following command:")
+        st.code("python object_detection_script.py")
+
+    else:
+        # Password is incorrect, show an error message
+        st.error('Invalid password. Access denied.')
+
+def main():
+    st.set_page_config(page_title="Human and vehicle recognition", page_icon=":memo:", layout="wide")
+    tabs = ["Intro", "Test", "Download Script"]
+
+    with st.sidebar:
+
+        current_tab = option_menu("Select a Tab", tabs, menu_icon="cast")
+
+    tab_functions = {
+    "Intro": tab1,
+    "Test": tab2,
+    "Download Script": tab3,
+    }
+
+    if current_tab in tab_functions:
+        tab_functions[current_tab]()
+
+if __name__ == "__main__":
+    main()

markup.py

@@ -0,0 +1,72 @@
+def real_estate_app():
+    return """
+    <h3 style='text-align: center;'>Introduction</h3>
+            
+    <p>This app allows you to upload an image and remove its background using a custom trained model.</p>
+
+    <h4>Information:</h4>
+    <ul>
+        <li><b>Test Detection Algorithm:</b> In this demo you can easily test the accuracy of the detection algorithm by uploading photos with cars and humans </li>
+        <li><b>Customize and Download Script:</b> You can download the personlized script once done.</li>
+    </ul>
+    </div>          
+    """
+
+def real_estate_app_hf():
+    return """
+    <div style='text-align: left;'>
+    <h3 style='text-align: center;'>About this Demo</h3>
+    <p>In this demo, the two requested features have been split into two separate tabs for better individual evaluation. They can be combined into one in the final submission.</p>
+    <br>
+    <h4>How to use:</h4>
+    <ul>
+    <li><b>Testing:</b> Simply upload any image with humans and cars, click apply and predict button</li>
+    <li><b>Correct Perspective:</b> You can set the destination folder, source folder and other settings to your choice via the GUI and click donwload button to download the finished script.</li>
+    </ul>
+    <br>
+    </div>
+    """
+
+def sliders_intro():
+    return """
+    <p>Newly added sliders which will appear after an image is uploaded serve as interactive tools to adjust various aspects of the uploaded image. Each slider corresponds to a specific color channel (red, green, blue) or a curve adjustment. 
+    By using these sliders, users can fine-tune the color levels and apply curve modifications to achieve the desired visual effect.</p>
+    <p>For the RGB Adjustments section, users can use the Red, Green, and Blue sliders to set the minimum and maximum values for each color channel. 
+    By adjusting these values, users can enhance or reduce the intensity of each color channel individually, allowing for precise color adjustments.</p>
+    <p>In the Curves Adjustment section, users can utilize the Red Curve, Green Curve, and Blue Curve sliders to control the brightness of the respective color channels. 
+    By moving these sliders, users can create custom curves, influencing the overall tone and contrast of the image.</p>
+    <p>The Masking section offers the Threshold slider, which determines the cutoff point for the transparency mask. 
+    Users can adjust the threshold value to define the boundary between foreground and background elements. This feature enables users to isolate objects by selectively applying transparency to specific areas of the image.</p>
+    """
+
+def perspective_intro():
+    return """
+    there are two different perspective correction methods you can chose from, the difference is how they determine the transformation matrix used for warping the image.
+
+    In the Four-Point Perspective Correction, the method uses a four-point perspective transform. It first detects lines in the image using the HoughLinesP function, and then calculates the endpoints of these lines. 
+    If enough endpoints are found (at least 4), a convex hull is created based on these endpoints. From the convex hull, a four-sided polygon is obtained, representing the region of interest. 
+    The width and height of this polygon are determined, and a destination set of points is defined to which the polygon will be mapped. 
+    Finally, a perspective transformation matrix is computed using getPerspectiveTransform function, and the image is warped accordingly.
+
+    In the Convex Hull Homography Perspective Correction, a similar process is followed, but instead of using a four-point perspective transform, it uses a homography transform. 
+    After obtaining the endpoints, a convex hull is created, and a four-sided polygon is extracted from it. The width and height of this polygon are calculated, and a destination set of points is defined. 
+    But instead of using getPerspectiveTransform, the findHomography function is used to compute the homography matrix. 
+    This matrix defines the transformation between the source polygon and the destination polygon, and the image is warped using the warpPerspective function.
+
+    The parameters threshold_value, min_line_length, and max_line_gap in both methods control the detection of lines in the image. 
+    These parameters affect the number and quality of lines detected, which in turn can impact the accuracy of the perspective correction. 
+    Adjusting these values allows fine-tuning the perspective correction process based on the specific characteristics of the input image. 
+    However, it is important to note that changing these values requires some experimentation to achieve the desired results, and it is recommended to find the optimal values through trial and error.
+    """
+
+def manual_bg_intro():
+    return """
+    Click on the canvas and select four or more points, starting from any one corner of the slab and proceeding in order in any direction. The background will be removed using the selected points.
+    """
+
+def segement_intro():
+    return """
+    Uses a custom trained model on multiple variations of the provided images. Accucary will increase if more images are provided and model is fine tuned. 
+    fine tuning the model for new images is a straight forward process, necessary documentaion and guidlines will be provided.
+    Adjust the confidence score and IoU sliders to refine the selected area.
+    """

object_detection_script.py

@@ -0,0 +1,40 @@
+
+import os
+import cv2
+from ultralytics import YOLO
+from tqdm import tqdm
+
+model = YOLO('yolov8n.pt')
+
+def detect_cars_humans(image_path):
+    image_cv = cv2.imread(image_path)
+    
+    # Perform object detection
+    results = model(
+        image_cv,
+        classes=[0, 2, 7, 3, 5],
+        iou=0.7,
+        conf=0.65,
+        show_labels=False,
+        show_conf=False,
+        boxes=True
+    )
+
+    if len(results[0].boxes.xyxy) == 0:
+        return
+    
+    # Create the destination folder if it doesn't exist
+    os.makedirs(r"D:\ascii\car_person\testing\Test_Purpose\Test1_results", exist_ok=True)
+    
+    # Save the annotated image in the results folder
+    annotated_image_path = os.path.join(r"D:\ascii\car_person\testing\Test_Purpose\Test1_results", os.path.basename(image_path))
+    cv2.imwrite(annotated_image_path, results[0].plot())
+
+source_folder = r"D:\ascii\car_person\testing\Test_Purpose\Test1"
+image_files = [f for f in os.listdir(source_folder) if f.endswith(".png") or f.endswith(".jpg")]
+
+with tqdm(total=len(image_files), desc='Processing Images') as pbar:
+    for filename in image_files:
+        image_path = os.path.join(source_folder, filename)
+        detect_cars_humans(image_path)
+        pbar.update(1)

requirements.txt

@@ -0,0 +1,38 @@
+# pip install -r requirements.txt
+ultralytics
+streamlit
+streamlit_option_menu
+onnx
+onnxruntime
+tqdm 
+
+# base ----------------------------------------
+matplotlib>=3.2.2
+numpy>=1.18.5
+opencv-python
+opencv-python-headless>=4.1.2
+Pillow
+PyYAML>=5.3.1
+scipy>=1.4.1
+torch==1.7.1
+torchvision>=0.8.1
+tqdm>=4.41.0
+click==8
+
+# logging -------------------------------------
+tensorboard>=2.4.1
+# wandb
+
+# plotting ------------------------------------
+seaborn>=0.11.0
+pandas
+
+# export --------------------------------------
+# coremltools>=4.1
+# onnx>=1.8.1
+# scikit-learn==0.19.2  # for coreml quantization
+
+# extras --------------------------------------
+thop  # FLOPS computation
+pycocotools>=2.0  # COCO mAP
+scikit-learn

yolov8n.onnx

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

yolov8n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31e20dde3def09e2cf938c7be6fe23d9150bbbe503982af13345706515f2ef95
+size 6534387