Added GUI for saturation, brightness, hsv, and update doc for test_pf

README.md

@@ -2,55 +2,54 @@
 
 > For AgroBot one of the main concern is the robot's navigation. The robot must autonomously navigate the crop rows and for this task we are taking a computer vision approach. The goal of this script is to efficiently detect crop rows on a video.
 
-## Getting started
+# Getting started
 
-### How to install
+# How to install
 
-- install [python 3.9](https://www.python.org/downloads/release/python-390/)
+- install[python 3.9](https: // www.python.org/downloads/release/python-390/)
 - `git clone` this repository
 - run `pip install pipenv`
 - `cd` into project root
 - run `pipenv install` to install project dependencies
 - run `pipenv shell` to launch virtual environment
 
-### Scripts
+# Scripts
 
-`test_algorithms.py:`
+`test_algorithms.py: `
 
 - runs any of the 4 algorithms against any video
-- arguments :
-  - `-a/--alg` : name of algorithm
-    - `hough`, `center_row`, `mini_contour` or `scanning`
-  - `-v/--vid` : name of video
-    - video has to be stored in `./videos/`
-    - video configuration has to be stored as a `yaml` at `./config/video/`
-  - `-s/--show` : process drawings and show frame
-- example : `python test_algorithms.py -a center_row -v crop`
+- arguments:
+    - `-a/--alg`: name of algorithm
+     - `hough`, `center_row`, `mini_contour` or `scanning`
+    - `-v/--vid`: name of video
+     - video has to be stored in `./videos/`
+      - video configuration has to be stored as a `yaml` at `./config/video/`
+    - `-s/--show`: process drawings and show frame
+- example: `python test_algorithms.py - a center_row - v crop`
 
-`create_dataset.py:`
+`create_dataset.py: `
 
 - aids in data extraction from any video
-- arguments :
-  - `-v/--vid` : name of video
-    - video has to be stored in `./videos/`
-  - `-i/--interval (optional, default = 30)`: interval between keyframes
-  - `-o/--overwrite (optional, default = False)` : flag to indicate that you wish to overwrite files at `./extract/vid`
-- example : `python create_dataset.py -v sim` or `python create_dataset.py -v crop -i 60 -o`
-
-`test_pf.py:`
-
-- runs performance tests on any of the algorithms against any video
-- reports `framerate`, `time-to-finish`, `vanishing point uptime`, `avg time to process frame`
-- arguments :
-  - `-a/--alg` : name of algorithm
-    - `hough`, `center_row`, `mini_contour`, `mini_contour_downward`, `scanning`, `check_row_end` or `center_down`
-  - `-v/--vid` : name of video
-    - video has to be stored in `./videos/`
-    - video configuration has to be stored as a `yaml` at `./config/video/`
-  - `-s/--show` : process drawings and show frame
-- example : `python test_pf.py -a center_row -v farm4`
-
-### Commands to Start World in Gazebo
+- arguments:
+    - `-v/--vid`: name of video
+     - video has to be stored in `./videos/`
+    - `-i/--interval(optional, default=30)`: interval between keyframes
+    - `-o/--overwrite(optional, default=False)`: flag to indicate that you wish to overwrite files at `./extract/vid`
+- example: `python create_dataset.py - v sim` or `python create_dataset.py - v crop - i 60 - o`
+
+`test_pf.py: `
+ - runs performance tests on any of the algorithms against any video with an optional GUI
+  - reports `framerate`, `time-to-finish`, `vanishing point uptime`, `avg time to process frame`
+   - arguments:
+        - `-a/--alg`: name of algorithm
+         - `hough`, `center_row`, `mini_contour`, `mini_contour_downward`, `scanning`, `seesaw`, or `check_row_end`
+        - `-v/--vid`: name of video
+         - video has to be stored in `./videos/`
+          - video configuration has to be stored as a `yaml` at `./config/video/`
+        - `-s/--show`: creates a GUI that shows the frame, allow filter, toggle between views, adjust saturation, brightness, upper, and lower HSV
+    - example : `python test_pf.py - a center_row - v crop - s`
+
+# Commands to Start World in Gazebo
 
 Run the following Commands the first time:
 
@@ -60,21 +59,21 @@ Run the following Commands the first time:
 Run the following commands to open the world:
 
 - Go to agrobot_ws/src folder
-- Run bash script (start_corn_fields.sh or start_wheat_fields.sh)
+- Run bash script(start_corn_fields.sh or start_wheat_fields.sh)
 
 To run PID, open a new terminal:
 
 - Run run_controller bash script
 
 To reset the position of the robot:
 
-- Edit > Reset model poses (to reset the position of your robot to the start position)
+- Edit > Reset model poses(to reset the position of your robot to the start position)
 
-## Demo
+# Demo
 
 ![](/readme_files/demo_vid.mp4)
 
-### Colour Filtering
+# Colour Filtering
 
 To accomplish this task, we need to first denoise the image. In particular, since we know we are looking for crops which
 are green in colour, we can filter based on colour. We convert our image to HSV format and define upper and lower bound
@@ -90,9 +89,9 @@ By using bitwise and operator we see that this mask does correspond to the green
 
 ![crop bitwise](/readme_files/greenregions.png)
 
-### Denoising and Smoothing
+# Denoising and Smoothing
 
-Next, we need to denoise the resulting mask (which is a binary image containing the crop rows). To do this, we perform
+Next, we need to denoise the resulting mask(which is a binary image containing the crop rows). To do this, we perform
 gaussian blurring following by multiple iterations of dilation. Here is the resulting mask after dilation:
 
 ![denoising](/readme_files/denoising.png)
@@ -102,7 +101,7 @@ and also we want rows that are far from the camera to be merged into one. This i
 our navigation system and by merging them, we can avoid detecting them in our edge and line detection in subsequent
 steps.
 
-### Line Detection
+# Line Detection
 
 Although, the mask image is a binary image and it can be used directly with Hough transform, the large number of points
 in the image lead to noisy and slow computation. Hence, Canny edge detection was used to first decrease the number of
@@ -116,7 +115,7 @@ image shows the resulting lines we detected.
 
 ![Houghlines](/readme_files/Houghlines.png)
 
-### How does this fit in with the rest of the system?
+# How does this fit in with the rest of the system?
 
 We are currently using these lines and calculating their intersection which occurs at vanishing point. Then we are using
 a PID controller to minimimize the distance of this vanishing point from the center of our frame. Using this method, we

algorithms/CenterRowAlgorithm.py

@@ -2,8 +2,8 @@
 
 import cv2 as cv
 import numpy as np
-from algorithms.Algorithm import Algorithm
 
+from algorithms.Algorithm import Algorithm
 from algorithms.utils import Lines
 
 
@@ -18,6 +18,7 @@ def __init__(self, config):
         # masking range for green
         self.LOW_GREEN = np.array(config.lower_hsv_threshold)
         self.HIGH_GREEN = np.array(config.upper_hsv_threshold)
+        # print(self.LOW_GREEN, self.HIGH_GREEN)
 
         # filtering parameters
         self.averaging_kernel_size = config.averaging_kernel_size
@@ -44,6 +45,16 @@ def __init__(self, config):
         self.center = None
         self.center_angle = 0
 
+    def get_extra_content(self, frame, show):
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2
+
+    def update_lower_hsv(self, next):
+        self.LOW_GREEN = np.array(next)
+
+    def update_upper_hsv(self, next):
+        self.HIGH_GREEN = np.array(next)
+
     def process_frame(self, frame, show):
         """Uses contouring to create contours around each crop row and uses these contours to find centroid lines,
         row vanishing point, a center contour and the angle between the center contour and vanishing point\n

algorithms/CheckRowEnd.py

@@ -17,6 +17,16 @@ def __init__(self, config):
         # Percentage of empty rows required to register as row end
         self.percentage_of_empty_rows = config.percentage_of_empty_rows
 
+    def get_extra_content(self, frame, show):
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2
+
+    def update_lower_hsv(self, next):
+        self.LOW_GREEN = np.array(next)
+
+    def update_upper_hsv(self, next):
+        self.HIGH_GREEN = np.array(next)
+
     def process_frame(self, frame, show):
         """Averages values in each row in a mask of the frame. If the number of rows with an average value
         of zero is greater than req_rows_empty, then frame is row end\n

algorithms/HoughAlgorithm.py

@@ -32,6 +32,16 @@ def __init__(self, config):
         # resize factor
         self.RESIZE_FACTOR = config.resize_factor
 
+    def get_extra_content(self, frame, show):
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2
+
+    def update_lower_hsv(self, next):
+        self.LOW_GREEN = np.array(next)
+
+    def update_upper_hsv(self, next):
+        self.HIGH_GREEN = np.array(next)
+
     # processFrame function that is called to process a frame of a video
     # takes in frame mat object obtained from cv2 video.read()
     def process_frame(self, frame, show=True):

algorithms/MiniContoursAlgorithm.py

@@ -1,11 +1,13 @@
-import cv2
-import numpy as np
-import time
+import math
 import operator
 import sys
-import math
-from algorithms.utils import Lines
+import time
+
+import cv2
+import numpy as np
+
 from algorithms.Algorithm import Algorithm
+from algorithms.utils import Lines
 
 
 class MiniContoursAlgorithm(Algorithm):
@@ -199,6 +201,16 @@ def get_center_hough_lines(
 
         return frame, lines, point_lines
 
+    def get_extra_content(self, frame, show):
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2
+
+    def update_lower_hsv(self, next):
+        self.LOW_GREEN = np.array(next)
+
+    def update_upper_hsv(self, next):
+        self.HIGH_GREEN = np.array(next)
+
     def process_frame(self, original_frame, num_strips=60, show=False):
 
         # original_frame: BGR frame

algorithms/MiniContoursDownwards.py

@@ -152,6 +152,16 @@ def get_best_fit_line(self, frame, show, num_strips=60, dist_type=cv2.DIST_L2, p
 
         return frame, line
 
+    def get_extra_content(self, frame, show):
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2
+
+    def update_lower_hsv(self, next):
+        self.LOW_GREEN = np.array(next)
+
+    def update_upper_hsv(self, next):
+        self.HIGH_GREEN = np.array(next)
+
     def process_frame(self, original_frame, num_strips=60, show=False):
         """""
         parameters:

algorithms/ScanningAlgorithm.py

@@ -74,6 +74,16 @@ def create_line(self, start_x, start_y, end_x, end_y):
 
         return line
 
+    def get_extra_content(self, frame, show):
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2
+
+    def update_lower_hsv(self, next):
+        self.LOW_GREEN = np.array(next)
+
+    def update_upper_hsv(self, next):
+        self.HIGH_GREEN = np.array(next)
+
     def process_frame(self, frame, show):
 
         hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

algorithms/SeesawAlgorithm.py

@@ -23,6 +23,16 @@ def __init__(self, config):
         self.HEIGHT = int(config.frame_length)
         self.WIDTH = int(config.frame_width)
 
+    def get_extra_content(self, frame, show):
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2
+
+    def update_lower_hsv(self, next):
+        self.LOW_GREEN = np.array(next)
+
+    def update_upper_hsv(self, next):
+        self.HIGH_GREEN = np.array(next)
+
     def process_frame(self, frame, show):
 
         black_frame, points, both_points = self.plot_points(frame)