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

Pipfile

@@ -9,6 +9,7 @@ omegaconf = "*"
 numpy = "*"
 tk = "*"
 python-rospkg = "*"
+Pillow = "*"
 
 [dev-packages]
 

README.md

@@ -38,18 +38,17 @@
 - 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
+- runs performance tests on 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`, `check_row_end` or `center_down`
+    - `hough`, `center_row`, `mini_contour`, `mini_contour_downward`, `scanning`, `seesaw`, `seesaw_v2`, 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` : process drawings and show frame
-- example : `python test_pf.py -a center_row -v farm4`
-
+  - `-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 seesaw -v crop -s`
+  
 ### Commands to Start World in Gazebo
 
 Run the following Commands the first time:
@@ -120,4 +119,4 @@ image shows the resulting lines we detected.
 
 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
-are able to centre our chassis over the crop rows we are traversing.
+are able to centre our chassis over the crop rows we are traversing.

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,17 @@ def __init__(self, config):
         self.center = None
         self.center_angle = 0
 
+    def get_extra_content(self, frame, show):
+        maskf = self.create_binary_mask(frame)
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2, maskf
+
+    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,17 @@ 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):
+        maskf = self.create_binary_mask(frame)
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2, maskf
+
+    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,17 @@ def __init__(self, config):
         # resize factor
         self.RESIZE_FACTOR = config.resize_factor
 
+    def get_extra_content(self, frame, show):
+        maskf = self.create_mask(frame)
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2, maskf
+
+    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,13 +1,16 @@
-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
 
 
+cmask = ""
 class MiniContoursAlgorithm(Algorithm):
     # applies hsv binarization to the image
     # slices the image into horizontal strips and finds all the contours in each strip
@@ -106,6 +109,8 @@ def get_center_hough_lines(
 
         mask = cv2.inRange(cv2.cvtColor(frame, cv2.COLOR_BGR2HSV), self.low_green, self.high_green)
         mask = cv2.medianBlur(mask, 9)
+        global cmask
+        cmask = mask
         # mask = cv2.GaussianBlur(mask, (9,9), 10)
         # mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, self.morphology_kernel)
         centroids = self.get_centroids(mask, num_strips=num_strips)
@@ -199,6 +204,18 @@ def get_center_hough_lines(
 
         return frame, lines, point_lines
 
+    def get_extra_content(self, frame, show):
+        global cmask
+        # maskf = self.create_binary_mask(frame)
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2, cmask
+
+    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

@@ -6,6 +6,7 @@
 import math
 from algorithms.utils import Lines
 
+cmask = ""
 
 class MiniContoursDownwards():
 
@@ -144,6 +145,8 @@ def get_best_fit_line(self, frame, show, num_strips=60, dist_type=cv2.DIST_L2, p
         else:
             line = None
 
+        global cmask
+        cmask = c_mask
         if show:
             cv2.imshow('frame', frame)
             cv2.imshow('mask', mask)
@@ -152,6 +155,18 @@ 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):
+        global cmask
+        # maskf = self.create_binary_mask(frame)
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2, cmask
+
+    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,17 @@ 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)
+        maskf = frame
+        return item1, item2, maskf
+
+    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,17 @@ def __init__(self, config):
         self.HEIGHT = int(config.frame_length)
         self.WIDTH = int(config.frame_width)
 
+    def get_extra_content(self, frame, show):
+        maskf = self.create_binary_mask(frame)
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2, maskf
+
+    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)

algorithms/SeesawAlgorithmVersionTwo.py

