[Testing] Final testing

- Did final testing on every file.
- Edited documentation of each file.
- Added documentation in some file.

Task #3.4

Author: mahbubur.rahman

CsvHelper.py

@@ -3,19 +3,20 @@
 class CsvHelper:
     def __init__(self,lidar_file,flight_file):
         """
-        @param lidar_file: given or generated LIDARPoint.csv file's path
-        @param flight_file: given or generated FlightPath.csv file's path
+        This function is the constructor of CsvHelper Class.
 
-        Constructor of CsvHelper Class
+        @param lidar_file: given or generated LIDARPoint.csv file's path.
+        @param flight_file: given or generated FlightPath.csv file's path.
         """
         self.lidar_file=lidar_file
         self.flight_file=flight_file
 
     def make_list(self,x,y):
         """
+        This function creates a list of two element.
+
         @param x: An integer or float element
         @param y: An integer or float element
-
         @Return: return a list whose elements are x,y
         """
         result_list = []
@@ -25,9 +26,11 @@ def make_list(self,x,y):
 
     def read_lidar_element(self):
         """
-        Read given or pre-generated lidar points
+        This function reads given or pre-generated lidar points and create
+        a two dimensional list of lidar point. Each row contains the point
+        of a distinct sweep.
+
         @Return lidar_points: Return a two dimensional list of lidar point.
-                              Each row contains the point of a distinct sweep
         """
         with open(self.lidar_file) as lidar_reader:
             read_lidar_point = csv.reader(lidar_reader, delimiter=',')
@@ -49,9 +52,11 @@ def read_lidar_element(self):
 
     def read_flight_path_element(self):
         """
-        Read given or pre-generated flight path co-oridnates
+        This function reads given or pre-generated flight path co-oridnates
+        and make a two dimensional list of flight points. Each row contains
+        the points of a distinct sweep
+
         @Return flight_points: Return a two dimensional list of flight points.
-                              Each row contains the points of a distinct sweep
         """
         with open(self.flight_file) as flight_reader:
             read_flight_point = csv.reader(flight_reader, delimiter=',')
@@ -67,11 +72,29 @@ def read_flight_path_element(self):
 
 
     def write_csv(self,data,file_name_csv):
-        with open(file_name_csv, "wb") as f:
-            writer = csv.writer(f)
+        """
+        This function writes data on csv format in a csv file .
+
+        @param data: Given data which is going to be written in csv file.
+        @param file_name_csv: Csv file name in which data will be written.
+        """
+        with open(file_name_csv, "w") as file:
+            writer = csv.writer(file)
             writer.writerows(data)
 
     def write_flight_path(self,flight_path,output_flight_csv):
+        """
+        This function pre-process the flight path points and call
+        the write_csv function to write data on a given csv file.
+        In the given flight_path list, only the co-ordinates
+        are given. Sweep number are not included. So this function
+        add one additional line/list [sweep number,1] before each flight
+        co-ordinate and call write_csv to write these data on the file.
+
+        @param flight_path: Flight path points/co-ordinates
+        @param output_flight_csv: File name in which flight path points
+                                 will be written.
+        """
         output_flight_path=[]
         for point  in range(len(flight_path)):
             output_flight_path.append(self.make_list(point,1))

DisplayUtil.py

@@ -3,20 +3,24 @@
 class DisplayUtil:
     def __init__(self,sweep_points,flight_points):
         """
-        @param sweep_points: angle and distance of each sweep
-        @param flight_points: Collection of the flight points
-
         Constructor of DisplayUtil class
+
+        @param sweep_points: A list with angle and distance of all sweep.
+        @param flight_points: Collection of the flight points.
         """
         self.sweep_points=sweep_points
         self.flight_points=flight_points
 
     def plot_sweep(self,x_axis_list,y_axis_list,sweep_number):
 
         """
-        Plot a sweep points as well as that sweep's lidar point
-        plot the lidar position with green color
-        plot the sweep's points with red color
+        This function plot a sweep boundary points as well as that sweep's lidar
+        point. Plot the lidar position with green color and Plot the sweep's points
+        with red color.
+
+        @param x_axis_list: List of x axis points of the sweep boundary points.
+        @param y_axis_list: List of y axis points of the sweep boundary points.
+        @param sweep_number: Sweep number which boundary is to be plotted.
         """
         plot.figure(sweep_number)
         plot.scatter(x_axis_list, y_axis_list, c='r')