@@ -0,0 +1,164 @@
+import math
+import cv2 as cv
+import numpy
+import numpy as np
+from algorithms.Algorithm import Algorithm
+from helper_scripts.change_res import change_res
+
+
+class SeesawAlgorithmVersionTwo(Algorithm):
+
+    def __init__(self, config):
+        """
+        Sets seesaw algorithm configurations
+        :param config: config params
+        """
+        # masking range for green
+        self.LOW_GREEN = np.array(config.lower_hsv_threshold)
+        self.HIGH_GREEN = np.array(config.upper_hsv_threshold)
+
+        # filtering parameters
+        self.averaging_kernel_size = config.averaging_kernel_size
+        self.gauss_kernel_size = list(map(int, config.gauss_kernel_size.split(',')))
+        self.dilate_kernel_size = config.dilate_kernel_size
+        self.sigma_x = config.sigma_x
+
+        # dimensions
+        self.HEIGHT = int(config.frame_length)
+        self.WIDTH = int(config.frame_width)
+
+        # visual parameters
+        self.BAR_HEIGHT = config.bar_height
+        self.RES_FACTOR = config.resolution_factor
+
+    def get_extra_content(self, frame, show):
+        maskf = self.create_binary_mask(frame)
+        item1, item2 = self.process_frame(frame, show)
+        return item1, item2, maskf
+
+    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):
+        """
+        Divides screen into horizontal strips and find average location of green for each strip.
+        Draw the best fit line based the average location,
+        then calculate the angle between the best fit line and a horizontal line.
+        :param frame: current frame (mat)
+        :param show: show/hide frames on screen for debugging
+        :type show: bool
+        :return: processed frame (mat), angle [-90, 90]
+        """
+
+        frame = change_res(frame, self.RES_FACTOR)
+        black_frame, average_points, overall_bias = self.plot_points(frame)
+        average_points = np.array(average_points)
+
+        if average_points.any():
+            """get best fit line for centre points"""
+            [vx, vy, x, y] = cv.fitLine(average_points, cv.DIST_L2, 0, 0.01, 0.01)
+            x1 = int(x - vx * self.WIDTH)
+            x2 = int(x + vx * self.WIDTH)
+            y1 = int(y - vy * self.HEIGHT)
+            y2 = int(y + vy * self.HEIGHT)
+            black_frame = cv.line(black_frame, (x1, y1), (x2, y2), (0, 255, 255), 9)
+
+            # calculate angle
+            if y1 - y2 != 0:
+                angle = round(math.degrees(math.atan(int(x2 - x1) / int(y1 - y2))), 1)
+                bias = round(numpy.average(overall_bias)/(self.WIDTH/2)*90, 2)
+
+                if abs(angle) > abs(bias):
+                    output = angle
+                else:
+                    output = bias
+            else:
+                output = None
+        else:
+            output = None
+
+        black_frame = self.print_text(frame, str(output))
+
+        return black_frame, output
+
+    def plot_points(self, frame):
+        """
+        Divides screen into horizontal strips, and find average location of green for each strip.
+        :param frame: current frame (mat)
+        :return: processed frame (mat), list of centre points
+        """
+        frame = cv.line(frame, (int(self.WIDTH/2), 0), (int(self.WIDTH/2), int(self.HEIGHT)), (255, 0, 255), 9)
+        bar_height = int(self.BAR_HEIGHT)
+        mask = self.create_binary_mask(frame)
+
+        square_low = 0
+        square_high = bar_height
+
+        black_frame = frame
+
+        centre_points = []
+        overall_bias = []
+
+        while square_low < self.HEIGHT:
+            points = []
+
+            seg = mask[int(square_low) + 1:int(square_high), 0:self.WIDTH]
+
+            condition = (seg == 255)
+            points = np.where(condition)[1]
+
+            if points.any():
+                centre = int(numpy.median(points))
+                bias = int(centre - self.WIDTH/2)
+                black_frame = cv.circle(black_frame, [int(centre), int((square_high + square_low) / 2)],
+                                        radius=0, color=(0, 0, 255), thickness=15)
+                centre_points.append([centre, int((square_high + square_low) / 2)])
+                overall_bias.append(bias)
+
+            square_high += bar_height
+            square_low += bar_height
+
+        return frame, centre_points, overall_bias
+
+    def print_text(self, frame, text):
+
+        # Define the font and text size
+        font = cv.FONT_HERSHEY_SIMPLEX
+        font_scale = 1
+
+        # Define the color and thickness of the text
+        color = (255, 255, 255)  # in BGR format
+        thickness = 2
+
+        # Get the size of the text box
+        text_size, _ = cv.getTextSize(text, font, font_scale, thickness)
+
+        # Calculate the position of the text box
+        x = int((frame.shape[1] - text_size[0]) / 4)
+        y = int((frame.shape[0] + text_size[1]) / 4)
+
+        # Draw the text on the image
+        cv.putText(frame, text, (x, y), font, font_scale, color, thickness)
+
+        return frame
+
+    def create_binary_mask(self, frame):
+        """
+        :param frame: current frame
+        :return: binary mask of frame made using self.low_green and self.high_green as the HSV range
+        """
+
+        # Run averaging filter to blur the frame
+        kernel = np.ones((5, 5), np.float32) / 25
+        frame = cv.filter2D(frame, -1, kernel)
+
+        # Convert to hsv format to allow for easier colour filtering
+        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
+
+        # Filter image and allow only shades of green to pass
+        mask = cv.inRange(hsv, self.LOW_GREEN, self.HIGH_GREEN)
+
+        return mask