@@ -27,15 +31,15 @@ def display_sweep(self):
 
 
         """
-        Calculate all  co-ordinates of each sweep using angle and distance based on the lidar's position
-        1. Convert the angle from degree to redian using the following formula
+        Calculate all  co-ordinates(xi,yi) of each sweep boundary using angle and distance
+        based on the lidar's position(x,y).
+        1. Convert the angle from degree to redian using the following formula.
                redian= (pi* degree)/180
-        2. then find the co-ordinate at distance d and angle e  using formula
-               x1=x+d * cos(e)
-               y1=y+d * sin(e)
-           where (x,y) is current lidar position.
-        3. Final divide
-        Then plot these co-ordinates
+        2. Then find the co-ordinate at distance d and angle e  using formula.
+               xi=x+d * cos(e)
+               yi=y+d * sin(e)
+           where (x,y) is current lidar's position.
+        3. Finally call the plot sweep function to plot these co-ordinates.
         """
         for sweep in range(len(self.sweep_points)):
             lidar_x_coordinate=self.flight_points[sweep][0]

MathUtil.py

@@ -3,28 +3,52 @@
 from math import pi
 
 def length(v):
+    """
+    This function calculates the length of a given vector.
+
+    @param v: Vector representation of a 2-d coordinates
+    @Return: Returns the length of the vector.
+    """
     return sqrt(v[0]**2+v[1]**2)
+
 def dot_product(v,w):
     """
-    Calculate the dot product of two vector v and w
+    This function calculate the dot product of two vector v and w.
+
+    @param v: Vector representation of a 2-d coordinates.
+    @param w: Vector representation of a 2-d coordinates.
+    @Return: Return the dot product of v and w.
     """
     return v[0]*w[0]+v[1]*w[1]
+
 def determinant(v,w):
     """
-    Calculate the determinant of v an w
+    This function calculate the determinant of two vector v and w.
+
+    @param v: Vector representation of a 2-d coordinates.
+    @param w: Vector representation of a 2-d coordinates.
+    @Return: Return the determinant of v and w.
     """
     return v[0]*w[1]-v[1]*w[0]
 def inner_angle(v,w):
     """
-    Calculate the  angle between A and B
+    This function calculate the inner angle  between v and w.
+
+    @param v: Vector representation of a 2-d coordinates.
+    @param w: Vector representation of a 2-d coordinates.
+    @Return: Return the inner angle of v and w.
     """
     cosx=dot_product(v,w)/(length(v)*length(w))
     rad=acos(cosx) # in radians
     return rad*180/pi # returns degrees
 
 def angle_anti_clockwise(A, B):
     """
-    Calculate the anti clock-wise angle between A and B
+    Calculate the anti clock-wise angle between A and B.
+
+    @param A: Given 2-d coordinate.
+    @param B: Given 2-d coordinate.
+    @Return: Return the anti-clockwise angle between A and B.
     """
     inner=inner_angle(A,B)
     det = determinant(A,B)
@@ -35,7 +59,10 @@ def angle_anti_clockwise(A, B):
 
 def distance_a_to_b(point_A, point_B):
     """
-     Calculate the distance between A and B
+     Calculate the distance between A and B.
+    @param A: Given 2-d coordinate.
+    @param B: Given 2-d coordinate.
+    @Return: Return the distance between A and B.
     """
     difference_of_x = (point_A[0] - point_B[0])
     difference_of_y = (point_A[1] - point_B[1])

Optimization.py

@@ -3,19 +3,20 @@
 class Optimization:
     def __init__(self, sweep_points, flight_points):
         """
-        @param sweep_points: angle and distance of each sweep
-        @param flight_points: Collection of the flight points
+        Constructor of DisplayUtil class.
 
-        Constructor of DisplayUtil class
+        @param sweep_points: A list of angle and distance of all sweep.
+        @param flight_points: A list of the flight points.
         """
         self.sweep_points = sweep_points
         self.flight_points = flight_points
 
     def make_list(self,x,y):
         """
+        This function creates a list of two element.
+
         @param x: An integer or float element
         @param y: An integer or float element
-
         @Return: return a list whose elements are x,y
         """
         result_list = []
@@ -28,12 +29,18 @@ def make_list(self,x,y):
     def is_possible_a_to_b(self,boundary_point, point_a, point_b):
 
         """
-        @param boundary_point: Boundary point of a sweep calculated using given data
-        @param point_a: Current position of drone
-        @param point_b: Next position of drone
+        This function checks whether it is possible to go from point_a to point_b by
+        straight line. It first calculate the angle between point_a and point_b, then
+        checks the boundary_point  for that angle and also check the boundary for that
+        angle. If the boundary distance is greater then the distance between point_a
+        and point_b then it is considered that we can go straightly from point_a to
+        point_b.
 
-        @Return: return 1 if there is no obstacle from point point_a to point_b when it is considered as straight line
-                 otherwise return 0
+        @param boundary_point: Boundary point of a sweep calculated using given data.
+        @param point_a: Current position of drone/lidar.
+        @param point_b: Next position of drone/lidar.
+        @Return: return 1 if there is no obstacle from point point_a to point_b when it is
+                 considered as straight line otherwise return 0
         """
         angle= MathUtil.angle_anti_clockwise(point_a, point_b)
         # print(angle)
@@ -51,17 +58,27 @@ def is_possible_a_to_b(self,boundary_point, point_a, point_b):
     def optimization(self):
 
         """
-        @Return: returns optimized  flightPath and for each sweep of that
-        flight path coordinates return LIDARPoint
+         Traverse through the path. When  I am  at position of index i,
+         I tried to find whether is there any way to  go at position of
+         index j (all j such that j>i) by straight line. For each i, we
+         check continuously up to the last ending position. When I find any
+         position of index j which is not reachable from position  of index
+         i, I don't check for the rest position after j. If position of index
+         j is not reachable by straight line, then I consider that position
+         of index (j+1) is not reachable by straight line. After position of
+         index i, I directly go to position of index position of index j as
+         position of index j is reachable from position of index  i. So I just
+         ommit all the position between index i and j. After that I update  i
+         using j. I insert the position of each i in a list and finally return
+         that list.
+
+         @Return: returns optimized  flightPath.
 
-        finds a better flight path that will result in the shortest possible
-        travel time but still goes through the existing rooms.
         """
         optimized_sweep_points = []
         optimized_flight_points = []
         current_sweep = 0
         while current_sweep < len(self.flight_points):
-            print(current_sweep)
             optimized_flight_points.append(self.flight_points[current_sweep])
             optimized_sweep_points.append(self.sweep_points[current_sweep])
             next_sweep =current_sweep + 1

OutputOptimizeFlightPath.csv

@@ -0,0 +1,14 @@
+0,1
+12.87234,3.62299
+1,1
+15.9823,6.766453
+2,1
+17.1553,12.15622
+3,1
+13.29576,14.33377
+4,1
+8.850136,7.513073
+5,1
+7.71862,6.38156
+6,1
+5.883137,6.75139

README.md

@@ -35,9 +35,9 @@ My main target here is to provide an appropriate visualization of drone's path a
          - Read LIDAR data and flight path data from csv file.
          - Convert LIDAR data to two dimensional list such that each row contains the data of one sweep.
          - I traverse through the path.
-         - When  I am  at position of index i, I tried to find wheather is there any way to  go at position 
+         - When  I am  at position of index i, I tried to find whether is there any way to  go at position 
            of index j (all j such that j>i) by straight line. 
-         - For each i, we check continously upto the last ending position.
+         - For each i, we check continuously upto the last ending position.
          - When I find any position of index j which is not reachable from position  of index i, I don't
            check for the rest position after j. If position of index j is not reachable by straight line,
            then I consider that position of index (j+1) is not reachable by straight line.
@@ -61,10 +61,24 @@ My main target here is to provide an appropriate visualization of drone's path a
          -  python droneflight.py --dis "LIDARDPoints.csv" "FlightPath.csv"
 
       Here please put your own LIDARDPoints.csv and FlightPath.csv file.
+      To show each sweep please click cross button after showing each sweep.
+      If we click on the cross button of the figure, current sweep figure will disappear and then next one
+      will display.
+      
    2. To optimize the path please run the following command:
 
          - python droneflight.py --op "LIDARDPoints.csv" "FlightPath.csv" "OutputFlightPath.csv"
 
       Output will be stored in file "OutputFlightPath.csv". Here please put your own LIDARDPoints.csv,
       FlightPath.csv and OutputFlightPath.csv file name.
-    
+   
+   2. To test the optimize the path, please run the following command. It will display the optimized path 
+      after optimization.
+   
+         - python droneflight.py --test "LIDARDPoints.csv" "FlightPath.csv"
+       
+      Here please put your own LIDARDPoints.csv and FlightPath.csv file.
+      To show each sweep please click cross button after showing each sweep.
+      If we click on the cross button of the figure, current sweep figure will disappear and then next one 
+      will  display.
+      

Test.py

@@ -1,22 +1,27 @@
 from CsvHelper import CsvHelper
 from DisplayUtil import DisplayUtil
 from Optimization import Optimization
-csv_helper=CsvHelper("points.csv","path.csv")
-flight_path=csv_helper.read_flight_path_element()
-if len(flight_path)!=34:
-    print("Number of sweep is not 34!Please check ! May be wrong flight path file included")
-else:
-    for point in range(len(flight_path)):
-        print(flight_path[point][0],flight_path[point][1])
 
-lidar_points=csv_helper.read_lidar_element()
-if len(lidar_points)!=34:
-    print("Number of sweep is not 34!Please check ! May be wrong lidar points file included")
-else:
-    for length in range(len(lidar_points)):
-        print(length,len(lidar_points[length]))
-optimization=Optimization(lidar_points,flight_path)
-optimized_lidar_points,optimized_flight_path=optimization.optimization()
-display_helper=DisplayUtil(optimized_lidar_points,optimized_flight_path)
-display_helper.display_sweep()
+def test_optimization(lidar_points_file_name,flight_path_file_name):
+    """
+    This function is used to display each sweep one by one of the optimized
+    flight path. This function first read_lidar_element() and read_flight_element()
+    functions from CsvHelper class to read the lidar's point and flight path points
+    from given csv file. Then it calls optimization function from Optimization class
+    to optimize the flight path. After that it calls display_sweep function from
+    DisplayUtil class to display each sweep one by one of the optimized flight path.
+
+    @param lidar_points_file_name: Given file name of lidar's point.
+    @param flight_path_file_name:  Given file name of flight path points.
+    """
+    csv_helper=CsvHelper(lidar_points_file_name,flight_path_file_name)
+    flight_path=csv_helper.read_flight_path_element()
+    lidar_points=csv_helper.read_lidar_element()
+    if len(flight_path)!=len(lidar_points):
+        print("Wrong given data! Number of sweep in booth file is not equal")
+    else:
+        optimization=Optimization(lidar_points,flight_path)
+        optimized_lidar_points,optimized_flight_path=optimization.optimization()
+        display_helper=DisplayUtil(optimized_lidar_points,optimized_flight_path)
+        display_helper.display_sweep()