From a5644d4b8bf8cea993eb1065619dc8a1d6842084 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Wed, 30 Aug 2023 23:17:41 -0400
Subject: [PATCH 01/22] Trail_detection_node package

Trail_detection_node package. The models are too large so they are uploaded to the google drive.
---
 trail_detection_node/package.xml              |  21 +
 .../resource/trail_detection_node             |   0
 trail_detection_node/setup.cfg                |   4 +
 trail_detection_node/setup.py                 |  28 ++
 trail_detection_node/test.py                  |   3 +
 trail_detection_node/test/test_copyright.py   |  25 +
 trail_detection_node/test/test_flake8.py      |  25 +
 trail_detection_node/test/test_pep257.py      |  23 +
 .../trail_detection_node/GANav_visualizer.py  | 412 +++++++++++++++++
 .../trail_detection_node/__init__.py          |   0
 .../GANav_visualizer.cpython-310.pyc          | Bin 0 -> 8527 bytes
 .../GANav_visualizer.cpython-37.pyc           | Bin 0 -> 8540 bytes
 .../__pycache__/__init__.cpython-310.pyc      | Bin 0 -> 173 bytes
 .../__pycache__/__init__.cpython-37.pyc       | Bin 0 -> 167 bytes
 .../__pycache__/model_loader.cpython-310.pyc  | Bin 0 -> 3390 bytes
 .../__pycache__/model_loader.cpython-39.pyc   | Bin 0 -> 2460 bytes
 .../v1_trailDetectionNode.cpython-310.pyc     | Bin 0 -> 7419 bytes
 .../v2_trailDetectionNode.cpython-310.pyc     | Bin 0 -> 6580 bytes
 .../__pycache__/vgg.cpython-310.pyc           | Bin 0 -> 5456 bytes
 .../__pycache__/vgg.cpython-39.pyc            | Bin 0 -> 5926 bytes
 ...izer_v1_trailDetectionNode.cpython-310.pyc | Bin 0 -> 9034 bytes
 ...izer_v2_trailDetectionNode.cpython-310.pyc | Bin 0 -> 8399 bytes
 .../trail_detection_node/model_loader.py      |  99 ++++
 .../trail_detection_node/setup.py             | 125 +++++
 .../v1_trailDetectionNode.py                  | 278 +++++++++++
 .../v2_trailDetectionNode.py                  | 233 ++++++++++
 .../trail_detection_node/vgg.py               | 191 ++++++++
 .../visualizer_v1_trailDetectionNode.py       | 431 ++++++++++++++++++
 .../visualizer_v2_trailDetectionNode.py       | 392 ++++++++++++++++
 29 files changed, 2290 insertions(+)
 create mode 100644 trail_detection_node/package.xml
 create mode 100644 trail_detection_node/resource/trail_detection_node
 create mode 100644 trail_detection_node/setup.cfg
 create mode 100644 trail_detection_node/setup.py
 create mode 100644 trail_detection_node/test.py
 create mode 100644 trail_detection_node/test/test_copyright.py
 create mode 100644 trail_detection_node/test/test_flake8.py
 create mode 100644 trail_detection_node/test/test_pep257.py
 create mode 100644 trail_detection_node/trail_detection_node/GANav_visualizer.py
 create mode 100644 trail_detection_node/trail_detection_node/__init__.py
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/v1_trailDetectionNode.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/visualizer_v1_trailDetectionNode.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/model_loader.py
 create mode 100644 trail_detection_node/trail_detection_node/setup.py
 create mode 100644 trail_detection_node/trail_detection_node/v1_trailDetectionNode.py
 create mode 100644 trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
 create mode 100644 trail_detection_node/trail_detection_node/vgg.py
 create mode 100644 trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py
 create mode 100644 trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py

diff --git a/trail_detection_node/package.xml b/trail_detection_node/package.xml
new file mode 100644
index 00000000..45159f4b
--- /dev/null
+++ b/trail_detection_node/package.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>trail_detection_node</name>
+  <version>0.0.0</version>
+  <description>TODO: Package description</description>
+  <maintainer email="tom2352759619@hotmail.com">zhaodong</maintainer>
+  <license>TODO: License declaration</license>
+
+  <depend>sensor_msgs</depend>
+  <depend>cv_bridge</depend>
+	
+  <test_depend>ament_copyright</test_depend>
+  <test_depend>ament_flake8</test_depend>
+  <test_depend>ament_pep257</test_depend>
+  <test_depend>python3-pytest</test_depend>
+
+  <export>
+    <build_type>ament_python</build_type>
+  </export>
+</package>
diff --git a/trail_detection_node/resource/trail_detection_node b/trail_detection_node/resource/trail_detection_node
new file mode 100644
index 00000000..e69de29b
diff --git a/trail_detection_node/setup.cfg b/trail_detection_node/setup.cfg
new file mode 100644
index 00000000..3cedd943
--- /dev/null
+++ b/trail_detection_node/setup.cfg
@@ -0,0 +1,4 @@
+[develop]
+script_dir=$base/lib/trail_detection_node
+[install]
+install_scripts=$base/lib/trail_detection_node
diff --git a/trail_detection_node/setup.py b/trail_detection_node/setup.py
new file mode 100644
index 00000000..511d6ad0
--- /dev/null
+++ b/trail_detection_node/setup.py
@@ -0,0 +1,28 @@
+from setuptools import setup
+
+package_name = 'trail_detection_node'
+
+setup(
+    name=package_name,
+    version='0.0.0',
+    packages=[package_name],
+    data_files=[
+        ('share/ament_index/resource_index/packages',
+            ['resource/' + package_name]),
+        ('share/' + package_name, ['package.xml']),
+    ],
+    install_requires=['setuptools'],
+    zip_safe=True,
+    maintainer='zhaodong',
+    maintainer_email='tom2352759619@hotmail.com',
+    description='TODO: Package description',
+    license='TODO: License declaration',
+    tests_require=['pytest'],
+    entry_points={
+        'console_scripts': [
+            'trail_detection = trail_detection_node.v2_trailDetectionNode:main',
+            'visualizer = trail_detection_node.visualizer_v2_trailDetectionNode:main',
+            'original_visualizer = trail_detection_node.visualizer_v1_trailDetectionNode:main',
+        ],
+    },
+)
diff --git a/trail_detection_node/test.py b/trail_detection_node/test.py
new file mode 100644
index 00000000..5d715cab
--- /dev/null
+++ b/trail_detection_node/test.py
@@ -0,0 +1,3 @@
+from trail_detection_node.visualizer_v2_trailDetectionNode import *
+
+main()
diff --git a/trail_detection_node/test/test_copyright.py b/trail_detection_node/test/test_copyright.py
new file mode 100644
index 00000000..97a39196
--- /dev/null
+++ b/trail_detection_node/test/test_copyright.py
@@ -0,0 +1,25 @@
+# Copyright 2015 Open Source Robotics Foundation, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ament_copyright.main import main
+import pytest
+
+
+# Remove the `skip` decorator once the source file(s) have a copyright header
+@pytest.mark.skip(reason='No copyright header has been placed in the generated source file.')
+@pytest.mark.copyright
+@pytest.mark.linter
+def test_copyright():
+    rc = main(argv=['.', 'test'])
+    assert rc == 0, 'Found errors'
diff --git a/trail_detection_node/test/test_flake8.py b/trail_detection_node/test/test_flake8.py
new file mode 100644
index 00000000..27ee1078
--- /dev/null
+++ b/trail_detection_node/test/test_flake8.py
@@ -0,0 +1,25 @@
+# Copyright 2017 Open Source Robotics Foundation, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ament_flake8.main import main_with_errors
+import pytest
+
+
+@pytest.mark.flake8
+@pytest.mark.linter
+def test_flake8():
+    rc, errors = main_with_errors(argv=[])
+    assert rc == 0, \
+        'Found %d code style errors / warnings:\n' % len(errors) + \
+        '\n'.join(errors)
diff --git a/trail_detection_node/test/test_pep257.py b/trail_detection_node/test/test_pep257.py
new file mode 100644
index 00000000..b234a384
--- /dev/null
+++ b/trail_detection_node/test/test_pep257.py
@@ -0,0 +1,23 @@
+# Copyright 2015 Open Source Robotics Foundation, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ament_pep257.main import main
+import pytest
+
+
+@pytest.mark.linter
+@pytest.mark.pep257
+def test_pep257():
+    rc = main(argv=['.', 'test'])
+    assert rc == 0, 'Found code style errors / warnings'
diff --git a/trail_detection_node/trail_detection_node/GANav_visualizer.py b/trail_detection_node/trail_detection_node/GANav_visualizer.py
new file mode 100644
index 00000000..9919553f
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/GANav_visualizer.py
@@ -0,0 +1,412 @@
+import torch
+from .mmseg.apis import inference_segmentor, init_segmentor
+from PIL import Image as ImagePIL
+from torchvision import transforms
+import cv2
+import os
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import PoseStamped
+from sensor_msgs.msg import Image, PointCloud2
+import sensor_msgs_py.point_cloud2 as pc2
+import numpy as np
+import math
+from cv_bridge import CvBridge
+
+'''
+    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
+'''
+camera_transformation_k = np.array([
+    [628.5359544,0,676.9575694],
+    [0,627.7249542,532.7206716],
+    [0,0,1]])
+
+rotation_matrix = np.array([
+    [-0.007495781893,-0.0006277316155,0.9999717092],
+    [-0.9999516401,-0.006361853422,-0.007499625104],
+    [0.006366381192,-0.9999795662,-0.0005800141927]])
+
+rotation_matrix = rotation_matrix.T
+
+translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
+image_width=1280
+image_height=1024
+
+def convert_to_lidar_frame(uv_coordinate):
+    """
+    convert 2d camera coordinate + depth into 3d lidar frame
+    """
+    point_cloud = np.empty( (3,) , dtype=float)
+    point_cloud[2] = uv_coordinate[2]
+    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
+    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
+
+    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
+    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
+    point_cloud = inverse_camera_transformation_k @ point_cloud
+    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
+    return point_cloud
+
+def convert_to_camera_frame(point_cloud):
+    """
+    convert 3d lidar data into 2d coordinate of the camera frame + depth
+    """
+    length = point_cloud.shape[0]
+    translation = np.tile(translation_vector, (length, 1)).T
+    
+    point_cloud = point_cloud.T
+    point_cloud = rotation_matrix@point_cloud + translation
+    point_cloud = camera_transformation_k @ point_cloud
+
+    uv_coordinate = np.empty_like(point_cloud)
+
+    """
+    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
+    """
+    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
+    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
+    uv_coordinate[2] = point_cloud[2]
+
+    uv_depth = uv_coordinate[2, :]
+    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
+    return filtered_uv_coordinate
+
+def estimate_depth(x, y, np_2d_array):
+    """
+    estimate the depth by finding points closest to x,y from thhe 2d array
+    """
+    # Calculate the distance between each point and the target coordinates (x, y)
+    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
+
+    # Find the indices of the k nearest points
+    k = 5     # Number of nearest neighbors we want
+    closest_indices = np.argpartition(distances_sq, k)[:k]
+    pixel_distance_threshold = 2000
+
+    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
+    if len(valid_indices) == 0:
+        # lidar points disappears usually around 0.4m
+        distance_where_lidar_stops_working = -1
+        return distance_where_lidar_stops_working
+
+    filtered_indices = np.array(valid_indices)
+    # Get the depth value of the closest point
+    closest_depths = np_2d_array[2,filtered_indices]
+
+    return np.mean(closest_depths)
+
+def load_model(device):
+
+    config = "./trail_detection_node/trained_models/rugd_group6/ganav_rugd_6.py"
+    checkpoint = "./trail_detection_node/trained_models/rugd_group6/ganav_rugd_6.pth"
+    model = init_segmentor(config, checkpoint, device="cuda:0")
+    print('Finished loading model!')
+
+    return model
+
+def find_route(model, device, cv_image):    
+    result = inference_segmentor(model, cv_image)
+    result_np = np.vstack(result).astype(np.uint8)
+    pred = np.where(result_np == 0, 255, 0)
+
+    # # prediction visualize
+    # cv2.imshow('prediction',pred)
+    # cv2.waitKey(25)
+
+    route = np.zeros_like(pred)
+    # calculate the center line by taking the average
+    row_num = 0
+    for row in pred:
+        white_pixels = list(np.nonzero(row)[0])
+        if white_pixels:
+            average = (white_pixels[0] + white_pixels[-1]) / 2
+            route[row_num][round(average)] = 255
+        row_num = row_num + 1
+    return route, pred
+
+def equalize_hist_rgb(img):
+    # Split the image into its color channels
+    r, g, b = cv2.split(img)
+
+    # Equalize the histograms for each channel
+    r_eq = cv2.equalizeHist(r)
+    g_eq = cv2.equalizeHist(g)
+    b_eq = cv2.equalizeHist(b)
+
+    # Merge the channels
+    img_eq = cv2.merge((r_eq, g_eq, b_eq))
+    # img_eq = cv2.fastNlMeansDenoisingColored(img_eq,None,10,20,7,42)
+    # img_eq = cv2.GaussianBlur(img_eq, (25,25), 0)
+    return img_eq
+
+'''
+    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
+    it detects the trail in the image and sends the corresponding lidar position as the trail location.
+    The msgs are synchornized before processing, using buffer and sync function.
+    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
+    and choose to go to the closest point. 
+    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
+'''
+class trailDetector(Node):
+    def __init__(self, model, device):
+        super().__init__('trail_detector')
+        # define trail subscription
+        self.trail_publisher = self.create_publisher(
+            PoseStamped,
+            'trail_location',
+            10)
+        
+        # define camera subscription
+        self.camera_subscription = self.create_subscription(
+            Image,
+            'camera',
+            self.camera_callback,
+            10)
+        self.camera_subscription
+        
+        # define lidar subscription
+        self.lidar_subscription = self.create_subscription(
+            PointCloud2,
+            'velodyne_points',  
+            self.lidar_callback,
+            10)
+        self.lidar_subscription
+
+        self.bridge = CvBridge()
+
+        # load model and device
+        self.model = model
+        self.device = device
+
+        # buffers to hold msgs for sync
+        self.buffer_size = 50   # 30 is a random choice, to be discussed 
+        self.lidar_buffer = []
+        self.camera_buffer = []
+        self.only_camera_mode = True
+    
+    def camera_callback(self, msg):
+        if len(self.camera_buffer) >= self.buffer_size:
+            self.camera_buffer.pop(0)
+        self.camera_buffer.append(msg)
+        self.sync()
+
+    def lidar_callback(self, msg):           
+        if len(self.lidar_buffer) >= self.buffer_size:
+            self.lidar_buffer.pop(0)
+        self.lidar_buffer.append(msg)
+        self.sync()
+
+    def sync(self):
+        # if one of the sensor has no msg, then return
+        if self.only_camera_mode and self.camera_buffer:
+            camera_msg = self.camera_buffer[0]
+            self.camera_buffer.pop(0)
+            self.only_camera_callback(camera_msg)
+        elif not self.lidar_buffer or not self.camera_buffer:
+            return
+        
+        while self.lidar_buffer and self.camera_buffer:
+            lidar_msg = self.lidar_buffer[0]
+            camera_msg = self.camera_buffer[0]
+
+            time_tolerance = 20000000    # nanosec, random choice to be discussed
+            time_difference = abs(lidar_msg.header.stamp.nanosec - camera_msg.header.stamp.nanosec)
+            # print(time_difference)
+            
+            # compare the time difference, if it's within tolerance, then pass to the trail_callback, otherwise discard the older msg
+            if time_difference <= time_tolerance:
+                self.lidar_buffer.pop(0)
+                self.camera_buffer.pop(0)
+                self.get_logger().info("msgs received!")
+                self.trail_callback(lidar_msg, camera_msg)
+            elif lidar_msg.header.stamp.nanosec > camera_msg.header.stamp.nanosec:
+                self.camera_buffer.pop(0)
+            else:
+                self.lidar_buffer.pop(0)
+
+    def trail_callback(self, lidar_msg, camera_msg):
+        # process lidar msg
+        point_gen = pc2.read_points(
+            lidar_msg, field_names=(
+                "x", "y", "z"), skip_nans=True)
+        points = [[x, y, z] for x, y, z in point_gen]
+        points = np.array(points)
+        points2d = convert_to_camera_frame(points)
+
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        
+        # increase brightness
+        M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            print("No centerline found!")
+            return
+        
+        # #filter points that have no lidar points near it
+        # filtered_route_indices = []
+        # for index in route_indices:
+        #     point = []
+        #     point.append(index[0])
+        #     point.append(index[1])
+        #     point.append(estimate_depth(index[0], index[1], points2d))
+        #     if point[2] == -1:
+        #         continue
+        #     else:
+        #         filtered_route_indices.append(point)
+
+        # find the corresponding lidar points using the center line pixels
+        filtered_3dPoints = []
+        # for index in filtered_route_indices:
+        for index in route_indices:
+            point = []
+            # point.append(index[0])
+            # point.append(index[1])
+            # point.append(index[2])
+
+            point.append(index[0])
+            point.append(index[1])
+            point.append(estimate_depth(index[0], index[1], points2d))
+
+            point_3d = convert_to_lidar_frame(point)
+            filtered_3dPoints.append(point_3d)
+
+        filtered_3dPoints = np.array(filtered_3dPoints)
+        # find the nearest 3d point and set that as goal
+        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
+        smallest_index = np.argmin(distances_sq)
+        # print(math.sqrt(distances_sq[smallest_index]))
+        # smallest_index = np.argmin(filtered_3dPoints[:,2])
+
+        # visualize after-pocessed image
+        visualize_cv_image = cv_image
+        print(f"{visualize_cv_image.shape[0]}")
+        circle_x = route_indices[smallest_index][0]
+        circle_y = route_indices[smallest_index][1]
+        
+        # # visualize the lidar points in image
+        # uv_x, uv_y, uv_z = points2d
+        # for index_lidar in range(points2d.shape[1]):
+        #     # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
+        #     cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
+        
+        # visualize center line in image
+        for index_circle in range(len(route_indices)):
+            if index_circle == smallest_index:
+                continue
+            else:
+                red_circle_x = route_indices[index_circle][0]
+                red_circle_y = route_indices[index_circle][1]
+                cv2.circle(visualize_cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
+        
+        # visualize the chosen point in image
+        cv2.circle(visualize_cv_image, (circle_y, circle_x), radius=7, color=(0, 255, 0), thickness=-1)
+        cv2.circle(visualize_cv_image, (0, 0), radius=12, color=(0, 255, 0), thickness=-1)
+        
+        cv2.imshow('circled image',visualize_cv_image)
+        cv2.waitKey(25)
+
+        # publsih message
+        trail_location_msg = PoseStamped()
+        trail_location_msg.header.stamp = lidar_msg.header.stamp
+        trail_location_msg.header.frame_id = "velodyne"
+        #position
+        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
+        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
+        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
+        #orientation
+        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
+        trail_location_msg.pose.orientation.x = 0.0  
+        trail_location_msg.pose.orientation.y = 0.0 
+        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
+        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
+        self.get_logger().info("location published!")
+        self.trail_publisher.publish(trail_location_msg)
+        
+    def only_camera_callback(self, camera_msg):
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+
+        # cv_image = cv2.fastNlMeansDenoisingColored(cv_image,None,5,10,7,14)
+        
+        # # histogram equalization method 1
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2YCrCb)
+        # cv_image[:,:,0] = cv2.equalizeHist(cv_image[:,:,0])
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_YCrCb2BGR)
+
+        # # histogram equalization method 2
+        # cv_image = equalize_hist_rgb(cv_image)
+
+        # # histogram equalization method 3 CLAHE
+        # image_bw = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
+        # clahe = cv2.createCLAHE(clipLimit=5)
+        # cv_image = clahe.apply(image_bw) + 30
+
+        # # histogram equalization method 4 CLAHE
+        # cla = cv2.createCLAHE(clipLimit=4.0)
+        # H, S, V = cv2.split(cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV))
+        # eq_V = cla.apply(V)
+        # cv_image = cv2.cvtColor(cv2.merge([H, S, eq_V]), cv2.COLOR_HSV2BGR)
+
+        # # increase brightness
+        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        # cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route, pred = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        # increase the brightness of image where is predicted as road
+        sign = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR)
+        cv_image = cv2.add(cv_image, sign)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            print("No centerline found!")
+            return
+        
+        for index_circle in range(len(route_indices)):
+            red_circle_x = route_indices[index_circle][0]
+            red_circle_y = route_indices[index_circle][1]
+            cv2.circle(cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
+
+        cv2.imshow('circled image',cv_image)
+        cv2.waitKey(25)
+        
+
+
+
+def main(args=None):
+    print(torch.cuda.is_available())
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = load_model(device)
+    
+    rclpy.init(args=args)
+    trailDetectorNode = trailDetector(model, device)
+    rclpy.spin(trailDetectorNode)
+
+    trailDetectorNode.destroy_node()
+    rclpy.shutdown()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/trail_detection_node/trail_detection_node/__init__.py b/trail_detection_node/trail_detection_node/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23211bce82b256058757eb70014e788a5350c843
GIT binary patch
literal 8527
zcmbtZYm6k<RjzkeS3jobvGdrS_4cm4u{(BVH|t<RSoyUZ>{Xn};x%&8Br5gvt?8+r
z>aN~fH8VR+wPP~7*cPlI5MCijJ%#{FcnBpDQe<hxGqC_c6k?<c2qA|bgM<un_<=>T
zeCJko&-B>&MYrnKz2`pa);+K9oC*sCN5Su3-gtxk_jyHmgBk~a78;M@iY}{)!W5<k
zN>yPR(*w1oRkfC0)m5S!fzdLnmaLmWre#-cSyzK>H7n;iRY%@))g10tkZ%>L1vw@Y
z6k8M330b#;64o(Wlhw(={HfM-b!JdMQk|7+%vI-b&j$0Yh3bN;WEF3=f3%@6=M@!Y
zPL_F;`mS0%Hs~uzYEhOGgT6&?v3b0@I2ciSMaB5L*kttto2r)CG@H4uR8O)aY!>%Z
zY>v(2em7fSM{&Q09b=2QpJvC|UAVs|t308w6Rdn)VP&tdqgU@`_pp=f)OEFbpI2db
zuWS6by!&<(yo-88UX{~(bk@szI9sKniD|#R>T$1K_uR;9w7hm4a#8f#e!SnVsKUI|
zsx>@RoS4_z(Q3$B5n9G_$cUP|97f)ixYp`;tfFxfYZJ|H#}|TdgPp?=`@-hq+-F!s
zZ!G=m#w(Y8bLUY`n`nIC!>5nly7$JT6+LZ#z5m)*{`%K<9&J4G+O;?T?2FG2J7h1{
zXy1C{vf14Iw=X|;yYc#$mui3Y*^9Rui^b=@^yhcpd<308^qv3t+~@DSdAsrN<sY`*
zD0Xi*zVV;`^yGj1@pHG)`Rb4TVCR+T?jwya?ET^CZ_%im&M$oLGwKEE+`99%iGTcu
zKe*j^?fu_+z4c#Tx!w5S-+ucGm%j7O+rEOg@)bi->a^?O4{f3;7jQ+JC}O3lGBwti
zc2n!AiNf>+B~h7vUWs+Ij0I(0wilEcx*O*eP|bAAfM#N>(lq*JZ0)K&ZBWmkt|wZe
zmK3b3Cu(fZE3yvOR;=#hP8q*?*xvMbTt3Ij^;*m0HBds%{B|w&%J-L<*NNB4;7eG3
zkd*_U)p&W8W1yT|QTKGb!Y%Nd#oHZkj}BX&xIFtxR%q>xFuhhM-WKL+5Y}Rm_enC`
zHP3IX#li~kq@W>mzr88u(jB-Xk*URg*ml>&1P|l1-m1mizb2;SkRYXPdUXh4#Sn#!
zO?Q9yBG(~-a_b~f;shSx@yK((-!tZh0}egwmckeDR&Rg&%v#v;&UDvmAq(4$GdzsW
zxm(ehh}X|xH-6wUFUC%2$8AXYyAz*yY`M1SZu-$iE%3V@U+Qd&*#QsSICSL+yYhtZ
z!Be9t6h$Mi&Z{$OUdyYtnpX{#-v#oRSdk4REs|pO3Mz@xg#Ipo^|9L5AWACJR<&KN
zY4kMo89gO76Np2i%_*o`RL5QIXA*@3Cre_6`Kdr2Qxcu25HlNXZJ!F!)R`tllEhXg
zv89q3%(#K);rRyIvXvN2T{k7oOiYNN*<BtJ!I6NmT3kzIj-+y59K+Reyygw%R36e$
zMCC&J3eSr;f@R2`8Libi9-lx{7_lFCe2%K>Gkg|zeuNs1lusP}y2t6fD;8fMx)pfs
zM!Y6+2ZW8!Q;!WnlbRuBSN$M{J!I~f>`9SHi{mt5?f{Di0w}ltAUdO?C>&!-wIqKX
zP19!ddGNWU%@D8eMR%RlZ1~HfLcAtg^f?rX#=u>sr6-=iU@(1}sKx=Rno{SKmta16
zdaU%-7s0Dt%uDnel2gojNqs?iL0#2YhS}Hc#JH&Js68{*5_1Pe3f|#EEZegZ>k14`
zUr$U(N(Rr-lZ@o64XTmYyJTRT?q$goFN&e@Feb#h)SRqrmskBZY)qppRWvF?M<Wa@
z!^~WJ0KGhHVLT>40BW4qw)gqFEO{%9%pRSB|96=~x<E#VOzbqSh;+9BDgKnxqxXeG
zzo@RO9A@#e+EwjJs@#%OaBkYtSy&==?Up9;%#Y$4++5^FSH*nCzve;12Q)Wc<6g8D
z2J8Tjo$~>@>tU<&@UwX6TeOWurF&|40I9?*oe#o#Er=dQWjK8A4t^CgmC}5TH##*Q
z`(#Ok4jB}tJOW{~yjmMFtzHxAw#c<R?m6bBT`Fwk;0#?lS!`PrHeq7esCjC%`K>hw
z?7-4QaoCC6t&p#S8=^Fl=HVj6;i{5zQTn>~<IT8~>*Dy!eFPm5Db`uj&`Ee_Akv0r
zsE(G`9F0GWt}(MkY#N!ZQ)n=?2T>*;mZ&6H%($sTSXBlAR3Wb9xt6<+Exo&SB|F@P
zF1BEQgXj$3XfU_I!;Q{EXBxFO46md-1f$!1{QtW|yw<hq8?5%Bvj8g=^EPql-MJqD
z5{lM5xXQ351zc|BBrp!WsxUhoE~#ShN2q1NDy;eq;ndf>`npsFVaf^VIg{+B=j_mO
z>1)+Nj0h0ZxfbCN42@qzbIe5KKp36t&!K_yghANR=q&qC_+7P+TGN068=#odIKvb$
zbytVNt9?r<w*`J=67!<+sk?i2oB`b?^(Myv!;np~{E;Lp-9(mf%N+2^F{S6gq*zI2
zL5Z`8vjex0WS9vzlet<39WFp}QCjQ0JJ=jQO9h$i6s<X&Ok1iB)+W@jzAmg<L<mEe
z8#urZ3R4QPaNt72NSbb8kUoh_J8TnCnBaSxRdW0SttHRfu5Y>$eFzKcyAi}9o8DcZ
z6r%$xE@#D_$nbE>ZEv)Mj*7@{t@*L%N*fS~ObtK+5at~`BAe#osj(N}kr8<cN1ejo
zu?)?|9r~b_R0llcWFf{h!3JT(vB%LM15K{@lX?%BP8w_&Ey*th9Mn)VF-G#TXGwEx
zBxYi*g16vV<_cihGC+}D-#iC5*a>`KFYjuKJD#MYG6DAhuWgvTRzs*<s3=#2!CmjF
zFdDL4q0&M>?uTD^a=4nihUHw|Sa}}%j`Ao<nxi{-(~@rJ+yjB6cI-zSre8#|>nT;0
zDOK$SWfii;wCi?Nf(V2x1~Zw3yD43gQngr?IcR5Cj^%N;Ux2NzW+71pQII(7qJ&`~
zA5#c=9APB7N6({(l^q-~#GT9vjxh#~Vfrp0w`-scD9vzhW<bN;1@37gT9iFm2ISOq
z20b~{bE*>OchKt=V73&u2-vN-6AY-zEs^(eCuKRsfUewWreM4FvM3(JjTA<uZE_G~
z{P#%9VI(9h7ZaOa5VGwy<d9%(w091@&s1i>+YKNbVY@K(h{9Y^s&fwx*X?YqKqX-8
zISH4TNLL?G#q?lYw6PM^x!<8@rlHux0HeTB1uLX|(*wfTP{JXim?GBE$f>kFHZXmU
z6&cMPP{-WL#wub-Hv$kA`E*`N5{1F@2F+5~4z`ELoeX3}7e?d-tNW`V2Fbd>`n4!>
z-BeP^L-96>U%?eUgo2!rrqbW~u3^#Lp!)w>a90Ogwr1&;DlZ6ecXmv!mWBsiCl5dT
zQJsYA0<O0{fPyS;Q{90$G_`e;7pc_;h)x9#b%V4y6{%ecxFHm`wB<B#vN&;<Z&R^_
zLg<~a0~^@scx{GP-)`4$Y5XT-Pb+F1(oD|L@hYyji18&rN&0t>kH5wt9)I7r;m=_a
z{%I5d#&TQNh(O!o&r|V}RD6bt9V(>P8o4eWgZ8IHzk#B=IKGE*;TbcCWDLn?(t$=e
zA39Ej&(SfaWg6YcV<oqh9wp)&s<la94St+@qZ4$rvfZUNPpB?uQzRsvnFJj=A|kD6
zH8V{+QPcZ8xj7?23<J#g<20{7dKOqXs`s<IN}nu3x{Dlz-Mbq0F?V>yb%O`=)ZyGV
zY{b~A27iwFqtmqOgIC2!g~M0g_kOio1lyxB_v)U%>9LcQJn!P5Qi*vUH8FEgXNKy@
ziFHD+twh3F^J)xs!-Rirb>KH^ZD8=aa2j6h24MpZP8dk`ghR75TmwK=3Z63%AZ$cr
zQ$|v?2)OSdltrjT@EK-@+RP_ar?k;w`5?jhI<DwG6hMgsX*Ce;k_R!gdDTV$oCnq^
z!haS)UwpGm2>?GBn))SDh%tLl&X<H=O3$lMPD-;N2BtVkCrF9d$h;0fDI**s))37Y
z(z$}$6!U-wX43)$wO9s;87tPBnZ#<^%x2k}8gpg<XX0$%A)vEM{p1JoxC)82qXR4z
z;|Z)<BDnPO04zn9;z^bxAWM9004OC{K&$(DIn?t>zCV?~sV%_i!z`q&!hS2BPJ2;;
ziik`~TRfBGvEM@CV0M9KUj3+i8wYRWB$UroZfGn|@fj;3DjZS@L(1Gft+-F?6|u^Z
zq=;1}6028=CzBH19=rQBybbo3O(w7++P%p^9lPpH#k28TlHGyf!<(JxO()aI1mea&
zx%yR%njXxU8PsXUkvQ9&PfE#=WCn5P1S_#gHg(g)dwg}!GnGuD2bs=cPfDkp=RsP3
zfz2f)(mL?vD4VCVh>z_ky;*28a;V8{bJ0D{7Ucb|#2M}%?Gw$idvZXbvrQ?d29)B6
za(8@B|MY=zqctD_bL^;`_a67;sCEkD?@i`d@fdhI=%qF8J4CAhSG*S%<bHNc@?L2^
z(0^YtOLdZz%HlF|oj(9^=H$hM+I<GWYHro{0_L^>4<eC`*8L9Z?P$!1k^v<{dIi^k
zP<V(bDaK0lhW?IF*x(h+*ncGdd1@ZA>`S0ga+se%(LFn^k+KDsodSq=i+YitgR@2?
z9d0z%;J!=Di+swYz)FM^JMkxJae|Ya0QK85%VD{WgtNzyH1x`=gzrxt%K31zBDd1S
zaN6}@noj}7Egi5QLD@zm%z79AZ)M{(zrNn~qG%5}1Z0U1%%GetqBgq8VvqLmcA@U`
zdVugwh7o%*O=J&&Spy^FuRA@2aOEM|f`wj!6R)2WIe;@Zz;H6e;gkfDSsuQLnkWEm
z!;n%okf6H}VuSnyjrjz1>ovw?_^^+CIK|yU@A@776pee73h9+8;FifkU<cl4`N$=}
zD#Nss9|yFQZ$tPV$&4+L*{b>RN4#x`7x{}c_az!<%UqS~19^1dBZQ4orY8;w2r?8k
z<jYK?@7j3Lko(}4gt9`9@NB&vMnc`<KTRwD3>6((J~KF^%Di+e{Aa1>W$MYM8QcbP
zAXbWc>Dh#S&oRDCBh-)br|Djhan~r>F*!<PJjgD~3Bp8l=3PSsPR+qG?t_d!K+}s+
z3zCXt2CaZmQ=<$mcrb_=?ew(VYhqa2Mlzd*yMuGglk|>89c*pOj5Tt^L&0##RqETd
zt;0%n6WjSVuBeHELVV!U?-g|l8cX_&j;x?HWf>IqtHy+l{-Rk_kE%8jEsk~`F4Hhm
zz*oxJm`ge1qv|}8G2~7y%ts)qQBb-l-Rq2WsU`I=FdJ9jF>FX^e&4mC0jD=|u5gta
z(uGPBfmG8##zFriVprrCOk@;LHpy9<XxXqlChA(8jh#5x&r?o9I!dG$qqA{==|e|J
zt`tr+bty*?+sfPmeHrQ5gF3#4^s-pJgjKVN4R-;zEnPJ^l85lTN#-DCCg))Gr&w-e
zTJy{N7x51Km#CmXAys)G21VKu{;O1z35w5Ctxv@+ipsQ9SN=sJJWB;(4Vh?26&2Zr
z_=2=E#S0&M>SIs4PdxqDC(b?o#MAt@X&~t={~anQIekEJf0vpPXMc%mzemOIqo_Ek
zdXQ#F;g^!ne-uqb1b(B<3G(y5pyDs7_!<?5Z1zuqb_GUFIs+t_PZTqG2t+DSB?t?N
zOI|Cg-BaWC{N2!G#i6K^91x;T$EEz#MnLtv>r$d2?U5mv3`t}xkVXn5=A1So3WKPv
z?ghaxa+8}*Xo!sAR#E$9Tu~8)jVR8($F}faEQOr<-r@2_aRVt)jISC^;JaOkTady+
z!Ygg_5>wkigupl|us;M0;t2dt-#l&-dLSWHWzx**XGuVTd-T3T;aY6<bMl_=7lz>*
z5V|lZCkRW|*+5#*fYFUAMQM<QiH}tEHU15333elLYnwo@wH4rGN>0ff9;|acz!xFl
zZa<c<2F`Y1IrH$1F%P%pmnC6GYa1~Ox7w+oO%6IA3xa21kHW183C3^InsQ+hOEEdd
zP5KIZNHWNF`|X!WG^Q}2h%Zj~)+B9&jpS8c<^N3UfZsF@jQTj5mG|<$C#utG;bZVp
zt>Z^&>W&y7^vjo?O7jW!CHm%vCcdT6A;7v)uED~n^cA!);;+k<<N++v2Q*GTSxh!O
ze0GcZHd)MQ3B@3r5qa$><oi^ajW~9I>UOr5q_I!G0G<>1gDw6Ww7Q8LUuQejz&|2F
z7Uq7Cs31F+`eyn{lzuNdNwql|n3D*=-SQa_44s&Cv#A@GUiTu=q+Rf+Msg~TkpB(U
z_SI6>WHQ}8pDNJ9V1g1ogTfvJ?>2Zr79Q3g7q#-LrWur@p#OIbb6B&?B9s~Gtl1Ox
WJpNgGMw=+v%BP)cb^+eu&i?_6kEGrJ

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e803d19b28ae02db23c1203a34cd91860783dc4
GIT binary patch
literal 8540
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
JEvsV5{{{8MbW{KU

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a29346dca3da9405d20064e434c475fcbd687b4f
GIT binary patch
literal 173
zcmd1j<>g`kg5`EMQ$X}%5P=LBfgA@QE@lA|DGb33nv8xc8Hzx{2;x_Oenx(7s(w{Q
zVtz_~Ub=o!ez8$}d9i+RQL=tXQDSCJd`fCbYH~?teqMZDeo88K!T9*hyv&mLc)fzk
WTO2mI`6;D2sdgZnikW}}3j+XQCM-|@

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..108db98bb6506399a21ca2fadf9221c73d5f37da
GIT binary patch
literal 167
zcmZ?b<>g`kg5`EMQ$X}%5CH>>K!yVl7qb9~6oz01O-8?!3`HPe1o10CKO;XkRlh1D
zF+U|gFI~SVzt||gyjZ`uC|SRxC^0i9J|(pzHMt}+KQBHnKP45rV0?ULUS>&ryk0@&
UEe@O9{FKt1R6CGOpMjVG0N*eyod5s;

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b9029ed969ff988e7ccbe4405900b9c4afb469e
GIT binary patch
literal 3390
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
PU`dN_TAQ!m{LX&?Tzl?c

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-39.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ed3c2b27a61c9d025239c1628584438152e1683
GIT binary patch
literal 2460
zcmZ`*J98XG5T4oh?L8#R@&gA(g$XzpNPftMqA2qa2m(-Gi)53n)y~}Mq`lem%&s3|
zl^|1&L=Mp%nSTHQRs05iz!VwLRS^<F0NryBpIv6IrnkFydZxGM>+VaM&5*!&cl0y6
z3fvzkEDi^Rk6^01Kp0^(BYhfCI^nH8wFo7BJ93Q1%G|yed6axkn9ZCgggKlZ_$PK0
zfW~DWXuPSW#^^oL_Q$X<*=bYlKInF@-%e3n9OwWJbqxq75oIK@7-bf-xqaYtoTsEi
znZw*CwFnMi{u2^;Pl-b!AGQy)yS=sZo{|<=Z||laZZ#b~JYAS|nCf>R1u1AnPOPCd
zf{&`~io|vWXB}Gd?ZT-XW}VUl7qp&e6+W|vL1m5T3H_E9wS%xC2Ob2-`ObQcd{1Ci
zeXa%X=Gw+w>oPLeHj5VXDq6WGc<NG78!j`yqAVDpe8$M|ek!k2w*2)4i?bCOuCf~F
zf9nz!{zQcb&-zbvWZ}g?BpN#=1`z0QAbBB^p5W|gwG@XUe<;@WlJsyd7ySLTZ;r=j
zAQ<C|Kzan?Hilr3F-#KG_@gu{Rqp|BJKEXj3Db3z=90&QJkM?}3Y$7e%12r9n9H^;
zYhW!AX%eH|KBrw(4!D#yNIHn)p6C^EtZgtcZbm_eCq*f_k_Z6ZxLb;%*XN%}nM>_;
za@kJ`Z3&^nd;EUM;boF(cjAS4Y)+(Gusa~&3vksqp}nnKJh;K0J0lx-Ks}BXFOs5=
zaoqN`qj=WQo=CGqDILtBBbRXP((?eudx_#Y6yQ&6zEyjN4-?r{&#11&u`!S1XXNkQ
zjs3jOH;(p`oaLgsA#-&jeyBE-OgHc{vY7FLr$sLpvB(*JwXzRyvN+2V#^w6pv21}m
z2x+wjgwPiCXh4^(7Cmo%ExHUphqf$_uKat{GO4gWi*|}RF&p?{xYHI)^%oET6shQl
z9$Uas1o|;RacEUGa88#TLm~|A$^pp(&M|r)IM=KV3h%(LyviR2Bd8h^sAJMH=hQi_
zRkg~$K#oJRDy)K6uBun{Du7iDv#L?iSFUPS?yy!hM^KX>1w;8K_)s@~wTxZsf9zVu
zu7!3*0}>Cbk-Ia-pumOqGRTia?zS!MVAORp$$DK81K0(Zs@;^Uuuz^uavq66ID*?C
zOVe##?}>uTL7pWA2SD|Xxb~94fD2||G{K!)l!J`7m*gcd)%4Lz+iE{Ai$PhaD466~
zN16;WheSa+FxneY*eTT{2{)tWRBLi_bK%uZZNqMn2T2A``35>`$Q3->hol1NGIT_}
z353uPf0hFipO<Mcogv^Uq?bW=)SO^yYWpm}WEM%ELo$bP43R4{<Qs8(zf7{p8@Yn#
z)jvs!bbkjj2eJ`?EV07t<}_<ko@H^o;N%)EK~GK5z{0JtGz9eGs?nq%yfEgS<0`0U
zox}7DYI+9r5YsbEqgv=0uDk#S>C7DW#LU3EHLW57=A~9a8NCD<QP@MLu%SgjA)jEK
zxu-5P5<nN|J#0^>zzuyU<oI+e$QEXg>=Cw=z!d7*&KQp#+dyOhWE(K(4-&?DqN|;~
zUZQrPiu*k=$dZ(IfBXT*FCVsRvWX_>{3M<jW_cC~)^hFK<zIfS{ZC~+fa}-pUY4ha
zZEu1+0BfA?CqnQH>fMZ!m(lulAW_SpdA>%j;hQ;n%z?K-rSMR!L;=*D6{trcaE*VC
z&djRttIH2&9e(f@Ooe>{lGv0VNJ<L-4&)uswJqbTd<XaiU|c~FvGXxZg*y>?v^+m=
z3Qc((^b1yNC>m1?*e#e-IIYx82-~3!id?4q>p~d7MrUW@dZ!eoQbWsu#GCQ*E!ZTo
q;ctv-VcPr3px=OVaw{fW&k3HcgAXQ2at9l%!uxJO+#1%(wf_K_V@JaP

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/v1_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/v1_trailDetectionNode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d94f2c6747331e53919f20480d27449e3c971e8
GIT binary patch
literal 7419
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
CJ*Tw*

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da38997b960fee7a3d0a12059864382d75072af4
GIT binary patch
literal 6580
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc47269785bcb8b26e33c6f6351334c0c72468f8
GIT binary patch
literal 5456
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
WeH_34WbN$m&YwL@7hK%V|NB2(_ce6@

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-39.pyc b/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ff37c2ace5ee8be1c9f6edf0d90753bd6111841
GIT binary patch
literal 5926
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/visualizer_v1_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/visualizer_v1_trailDetectionNode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cd4e32d62bc9b3ba483c8792aec0f75c18dbad32
GIT binary patch
literal 9034
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
E2S8v-)Bpeg

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e2bdc9339a34b12ccf04eccec095a727c47c602
GIT binary patch
literal 8399
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
B*2e$<

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/model_loader.py b/trail_detection_node/trail_detection_node/model_loader.py
new file mode 100644
index 00000000..908c74f6
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/model_loader.py
@@ -0,0 +1,99 @@
+import torch.nn as nn
+import torch.nn.functional as F
+from .vgg import vgg16
+
+class FCN8s(nn.Module):
+    def __init__(self, nclass, backbone='vgg16', aux=False, pretrained_base=True, norm_layer=nn.BatchNorm2d, **kwargs):
+        super(FCN8s, self).__init__()
+        self.aux = aux
+        if backbone == 'vgg16':
+            self.pretrained = vgg16(pretrained=pretrained_base).features
+        else:
+            raise RuntimeError('unknown backbone: {}'.format(backbone))
+        self.pool3 = nn.Sequential(*self.pretrained[:17])
+        self.pool4 = nn.Sequential(*self.pretrained[17:24])
+        self.pool5 = nn.Sequential(*self.pretrained[24:])
+        self.head = _FCNHead(512, nclass, norm_layer)
+        self.score_pool3 = nn.Conv2d(256, nclass, 1)
+        self.score_pool4 = nn.Conv2d(512, nclass, 1)
+        if aux:
+            self.auxlayer = _FCNHead(512, nclass, norm_layer)
+
+        self.__setattr__('exclusive',
+                         ['head', 'score_pool3', 'score_pool4', 'auxlayer'] if aux else ['head', 'score_pool3',
+                                                                                         'score_pool4'])
+
+    def forward(self, x):
+        pool3 = self.pool3(x)
+        pool4 = self.pool4(pool3)
+        pool5 = self.pool5(pool4)
+
+        outputs = []
+        score_fr = self.head(pool5)
+
+        score_pool4 = self.score_pool4(pool4)
+        score_pool3 = self.score_pool3(pool3)
+
+        upscore2 = F.interpolate(score_fr, score_pool4.size()[2:], mode='bilinear', align_corners=True)
+        fuse_pool4 = upscore2 + score_pool4
+
+        upscore_pool4 = F.interpolate(fuse_pool4, score_pool3.size()[2:], mode='bilinear', align_corners=True)
+        fuse_pool3 = upscore_pool4 + score_pool3
+
+        out = F.interpolate(fuse_pool3, x.size()[2:], mode='bilinear', align_corners=True)
+        outputs.append(out)
+
+        if self.aux:
+            auxout = self.auxlayer(pool5)
+            auxout = F.interpolate(auxout, x.size()[2:], mode='bilinear', align_corners=True)
+            outputs.append(auxout)
+
+        return tuple(outputs)
+
+class FCN32s(nn.Module):
+    """There are some difference from original fcn"""
+
+    def __init__(self, nclass, backbone='vgg16', aux=False, pretrained_base=True,
+                 norm_layer=nn.BatchNorm2d, **kwargs):
+        super(FCN32s, self).__init__()
+        self.aux = aux
+        if backbone == 'vgg16':
+            self.pretrained = vgg16(pretrained=pretrained_base).features
+        else:
+            raise RuntimeError('unknown backbone: {}'.format(backbone))
+        self.head = _FCNHead(512, nclass, norm_layer)
+        if aux:
+            self.auxlayer = _FCNHead(512, nclass, norm_layer)
+
+        self.__setattr__('exclusive', ['head', 'auxlayer'] if aux else ['head'])
+
+    def forward(self, x):
+        size = x.size()[2:]
+        pool5 = self.pretrained(x)
+
+        outputs = []
+        out = self.head(pool5)
+        out = F.interpolate(out, size, mode='bilinear', align_corners=True)
+        outputs.append(out)
+
+        if self.aux:
+            auxout = self.auxlayer(pool5)
+            auxout = F.interpolate(auxout, size, mode='bilinear', align_corners=True)
+            outputs.append(auxout)
+
+        return tuple(outputs)
+
+class _FCNHead(nn.Module):
+    def __init__(self, in_channels, channels, norm_layer=nn.BatchNorm2d, **kwargs):
+        super(_FCNHead, self).__init__()
+        inter_channels = in_channels // 4
+        self.block = nn.Sequential(
+            nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
+            norm_layer(inter_channels),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.1),
+            nn.Conv2d(inter_channels, channels, 1)
+        )
+
+    def forward(self, x):
+        return self.block(x)
\ No newline at end of file
diff --git a/trail_detection_node/trail_detection_node/setup.py b/trail_detection_node/trail_detection_node/setup.py
new file mode 100644
index 00000000..ff6a39fd
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/setup.py
@@ -0,0 +1,125 @@
+from setuptools import find_packages, setup
+
+
+def readme():
+    with open('README.md', encoding='utf-8') as f:
+        content = f.read()
+    return content
+
+
+version_file = 'mmseg/version.py'
+
+
+def get_version():
+    with open(version_file, 'r') as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+def parse_requirements(fname='requirements.txt', with_version=True):
+    """Parse the package dependencies listed in a requirements file but strips
+    specific versioning information.
+
+    Args:
+        fname (str): path to requirements file
+        with_version (bool, default=False): if True include version specs
+
+    Returns:
+        List[str]: list of requirements items
+
+    CommandLine:
+        python -c "import setup; print(setup.parse_requirements())"
+    """
+    import sys
+    from os.path import exists
+    import re
+    require_fpath = fname
+
+    def parse_line(line):
+        """Parse information from a line in a requirements text file."""
+        if line.startswith('-r '):
+            # Allow specifying requirements in other files
+            target = line.split(' ')[1]
+            for info in parse_require_file(target):
+                yield info
+        else:
+            info = {'line': line}
+            if line.startswith('-e '):
+                info['package'] = line.split('#egg=')[1]
+            else:
+                # Remove versioning from the package
+                pat = '(' + '|'.join(['>=', '==', '>']) + ')'
+                parts = re.split(pat, line, maxsplit=1)
+                parts = [p.strip() for p in parts]
+
+                info['package'] = parts[0]
+                if len(parts) > 1:
+                    op, rest = parts[1:]
+                    if ';' in rest:
+                        # Handle platform specific dependencies
+                        # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies
+                        version, platform_deps = map(str.strip,
+                                                     rest.split(';'))
+                        info['platform_deps'] = platform_deps
+                    else:
+                        version = rest  # NOQA
+                    info['version'] = (op, version)
+            yield info
+
+    def parse_require_file(fpath):
+        with open(fpath, 'r') as f:
+            for line in f.readlines():
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    for info in parse_line(line):
+                        yield info
+
+    def gen_packages_items():
+        if exists(require_fpath):
+            for info in parse_require_file(require_fpath):
+                parts = [info['package']]
+                if with_version and 'version' in info:
+                    parts.extend(info['version'])
+                if not sys.version.startswith('3.4'):
+                    # apparently package_deps are broken in 3.4
+                    platform_deps = info.get('platform_deps')
+                    if platform_deps is not None:
+                        parts.append(';' + platform_deps)
+                item = ''.join(parts)
+                yield item
+
+    packages = list(gen_packages_items())
+    return packages
+
+
+if __name__ == '__main__':
+    setup(
+        name='mmsegmentation',
+        version=get_version(),
+        description='Open MMLab Semantic Segmentation Toolbox and Benchmark',
+        long_description_content_type='text/markdown',
+        author='MMSegmentation Authors',
+        author_email='openmmlab@gmail.com',
+        keywords='computer vision, semantic segmentation',
+        url='http://github.com/open-mmlab/mmsegmentation',
+        packages=find_packages(exclude=('configs', 'tools', 'demo')),
+        classifiers=[
+            'Development Status :: 4 - Beta',
+            'License :: OSI Approved :: Apache Software License',
+            'Operating System :: OS Independent',
+            'Programming Language :: Python :: 3.6',
+            'Programming Language :: Python :: 3.7',
+            'Programming Language :: Python :: 3.8',
+        ],
+        license='Apache License 2.0',
+        setup_requires=parse_requirements('requirements/build.txt'),
+        tests_require=parse_requirements('requirements/tests.txt'),
+        install_requires=parse_requirements('requirements/runtime.txt'),
+        extras_require={
+            'all': parse_requirements('requirements.txt'),
+            'tests': parse_requirements('requirements/tests.txt'),
+            'build': parse_requirements('requirements/build.txt'),
+            'optional': parse_requirements('requirements/optional.txt'),
+        },
+        ext_modules=[],
+        zip_safe=False)
diff --git a/trail_detection_node/trail_detection_node/v1_trailDetectionNode.py b/trail_detection_node/trail_detection_node/v1_trailDetectionNode.py
new file mode 100644
index 00000000..c20f7df5
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/v1_trailDetectionNode.py
@@ -0,0 +1,278 @@
+import torch
+from .model_loader import FCN8s
+from PIL import Image as ImagePIL
+from torchvision import transforms
+import cv2
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import PoseStamped
+from sensor_msgs.msg import Image, PointCloud2
+import sensor_msgs_py.point_cloud2 as pc2
+import numpy as np
+import math
+from cv_bridge import CvBridge
+
+'''
+    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
+'''
+camera_transformation_k = np.array([
+    [628.5359544,0,676.9575694],
+    [0,627.7249542,532.7206716],
+    [0,0,1]])
+
+rotation_matrix = np.array([
+    [-0.007495781893,-0.0006277316155,0.9999717092],
+    [-0.9999516401,-0.006361853422,-0.007499625104],
+    [0.006366381192,-0.9999795662,-0.0005800141927]])
+
+rotation_matrix = rotation_matrix.T
+
+translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
+image_width=1280
+image_height=1024
+
+def convert_to_lidar_frame(uv_coordinate):
+    """
+    convert 2d camera coordinate + depth into 3d lidar frame
+    """
+    point_cloud = np.empty( (3,) , dtype=float)
+    point_cloud[2] = uv_coordinate[2]
+    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
+    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
+
+    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
+    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
+    point_cloud = inverse_camera_transformation_k @ point_cloud
+    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
+    return point_cloud
+
+def convert_to_camera_frame(point_cloud):
+    """
+    convert 3d lidar data into 2d coordinate of the camera frame + depth
+    """
+    length = point_cloud.shape[0]
+    translation = np.tile(translation_vector, (length, 1)).T
+    
+    point_cloud = point_cloud.T
+    point_cloud = rotation_matrix@point_cloud + translation
+    point_cloud = camera_transformation_k @ point_cloud
+
+    uv_coordinate = np.empty_like(point_cloud)
+
+    """
+    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
+    """
+    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
+    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
+    uv_coordinate[2] = point_cloud[2]
+
+    uv_depth = uv_coordinate[2, :]
+    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
+    return filtered_uv_coordinate
+
+def estimate_depth(x, y, np_2d_array):
+    """
+    estimate the depth by finding points closest to x,y from thhe 2d array
+    """
+    # Calculate the distance between each point and the target coordinates (x, y)
+    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
+
+    # Find the indices of the k nearest points
+    k = 5     # Number of nearest neighbors we want
+    closest_indices = np.argpartition(distances_sq, k)[:k]
+    pixel_distance_threshold = 2000
+
+    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
+    if len(valid_indices) == 0:
+        # lidar points disappears usually around 0.4m
+        distance_where_lidar_stops_working = -1
+        return distance_where_lidar_stops_working
+
+    filtered_indices = np.array(valid_indices)
+    # Get the depth value of the closest point
+    closest_depths = np_2d_array[2,filtered_indices]
+
+    return np.mean(closest_depths)
+
+def load_model(device):
+    model = FCN8s(nclass=6, backbone='vgg16', pretrained_base=True, pretrained=True)
+    model.load_state_dict(torch.load('src/trail_detection_node/trail_detection_node/model/fcn8s_vgg16_pascal_voc.pth'))
+    model = model.to(device)
+    print('Finished loading model!')
+
+    return model
+
+def find_route(model, device, cv_image):
+    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+    image = transform(PIL_image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        output = model(image)
+    # pred is prediction generated by the model, route is the variable for the center line
+    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
+    pred[pred != 1] = 0 # only see the trail
+    pred[pred == 1] = 255
+    pred = np.array(pred, dtype=np.uint8)
+    route = np.zeros_like(pred)
+    # calculate the center line by taking the average
+    row_num = 0
+    for row in pred:
+        white_pixels = list(np.nonzero(row)[0])
+        if white_pixels:
+            average = (white_pixels[0] + white_pixels[-1]) / 2
+            route[row_num][round(average)] = 255
+        row_num = row_num + 1
+    return route
+
+'''
+    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
+    it detects the trail in the image and sends the corresponding lidar position as the trail location.
+    The msgs are synchornized before processing, using buffer and sync function.
+    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
+    and choose to go to the closest point. 
+    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
+'''
+class trailDetector(Node):
+    def __init__(self, model, device):
+        super().__init__('trail_detector')
+        # define trail subscription
+        self.trail_publisher = self.create_publisher(
+            PoseStamped,
+            'trail_location',
+            10)
+        
+        # define camera subscription
+        self.camera_subscription = self.create_subscription(
+            Image,
+            'camera',
+            self.camera_callback,
+            10)
+        self.camera_subscription
+        
+        # define lidar subscription
+        self.lidar_subscription = self.create_subscription(
+            PointCloud2,
+            'velodyne_points',  
+            self.lidar_callback,
+            10)
+        self.lidar_subscription
+
+        self.bridge = CvBridge()
+
+        # load model and device
+        self.model = model
+        self.device = device
+
+        # buffers to hold msgs for sync
+        self.buffer_size = 30   # 30 is a random choice, to be discussed 
+        self.lidar_buffer = []
+        self.camera_buffer = []
+    
+    def camera_callback(self, msg):
+        if len(self.camera_buffer) >= self.buffer_size:
+            self.camera_buffer.pop(0)
+        self.camera_buffer.append(msg)
+        self.sync()
+
+    def lidar_callback(self, msg):           
+        if len(self.lidar_buffer) >= self.buffer_size:
+            self.lidar_buffer.pop(0)
+        self.lidar_buffer.append(msg)
+        self.sync()
+
+    def sync(self):
+        # if one of the sensor has no msg, then return
+        if not self.lidar_buffer or not self.camera_buffer:
+            return
+        
+        while self.lidar_buffer and self.camera_buffer:
+            lidar_msg = self.lidar_buffer[0]
+            camera_msg = self.camera_buffer[0]
+
+            time_tolerance = 5000000    # nanosec, random choice to be discussed
+            time_difference = abs(lidar_msg.header.stamp.nanosec - camera_msg.header.stamp.nanosec)
+            print(time_difference)
+            
+            # compare the time difference, if it's within tolerance, then pass to the trail_callback, otherwise discard the older msg
+            if time_difference <= time_tolerance:
+                self.lidar_buffer.pop(0)
+                self.camera_buffer.pop(0)
+                self.get_logger().info("msgs received!")
+                self.trail_callback(lidar_msg, camera_msg)
+            elif lidar_msg.header.stamp.nanosec > camera_msg.header.stamp.nanosec:
+                self.camera_buffer.pop(0)
+            else:
+                self.lidar_buffer.pop(0)
+
+    def trail_callback(self, lidar_msg, camera_msg):
+        # process lidar msg
+        point_gen = pc2.read_points(
+            lidar_msg, field_names=(
+                "x", "y", "z"), skip_nans=True)
+        points = [[x, y, z] for x, y, z in point_gen]
+        points = np.array(points)
+        points2d = convert_to_camera_frame(points)
+
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        route = find_route(self.model, self.device, cv_image)
+        route_indices = list(zip(*np.nonzero(route)))
+
+        if not route_indices:
+            print("No centerline found!")
+            return
+
+        # find the corresponding lidar points using the center line pixels
+        filtered_3dPoints = []
+        for index in route_indices:
+            point = []
+            point.append(index[0])
+            point.append(index[1])
+            point.append(estimate_depth(index[0], index[1], points2d))
+            point_3d = convert_to_lidar_frame(point)
+            filtered_3dPoints.append(point_3d)
+
+        filtered_3dPoints = np.array(filtered_3dPoints)
+        # find the nearest 3d point and set that as goal
+        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
+        smallest_index = np.argmin(distances_sq)
+
+        # publsih message
+        trail_location_msg = PoseStamped()
+        trail_location_msg.header.stamp = lidar_msg.header.stamp
+        trail_location_msg.header.frame_id = "velodyne"
+        #position
+        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
+        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
+        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
+        #orientation
+        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
+        trail_location_msg.pose.orientation.x = 0.0  
+        trail_location_msg.pose.orientation.y = 0.0 
+        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
+        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
+        self.get_logger().info("location published!")
+        self.trail_publisher.publish(trail_location_msg)
+        
+        
+
+
+
+def main(args=None):
+    print(torch.cuda.is_available())
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = load_model(device)
+    
+    rclpy.init(args=args)
+    trailDetectorNode = trailDetector(model, device)
+    rclpy.spin(trailDetectorNode)
+
+    trailDetectorNode.destroy_node()
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
new file mode 100644
index 00000000..309ab765
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
@@ -0,0 +1,233 @@
+import torch
+from .model_loader import FCN8s
+from PIL import Image as ImagePIL
+from torchvision import transforms
+import cv2
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import PoseStamped
+from sensor_msgs.msg import Image, PointCloud2
+import sensor_msgs_py.point_cloud2 as pc2
+import numpy as np
+import math
+from cv_bridge import CvBridge
+
+import message_filters
+
+'''
+    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
+'''
+camera_transformation_k = np.array([
+    [628.5359544,0,676.9575694],
+    [0,627.7249542,532.7206716],
+    [0,0,1]])
+
+rotation_matrix = np.array([
+    [-0.007495781893,-0.0006277316155,0.9999717092],
+    [-0.9999516401,-0.006361853422,-0.007499625104],
+    [0.006366381192,-0.9999795662,-0.0005800141927]])
+
+rotation_matrix = rotation_matrix.T
+
+translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
+image_width=1280
+image_height=1024
+
+def convert_to_lidar_frame(uv_coordinate):
+    """
+    convert 2d camera coordinate + depth into 3d lidar frame
+    """
+    point_cloud = np.empty( (3,) , dtype=float)
+    point_cloud[2] = uv_coordinate[2]
+    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
+    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
+
+    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
+    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
+    point_cloud = inverse_camera_transformation_k @ point_cloud
+    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
+    return point_cloud
+
+def convert_to_camera_frame(point_cloud):
+    """
+    convert 3d lidar data into 2d coordinate of the camera frame + depth
+    """
+    length = point_cloud.shape[0]
+    translation = np.tile(translation_vector, (length, 1)).T
+    
+    point_cloud = point_cloud.T
+    point_cloud = rotation_matrix@point_cloud + translation
+    point_cloud = camera_transformation_k @ point_cloud
+
+    uv_coordinate = np.empty_like(point_cloud)
+
+    """
+    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
+    """
+    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
+    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
+    uv_coordinate[2] = point_cloud[2]
+
+    uv_depth = uv_coordinate[2, :]
+    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
+    return filtered_uv_coordinate
+
+def estimate_depth(x, y, np_2d_array):
+    """
+    estimate the depth by finding points closest to x,y from thhe 2d array
+    """
+    # Calculate the distance between each point and the target coordinates (x, y)
+    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
+
+    # Find the indices of the k nearest points
+    k = 5     # Number of nearest neighbors we want
+    closest_indices = np.argpartition(distances_sq, k)[:k]
+    pixel_distance_threshold = 2000
+
+    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
+    if len(valid_indices) == 0:
+        # lidar points disappears usually around 0.4m
+        distance_where_lidar_stops_working = -1
+        return distance_where_lidar_stops_working
+
+    filtered_indices = np.array(valid_indices)
+    # Get the depth value of the closest point
+    closest_depths = np_2d_array[2,filtered_indices]
+
+    return np.mean(closest_depths)
+
+def load_model(device):
+    model = FCN8s(nclass=6, backbone='vgg16', pretrained_base=True, pretrained=True)
+    model.load_state_dict(torch.load('src/trail_detection_node/trail_detection_node/model/fcn8s_vgg16_pascal_voc.pth'))
+    model = model.to(device)
+    print('Finished loading model!')
+
+    return model
+
+def find_route(model, device, cv_image):
+    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+    image = transform(PIL_image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        output = model(image)
+    # pred is prediction generated by the model, route is the variable for the center line
+    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
+    pred[pred != 1] = 0 # only see the trail
+    pred[pred == 1] = 255
+    pred = np.array(pred, dtype=np.uint8)
+    route = np.zeros_like(pred)
+    # calculate the center line by taking the average
+    row_num = 0
+    for row in pred:
+        white_pixels = list(np.nonzero(row)[0])
+        if white_pixels:
+            average = (white_pixels[0] + white_pixels[-1]) / 2
+            route[row_num][round(average)] = 255
+        row_num = row_num + 1
+    return route
+
+'''
+    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
+    it detects the trail in the image and sends the corresponding lidar position as the trail location.
+    The msgs are synchornized before processing, using buffer and sync function.
+    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
+    and choose to go to the closest point. 
+    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
+'''
+class trailDetector(Node):
+    def __init__(self, model, device):
+        super().__init__('trail_detector')
+        # define trail publisher
+        self.trail_publisher = self.create_publisher(
+            PoseStamped,
+            'trail_location',
+            10)
+
+        # create subscribers
+        self.image_sub = message_filters.Subscriber(self, Image, 'camera')
+        self.lidar_sub = message_filters.Subscriber(self, PointCloud2, 'velodyne_points')
+
+        self.bridge = CvBridge()
+
+        # load model and device
+        self.model = model
+        self.device = device
+
+        # create callback
+        queue_size = 30
+        ts = message_filters.ApproximateTimeSynchronizer([self.image_sub, self.lidar_sub], queue_size, 0.5)
+        ts.registerCallback(self.trail_callback)  
+    
+    def trail_callback(self, camera_msg, lidar_msg):
+        print("Message received!")
+        # process lidar msg
+        point_gen = pc2.read_points(
+            lidar_msg, field_names=(
+                "x", "y", "z"), skip_nans=True)
+        points = [[x, y, z] for x, y, z in point_gen]
+        points = np.array(points)
+        points2d = convert_to_camera_frame(points)
+
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        route = find_route(self.model, self.device, cv_image)
+        route_indices = list(zip(*np.nonzero(route)))
+
+        if not route_indices:
+            print("No centerline found!")
+            return
+
+        # find the corresponding lidar points using the center line pixels
+        filtered_3dPoints = []
+        for index in route_indices:
+            point = []
+            point.append(index[0])
+            point.append(index[1])
+            point.append(estimate_depth(index[0], index[1], points2d))
+            point_3d = convert_to_lidar_frame(point)
+            filtered_3dPoints.append(point_3d)
+
+        filtered_3dPoints = np.array(filtered_3dPoints)
+        # find the nearest 3d point and set that as goal
+        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
+        smallest_index = np.argmin(distances_sq)
+
+        # publsih message
+        trail_location_msg = PoseStamped()
+        trail_location_msg.header.stamp = lidar_msg.header.stamp
+        trail_location_msg.header.frame_id = "velodyne"
+        #position
+        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
+        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
+        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
+        #orientation
+        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
+        trail_location_msg.pose.orientation.x = 0.0  
+        trail_location_msg.pose.orientation.y = 0.0 
+        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
+        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
+        self.get_logger().info("location published!")
+        self.trail_publisher.publish(trail_location_msg)
+        
+        
+
+
+
+def main(args=None):
+    print(torch.cuda.is_available())
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = load_model(device)
+    
+    rclpy.init(args=args)
+    trailDetectorNode = trailDetector(model, device)
+    rclpy.spin(trailDetectorNode)
+
+    trailDetectorNode.destroy_node()
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/trail_detection_node/trail_detection_node/vgg.py b/trail_detection_node/trail_detection_node/vgg.py
new file mode 100644
index 00000000..fe5c163c
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/vgg.py
@@ -0,0 +1,191 @@
+import torch
+import torch.nn as nn
+import torch.utils.model_zoo as model_zoo
+
+__all__ = [
+    'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
+    'vgg19_bn', 'vgg19',
+]
+
+model_urls = {
+    'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
+    'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
+    'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
+    'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
+    'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
+    'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
+    'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
+    'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',
+}
+
+
+class VGG(nn.Module):
+    def __init__(self, features, num_classes=1000, init_weights=True):
+        super(VGG, self).__init__()
+        self.features = features
+        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
+        self.classifier = nn.Sequential(
+            nn.Linear(512 * 7 * 7, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, num_classes)
+        )
+        if init_weights:
+            self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
+
+
+def make_layers(cfg, batch_norm=False):
+    layers = []
+    in_channels = 3
+    for v in cfg:
+        if v == 'M':
+            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
+        else:
+            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
+            if batch_norm:
+                layers += (conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True))
+            else:
+                layers += [conv2d, nn.ReLU(inplace=True)]
+            in_channels = v
+    return nn.Sequential(*layers)
+
+
+cfg = {
+    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
+    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
+}
+
+
+def vgg11(pretrained=False, **kwargs):
+    """VGG 11-layer model (configuration "A")
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['A']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg11']))
+    return model
+
+
+def vgg11_bn(pretrained=False, **kwargs):
+    """VGG 11-layer model (configuration "A") with batch normalization
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['A'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg11_bn']))
+    return model
+
+
+def vgg13(pretrained=False, **kwargs):
+    """VGG 13-layer model (configuration "B")
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['B']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg13']))
+    return model
+
+
+def vgg13_bn(pretrained=False, **kwargs):
+    """VGG 13-layer model (configuration "B") with batch normalization
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['B'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg13_bn']))
+    return model
+
+
+def vgg16(pretrained=False, **kwargs):
+    """VGG 16-layer model (configuration "D")
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['D']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg16']))
+    return model
+
+
+def vgg16_bn(pretrained=False, **kwargs):
+    """VGG 16-layer model (configuration "D") with batch normalization
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['D'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg16_bn']))
+    return model
+
+
+def vgg19(pretrained=False, **kwargs):
+    """VGG 19-layer model (configuration "E")
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['E']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg19']))
+    return model
+
+
+def vgg19_bn(pretrained=False, **kwargs):
+    """VGG 19-layer model (configuration 'E') with batch normalization
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['E'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg19_bn']))
+    return model
+
+
+if __name__ == '__main__':
+    img = torch.randn((4, 3, 480, 480))
+    model = vgg16(pretrained=False)
+    out = model(img)
diff --git a/trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py b/trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py
new file mode 100644
index 00000000..616b689d
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py
@@ -0,0 +1,431 @@
+import torch
+from .model_loader import FCN8s, FCN32s
+from PIL import Image as ImagePIL
+from torchvision import transforms
+import cv2
+import os
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import PoseStamped
+from sensor_msgs.msg import Image, PointCloud2
+import sensor_msgs_py.point_cloud2 as pc2
+import numpy as np
+import math
+from cv_bridge import CvBridge
+
+'''
+    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
+'''
+camera_transformation_k = np.array([
+    [628.5359544,0,676.9575694],
+    [0,627.7249542,532.7206716],
+    [0,0,1]])
+
+rotation_matrix = np.array([
+    [-0.007495781893,-0.0006277316155,0.9999717092],
+    [-0.9999516401,-0.006361853422,-0.007499625104],
+    [0.006366381192,-0.9999795662,-0.0005800141927]])
+
+rotation_matrix = rotation_matrix.T
+
+translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
+image_width=1280
+image_height=1024
+
+def convert_to_lidar_frame(uv_coordinate):
+    """
+    convert 2d camera coordinate + depth into 3d lidar frame
+    """
+    point_cloud = np.empty( (3,) , dtype=float)
+    point_cloud[2] = uv_coordinate[2]
+    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
+    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
+
+    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
+    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
+    point_cloud = inverse_camera_transformation_k @ point_cloud
+    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
+    return point_cloud
+
+def convert_to_camera_frame(point_cloud):
+    """
+    convert 3d lidar data into 2d coordinate of the camera frame + depth
+    """
+    length = point_cloud.shape[0]
+    translation = np.tile(translation_vector, (length, 1)).T
+    
+    point_cloud = point_cloud.T
+    point_cloud = rotation_matrix@point_cloud + translation
+    point_cloud = camera_transformation_k @ point_cloud
+
+    uv_coordinate = np.empty_like(point_cloud)
+
+    """
+    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
+    """
+    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
+    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
+    uv_coordinate[2] = point_cloud[2]
+
+    uv_depth = uv_coordinate[2, :]
+    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
+    return filtered_uv_coordinate
+
+def estimate_depth(x, y, np_2d_array):
+    """
+    estimate the depth by finding points closest to x,y from thhe 2d array
+    """
+    # Calculate the distance between each point and the target coordinates (x, y)
+    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
+
+    # Find the indices of the k nearest points
+    k = 5     # Number of nearest neighbors we want
+    closest_indices = np.argpartition(distances_sq, k)[:k]
+    pixel_distance_threshold = 2000
+
+    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
+    if len(valid_indices) == 0:
+        # lidar points disappears usually around 0.4m
+        distance_where_lidar_stops_working = -1
+        return distance_where_lidar_stops_working
+
+    filtered_indices = np.array(valid_indices)
+    # Get the depth value of the closest point
+    closest_depths = np_2d_array[2,filtered_indices]
+
+    return np.mean(closest_depths)
+
+def load_model(device):
+    model = FCN32s(nclass=2, backbone='vgg16', pretrained_base=True, pretrained=True)
+    # model_location = '32s_batch8/fcn32s_vgg16_pascal_voc_best_model.pth'
+    model_location = '500epoch/fcn32s_vgg16_pascal_voc.pth'
+    if os.path.isfile(f'src/trail_detection_node/trail_detection_node/model/{model_location}'):
+        model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
+    else:
+        model.load_state_dict(torch.load(f'trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
+    model = model.to(device)
+    print('Finished loading model!')
+
+    return model
+
+def find_route(model, device, cv_image):
+    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+    image = transform(PIL_image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        output = model(image)
+    # pred is prediction generated by the model, route is the variable for the center line
+    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
+    pred[pred == 0] = 255 # only see the trail
+    pred[pred == 1] = 0
+    pred[pred == 2] = 0
+    pred[pred == 3] = 0
+    pred[pred == 4] = 0
+    pred[pred == 5] = 0    
+    pred = np.array(pred, dtype=np.uint8)
+    
+    # # prediction visualize
+    # cv2.imshow('prediction',pred)
+    # cv2.waitKey(25)
+
+    route = np.zeros_like(pred)
+    # calculate the center line by taking the average
+    row_num = 0
+    for row in pred:
+        white_pixels = list(np.nonzero(row)[0])
+        if white_pixels:
+            average = (white_pixels[0] + white_pixels[-1]) / 2
+            route[row_num][round(average)] = 255
+        row_num = row_num + 1
+    return route, pred
+
+def equalize_hist_rgb(img):
+    # Split the image into its color channels
+    r, g, b = cv2.split(img)
+
+    # Equalize the histograms for each channel
+    r_eq = cv2.equalizeHist(r)
+    g_eq = cv2.equalizeHist(g)
+    b_eq = cv2.equalizeHist(b)
+
+    # Merge the channels
+    img_eq = cv2.merge((r_eq, g_eq, b_eq))
+    # img_eq = cv2.fastNlMeansDenoisingColored(img_eq,None,10,20,7,42)
+    # img_eq = cv2.GaussianBlur(img_eq, (25,25), 0)
+    return img_eq
+
+'''
+    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
+    it detects the trail in the image and sends the corresponding lidar position as the trail location.
+    The msgs are synchornized before processing, using buffer and sync function.
+    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
+    and choose to go to the closest point. 
+    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
+'''
+class trailDetector(Node):
+    def __init__(self, model, device):
+        super().__init__('trail_detector')
+        # define trail subscription
+        self.trail_publisher = self.create_publisher(
+            PoseStamped,
+            'trail_location',
+            10)
+        
+        # define camera subscription
+        self.camera_subscription = self.create_subscription(
+            Image,
+            'camera',
+            self.camera_callback,
+            10)
+        self.camera_subscription
+        
+        # define lidar subscription
+        self.lidar_subscription = self.create_subscription(
+            PointCloud2,
+            'velodyne_points',  
+            self.lidar_callback,
+            10)
+        self.lidar_subscription
+
+        self.bridge = CvBridge()
+
+        # load model and device
+        self.model = model
+        self.device = device
+
+        # buffers to hold msgs for sync
+        self.buffer_size = 50   # 30 is a random choice, to be discussed 
+        self.lidar_buffer = []
+        self.camera_buffer = []
+        self.only_camera_mode = False
+    
+    def camera_callback(self, msg):
+        if len(self.camera_buffer) >= self.buffer_size:
+            self.camera_buffer.pop(0)
+        self.camera_buffer.append(msg)
+        self.sync()
+
+    def lidar_callback(self, msg):           
+        if len(self.lidar_buffer) >= self.buffer_size:
+            self.lidar_buffer.pop(0)
+        self.lidar_buffer.append(msg)
+        self.sync()
+
+    def sync(self):
+        # if one of the sensor has no msg, then return
+        if self.only_camera_mode and self.camera_buffer:
+            camera_msg = self.camera_buffer[0]
+            self.camera_buffer.pop(0)
+            self.only_camera_callback(camera_msg)
+        elif not self.lidar_buffer or not self.camera_buffer:
+            return
+        
+        while self.lidar_buffer and self.camera_buffer:
+            lidar_msg = self.lidar_buffer[0]
+            camera_msg = self.camera_buffer[0]
+
+            time_tolerance = 20000000    # nanosec, random choice to be discussed
+            time_difference = abs(lidar_msg.header.stamp.nanosec - camera_msg.header.stamp.nanosec)
+            # print(time_difference)
+            
+            # compare the time difference, if it's within tolerance, then pass to the trail_callback, otherwise discard the older msg
+            if time_difference <= time_tolerance:
+                self.lidar_buffer.pop(0)
+                self.camera_buffer.pop(0)
+                self.get_logger().info("msgs received!")
+                self.trail_callback(lidar_msg, camera_msg)
+            elif lidar_msg.header.stamp.nanosec > camera_msg.header.stamp.nanosec:
+                self.camera_buffer.pop(0)
+            else:
+                self.lidar_buffer.pop(0)
+
+    def trail_callback(self, lidar_msg, camera_msg):
+        # process lidar msg
+        point_gen = pc2.read_points(
+            lidar_msg, field_names=(
+                "x", "y", "z"), skip_nans=True)
+        points = [[x, y, z] for x, y, z in point_gen]
+        points = np.array(points)
+        points2d = convert_to_camera_frame(points)
+
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        
+        # increase brightness
+        M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            print("No centerline found!")
+            return
+        
+        # #filter points that have no lidar points near it
+        # filtered_route_indices = []
+        # for index in route_indices:
+        #     point = []
+        #     point.append(index[0])
+        #     point.append(index[1])
+        #     point.append(estimate_depth(index[0], index[1], points2d))
+        #     if point[2] == -1:
+        #         continue
+        #     else:
+        #         filtered_route_indices.append(point)
+
+        # find the corresponding lidar points using the center line pixels
+        filtered_3dPoints = []
+        # for index in filtered_route_indices:
+        for index in route_indices:
+            point = []
+            # point.append(index[0])
+            # point.append(index[1])
+            # point.append(index[2])
+
+            point.append(index[0])
+            point.append(index[1])
+            point.append(estimate_depth(index[0], index[1], points2d))
+
+            point_3d = convert_to_lidar_frame(point)
+            filtered_3dPoints.append(point_3d)
+
+        filtered_3dPoints = np.array(filtered_3dPoints)
+        # find the nearest 3d point and set that as goal
+        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
+        smallest_index = np.argmin(distances_sq)
+        # print(math.sqrt(distances_sq[smallest_index]))
+        # smallest_index = np.argmin(filtered_3dPoints[:,2])
+
+        # visualize after-pocessed image
+        visualize_cv_image = cv_image
+        print(f"{visualize_cv_image.shape[0]}")
+        circle_x = route_indices[smallest_index][0]
+        circle_y = route_indices[smallest_index][1]
+        
+        # # visualize the lidar points in image
+        # uv_x, uv_y, uv_z = points2d
+        # for index_lidar in range(points2d.shape[1]):
+        #     # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
+        #     cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
+        
+        # visualize center line in image
+        for index_circle in range(len(route_indices)):
+            if index_circle == smallest_index:
+                continue
+            else:
+                red_circle_x = route_indices[index_circle][0]
+                red_circle_y = route_indices[index_circle][1]
+                cv2.circle(visualize_cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
+        
+        # visualize the chosen point in image
+        cv2.circle(visualize_cv_image, (circle_y, circle_x), radius=7, color=(0, 255, 0), thickness=-1)
+        cv2.circle(visualize_cv_image, (0, 0), radius=12, color=(0, 255, 0), thickness=-1)
+        
+        cv2.imshow('circled image',visualize_cv_image)
+        cv2.waitKey(25)
+
+        # publsih message
+        trail_location_msg = PoseStamped()
+        trail_location_msg.header.stamp = lidar_msg.header.stamp
+        trail_location_msg.header.frame_id = "velodyne"
+        #position
+        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
+        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
+        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
+        #orientation
+        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
+        trail_location_msg.pose.orientation.x = 0.0  
+        trail_location_msg.pose.orientation.y = 0.0 
+        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
+        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
+        self.get_logger().info("location published!")
+        self.trail_publisher.publish(trail_location_msg)
+        
+    def only_camera_callback(self, camera_msg):
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        # cv_image = cv2.resize(cv_image,(480,480))
+
+        # cv_image = cv2.fastNlMeansDenoisingColored(cv_image,None,5,5,5,11)
+        
+        # # histogram equalization method 1
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2YCrCb)
+        # cv_image[:,:,0] = cv2.equalizeHist(cv_image[:,:,0])
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_YCrCb2BGR)
+
+        # histogram equalization method 2
+        # cv_image = equalize_hist_rgb(cv_image)
+
+        # # histogram equalization method 3 CLAHE
+        # image_bw = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
+        # clahe = cv2.createCLAHE(clipLimit=5)
+        # cv_image = clahe.apply(image_bw) + 30
+
+        # # histogram equalization method 4 CLAHE
+        # cla = cv2.createCLAHE(clipLimit=4.0)
+        # H, S, V = cv2.split(cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV))
+        # eq_V = cla.apply(V)
+        # cv_image = cv2.cvtColor(cv2.merge([H, S, eq_V]), cv2.COLOR_HSV2BGR)
+
+        # # increase brightness
+        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        # cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route, pred = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        # increase the brightness of image where is predicted as road
+        sign = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR)
+        cv_image = cv2.add(cv_image, sign)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            print("No centerline found!")
+            return
+        
+        # for index_circle in range(len(route_indices)):
+        #     red_circle_x = route_indices[index_circle][0]
+        #     red_circle_y = route_indices[index_circle][1]
+        #     cv2.circle(cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
+
+        cv2.imshow('circled image',cv_image)
+        cv2.waitKey(25)
+        
+
+
+
+def main(args=None):
+    print(torch.cuda.is_available())
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = load_model(device)
+    
+    rclpy.init(args=args)
+    trailDetectorNode = trailDetector(model, device)
+    rclpy.spin(trailDetectorNode)
+
+    trailDetectorNode.destroy_node()
+    rclpy.shutdown()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    main()
diff --git a/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
new file mode 100644
index 00000000..5055d3f4
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
@@ -0,0 +1,392 @@
+import torch
+from .model_loader import FCN8s, FCN32s
+from PIL import Image as ImagePIL
+from torchvision import transforms
+import cv2
+import os
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import PoseStamped
+from sensor_msgs.msg import Image, PointCloud2
+import sensor_msgs_py.point_cloud2 as pc2
+import numpy as np
+import math
+from cv_bridge import CvBridge
+
+import message_filters
+from scipy.ndimage import grey_erosion
+'''
+    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
+'''
+camera_transformation_k = np.array([
+    [628.5359544,0,676.9575694],
+    [0,627.7249542,532.7206716],
+    [0,0,1]])
+
+rotation_matrix = np.array([
+    [-0.007495781893,-0.0006277316155,0.9999717092],
+    [-0.9999516401,-0.006361853422,-0.007499625104],
+    [0.006366381192,-0.9999795662,-0.0005800141927]])
+
+rotation_matrix = rotation_matrix.T
+
+translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
+image_width=1280
+image_height=1024
+
+def convert_to_lidar_frame(uv_coordinate):
+    """
+    convert 2d camera coordinate + depth into 3d lidar frame
+    """
+    point_cloud = np.empty( (3,) , dtype=float)
+    point_cloud[2] = uv_coordinate[2]
+    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
+    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
+
+    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
+    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
+    point_cloud = inverse_camera_transformation_k @ point_cloud
+    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
+    return point_cloud
+
+def convert_to_camera_frame(point_cloud):
+    """
+    convert 3d lidar data into 2d coordinate of the camera frame + depth
+    """
+    length = point_cloud.shape[0]
+    translation = np.tile(translation_vector, (length, 1)).T
+    
+    point_cloud = point_cloud.T
+    point_cloud = rotation_matrix@point_cloud + translation
+    point_cloud = camera_transformation_k @ point_cloud
+
+    uv_coordinate = np.empty_like(point_cloud)
+
+    """
+    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
+    """
+    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
+    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
+    uv_coordinate[2] = point_cloud[2]
+
+    uv_depth = uv_coordinate[2, :]
+    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
+    return filtered_uv_coordinate
+
+def estimate_depth(x, y, np_2d_array):
+    """
+    estimate the depth by finding points closest to x,y from thhe 2d array
+    """
+    # Calculate the distance between each point and the target coordinates (x, y)
+    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
+
+    # Find the indices of the k nearest points
+    k = 5     # Number of nearest neighbors we want
+    closest_indices = np.argpartition(distances_sq, k)[:k]
+    pixel_distance_threshold = 2000
+
+    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
+    if len(valid_indices) == 0:
+        # lidar points disappears usually around 0.4m
+        distance_where_lidar_stops_working = -1
+        return distance_where_lidar_stops_working
+
+    filtered_indices = np.array(valid_indices)
+    # Get the depth value of the closest point
+    closest_depths = np_2d_array[2,filtered_indices]
+
+    return np.mean(closest_depths)
+
+def load_model(device):
+    model = FCN32s(nclass=2, backbone='vgg16', pretrained_base=True, pretrained=True)
+    # model_location = '32s_batch8/fcn32s_vgg16_pascal_voc_best_model.pth'
+    model_location = '500epoch/fcn32s_vgg16_pascal_voc.pth'
+    if os.path.isfile(f'src/trail_detection_node/trail_detection_node/model/{model_location}'):
+        model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
+    else:
+        model.load_state_dict(torch.load(f'trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
+    model = model.to(device)
+    print('Finished loading model!')
+
+    return model
+
+def find_route(model, device, cv_image):
+    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+    image = transform(PIL_image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        output = model(image)
+    # pred is prediction generated by the model, route is the variable for the center line
+    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
+    pred[pred == 0] = 255 # only see the trail
+    pred[pred == 1] = 0    
+    pred = np.array(pred, dtype=np.uint8)
+
+    pred = grey_erosion(pred, size=(4,4))
+    
+    # # prediction visualize
+    # cv2.imshow('prediction',pred)
+    # cv2.waitKey(25)
+
+    route = np.zeros_like(pred)
+    # calculate the center line by taking the average
+    row_num = 0
+    for row in pred:
+        white_pixels = list(np.nonzero(row)[0])
+        if white_pixels:
+            average = (white_pixels[0] + white_pixels[-1]) / 2
+            route[row_num][round(average)] = 255
+        row_num = row_num + 1
+    return route, pred
+
+def equalize_hist_rgb(img):
+    # Split the image into its color channels
+    r, g, b = cv2.split(img)
+
+    # Equalize the histograms for each channel
+    r_eq = cv2.equalizeHist(r)
+    g_eq = cv2.equalizeHist(g)
+    b_eq = cv2.equalizeHist(b)
+
+    # Merge the channels
+    img_eq = cv2.merge((r_eq, g_eq, b_eq))
+    # img_eq = cv2.fastNlMeansDenoisingColored(img_eq,None,10,20,7,42)
+    # img_eq = cv2.GaussianBlur(img_eq, (25,25), 0)
+    return img_eq
+
+'''
+    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
+    it detects the trail in the image and sends the corresponding lidar position as the trail location.
+    The msgs are synchornized before processing, using buffer and sync function.
+    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
+    and choose to go to the closest point. 
+    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
+'''
+class trailDetector(Node):
+    def __init__(self, model, device):
+        super().__init__('trail_detector')
+        self.only_camera_mode = True
+        self.bridge = CvBridge()
+
+        # load model and device
+        self.model = model
+        self.device = device
+
+        # define trail publication
+        self.trail_publisher = self.create_publisher(
+            PoseStamped,
+            'trail_location',
+            10)
+        
+        if self.only_camera_mode:
+            # define camera subscription
+            print("Mode: Only Camera")
+            self.camera_subscription = self.create_subscription(
+                Image,
+                'camera',
+                self.only_camera_callback,
+                10)
+            self.camera_subscription
+        else:
+            # create subscribers and synchronizer
+            print("Mode: Lidar and Camera")
+            self.image_sub = message_filters.Subscriber(self, Image, 'camera')
+            self.lidar_sub = message_filters.Subscriber(self, PointCloud2, 'velodyne_points')
+            queue_size = 30
+            ts = message_filters.ApproximateTimeSynchronizer([self.image_sub, self.lidar_sub], queue_size, 0.5)
+            ts.registerCallback(self.trail_callback)
+        
+
+        
+
+    def trail_callback(self, camera_msg, lidar_msg):
+        print("Message received!")
+        # process lidar msg
+        point_gen = pc2.read_points(
+            lidar_msg, field_names=(
+                "x", "y", "z"), skip_nans=True)
+        points = [[x, y, z] for x, y, z in point_gen]
+        points = np.array(points)
+        points2d = convert_to_camera_frame(points)
+
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        
+        # # increase brightness
+        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        # cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route, _ = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            print("No centerline found!")
+            return
+        
+        #filter points that have no lidar points near it
+        filtered_route_indices = []
+        for index in route_indices:
+            point = []
+            point.append(index[0])
+            point.append(index[1])
+            point.append(estimate_depth(index[0], index[1], points2d))
+            if point[2] == -1:
+                continue
+            else:
+                filtered_route_indices.append(point)
+
+        # find the corresponding lidar points using the center line pixels
+        filtered_3dPoints = []
+        for index in filtered_route_indices:
+        # for index in route_indices:
+            point = []
+            point.append(index[0])
+            point.append(index[1])
+            point.append(index[2])
+
+            # point.append(index[0])
+            # point.append(index[1])
+            # point.append(estimate_depth(index[0], index[1], points2d))
+
+            point_3d = convert_to_lidar_frame(point)
+            filtered_3dPoints.append(point_3d)
+
+        filtered_3dPoints = np.array(filtered_3dPoints)
+        # find the nearest 3d point and set that as goal
+        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
+        smallest_index = np.argmin(distances_sq)
+        # print(math.sqrt(distances_sq[smallest_index]))
+        # smallest_index = np.argmin(filtered_3dPoints[:,2])
+
+        # visualize after-pocessed image
+        visualize_cv_image = cv_image
+        print(f"{visualize_cv_image.shape[0]}")
+        circle_x = route_indices[smallest_index][0]
+        circle_y = route_indices[smallest_index][1]
+        
+        # # visualize the lidar points in image
+        # uv_x, uv_y, uv_z = points2d
+        # for index_lidar in range(points2d.shape[1]):
+        #     # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
+        #     cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
+        
+        # visualize center line in image
+        for index_circle in range(len(route_indices)):
+            if index_circle == smallest_index:
+                continue
+            else:
+                red_circle_x = route_indices[index_circle][0]
+                red_circle_y = route_indices[index_circle][1]
+                cv2.circle(visualize_cv_image, (red_circle_x, red_circle_y), radius=5, color=(0, 0, 255), thickness=-1)
+        
+        # visualize the chosen point in image
+        cv2.circle(visualize_cv_image, (circle_x, circle_y), radius=7, color=(0, 255, 0), thickness=-1)
+        cv2.circle(visualize_cv_image, (0, 0), radius=12, color=(0, 255, 0), thickness=-1)
+        
+        cv2.imshow('circled image',visualize_cv_image)
+        cv2.waitKey(25)
+
+        # publsih message
+        trail_location_msg = PoseStamped()
+        trail_location_msg.header.stamp = lidar_msg.header.stamp
+        trail_location_msg.header.frame_id = "velodyne"
+        #position
+        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
+        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
+        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
+        #orientation
+        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
+        trail_location_msg.pose.orientation.x = 0.0  
+        trail_location_msg.pose.orientation.y = 0.0 
+        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
+        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
+        self.get_logger().info("location published!")
+        self.trail_publisher.publish(trail_location_msg)
+        
+    def only_camera_callback(self, camera_msg):
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        # cv_image = cv2.resize(cv_image,(480,480))
+
+        # cv_image = cv2.fastNlMeansDenoisingColored(cv_image,None,5,5,5,11)
+        
+        # # histogram equalization method 1
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2YCrCb)
+        # cv_image[:,:,0] = cv2.equalizeHist(cv_image[:,:,0])
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_YCrCb2BGR)
+
+        # histogram equalization method 2
+        # cv_image = equalize_hist_rgb(cv_image)
+
+        # # histogram equalization method 3 CLAHE
+        # image_bw = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
+        # clahe = cv2.createCLAHE(clipLimit=5)
+        # cv_image = clahe.apply(image_bw) + 30
+
+        # # histogram equalization method 4 CLAHE
+        # cla = cv2.createCLAHE(clipLimit=4.0)
+        # H, S, V = cv2.split(cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV))
+        # eq_V = cla.apply(V)
+        # cv_image = cv2.cvtColor(cv2.merge([H, S, eq_V]), cv2.COLOR_HSV2BGR)
+
+        # # increase brightness
+        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        # cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route, pred = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        # increase the brightness of image where is predicted as road
+        sign = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR)
+        cv_image = cv2.add(cv_image, sign)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            print("No centerline found!")
+            return
+        
+        # for index_circle in range(len(route_indices)):
+        #     red_circle_x = route_indices[index_circle][0]
+        #     red_circle_y = route_indices[index_circle][1]
+        #     cv2.circle(cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
+
+        cv2.imshow('circled image',cv_image)
+        cv2.waitKey(25)
+        
+
+
+
+def main(args=None):
+    print(torch.cuda.is_available())
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = load_model(device)
+    
+    rclpy.init(args=args)
+    trailDetectorNode = trailDetector(model, device)
+    rclpy.spin(trailDetectorNode)
+
+    trailDetectorNode.destroy_node()
+    rclpy.shutdown()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    main()

From efd93a159fb62fd79194cfa2e0d93fe21319a426 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 31 Aug 2023 16:33:30 -0400
Subject: [PATCH 02/22] add psp model, change the coordinate conversion

---
 .../__pycache__/jpu.cpython-310.pyc           | Bin 0 -> 2452 bytes
 .../__pycache__/jpu.cpython-37.pyc            | Bin 0 -> 2441 bytes
 .../__pycache__/model_loader.cpython-310.pyc  | Bin 3390 -> 6824 bytes
 .../__pycache__/model_loader.cpython-37.pyc   | Bin 0 -> 6861 bytes
 .../__pycache__/model_store.cpython-310.pyc   | Bin 0 -> 1425 bytes
 .../__pycache__/segbase.cpython-310.pyc       | Bin 0 -> 2194 bytes
 .../__pycache__/segbase.cpython-37.pyc        | Bin 0 -> 2155 bytes
 .../v2_trailDetectionNode.cpython-310.pyc     | Bin 6580 -> 7265 bytes
 .../__pycache__/vgg.cpython-37.pyc            | Bin 0 -> 5925 bytes
 ...izer_v2_trailDetectionNode.cpython-310.pyc | Bin 8399 -> 8830 bytes
 ...lizer_v2_trailDetectionNode.cpython-37.pyc | Bin 0 -> 8356 bytes
 .../__pycache__/__init__.cpython-310.pyc      | Bin 0 -> 330 bytes
 .../__pycache__/__init__.cpython-39.pyc       | Bin 0 -> 328 bytes
 .../__pycache__/densenet.cpython-310.pyc      | Bin 0 -> 8119 bytes
 .../__pycache__/densenet.cpython-39.pyc       | Bin 0 -> 8190 bytes
 .../__pycache__/eespnet.cpython-310.pyc       | Bin 0 -> 6119 bytes
 .../__pycache__/eespnet.cpython-39.pyc        | Bin 0 -> 6085 bytes
 .../__pycache__/resnet.cpython-310.pyc        | Bin 0 -> 6189 bytes
 .../__pycache__/resnet.cpython-39.pyc         | Bin 0 -> 6424 bytes
 .../__pycache__/resnetv1b.cpython-310.pyc     | Bin 0 -> 7205 bytes
 .../__pycache__/resnetv1b.cpython-37.pyc      | Bin 0 -> 8293 bytes
 .../__pycache__/resnetv1b.cpython-39.pyc      | Bin 0 -> 7945 bytes
 .../__pycache__/vgg.cpython-310.pyc           | Bin 0 -> 5493 bytes
 .../__pycache__/vgg.cpython-39.pyc            | Bin 0 -> 5965 bytes
 .../__pycache__/xception.cpython-310.pyc      | Bin 0 -> 9518 bytes
 .../__pycache__/xception.cpython-39.pyc       | Bin 0 -> 10103 bytes
 .../base_models/resnetv1b.py                  | 264 ++++++++++++++++++
 .../trail_detection_node/jpu.py               |  68 +++++
 .../trail_detection_node/model_loader.py      |  96 ++++++-
 .../trail_detection_node/model_store.py       |  36 +++
 .../trail_detection_node/segbase.py           |  60 ++++
 .../v2_trailDetectionNode.py                  |  43 ++-
 .../visualizer_v2_trailDetectionNode.py       |  61 ++--
 33 files changed, 597 insertions(+), 31 deletions(-)
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_store.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-37.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-310.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-39.pyc
 create mode 100644 trail_detection_node/trail_detection_node/base_models/resnetv1b.py
 create mode 100644 trail_detection_node/trail_detection_node/jpu.py
 create mode 100644 trail_detection_node/trail_detection_node/model_store.py
 create mode 100644 trail_detection_node/trail_detection_node/segbase.py

diff --git a/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..96f976eaeff4e2dbe8bba73d606c4b100bf72eb2
GIT binary patch
literal 2452
zcmai0Uyl<v5VzOfKiMP)rB^r*l_+gdqqcYDpbu?PRTT*;1SeELt@5(kTRXXh&2F$a
zy%Oy`9aW$1JLFy}@z8J4&(H_I_9<VX5~VZFh6L^qj&^1|p0#JkGrvjEZifWMPk;X*
z{sieCoGcFxlkecsKLZh@O9T~8M!VE<XTZ9Q&UAdh974&!?RubLecJVJ62XQ0ln7U{
zhrvGUHbCPE1{zjtLgCya9e=!bt4Q<m!rdn-9;D*JgQ1QG!z|7FQ#hAw8FuULg9OFp
z;nfp;6$DAZDbjV&G5f<Kc+dNt^r&^C(RJZ)|0(H$j+3qr2M6ZFJvoe3yq(GGMgGgC
zm@?RFN`c%+8uk9jP{vT<vc3(ZBqgoLzB6$S;j>FPtD^8@6|daN1IZWkAgD;>RzXGg
z!8Y=0EAS6i*#QTgF9`U-w>pmT`l=WWwc*=otd$FAbg1%?1;*8*p;QV_H$fDod0Ix1
zaq`@FGrtW_z<=Xx=cX~lSnj4;b{d9jne|MN=EE$`r8Zv8n~$W*WftjlERCm2l?rM6
zVJrj$-2@`d;xa9Ad%g+tLJguUej?Q~Y8p|LWU<y!^o;y_XJe-r$c^z%T!<p?Z>U0V
zM!R}rdz5Bkqf~L4MM9P`!QG;~5b}8C!{KOs_(aXatONMc73Vw+=^7ocy>?0K^9Upk
zn9T>u7@+I$=!-xqG9eW`q<awj30zJsIkiL~@N}!gR10iX8_5cgj-yThGxS$=7Il`K
zLyg}n)NZWAJ20^hhTvXEIUS#Q-ND-OS%9~d#{&ts6-LpZ5Tgv`RunxR#o25{VPcu)
z_i>r*Y(b<qg^hzckLq?E?L=l-6fL=Q238gNWwQbUr*WTvcr>6ZFHZVapMdI>ffbEI
ze+FbxG`3hATPzM#C>D#Y-KApj6h=5DK$H0{xD#e7p4@~---pt9y)-5q65p)=GtQC<
zi<9Br2QCzgvrkJl@q~9s4;hvN%;whqTdjj7>)@@{4QmaEQ#q@1KhTrLfp?52%_G*K
z2;XSkI%3@v%{N-Nk65=v>y6ec79!eP(-$xlM&5$M4M@~goFGKppZ*7n)8{}Sp{@G8
z`Pvk(ZHn(rv8p;J6f%36vplou7v7VPM=~$dI8%6&hW{vUKQJ!B%9k^Cb;hpDV5l+2
zh|A`sxVaFoEX1oFcUDr(G>?*<I0xX-#@$UtxuZ_wS>7Y4tG-q?r(YJF^$s&!{{Uo#
za_2O~<o2F(evITEqdQ_3J|DNBmn;wjp?*FvlQEh%;n9BqnIQ<~?O}}}!l`9I5y4RI
zvpvWtw3)C&?0Doiu-RiJhn$COhrDFMwjKa{m|r9H3cUTw3WF8zp$|3z<fOC5?Tk!<
zirdp0H4kgvMBe9fYw#z89jU-dfR+c8_c&l&b4z^)-=aQ3@-dQ2KuoZmLW7mDx(~gF
z12Rd|j<d86S5!c2Q1cdKm`Dc-!_;Z1Pw{m`4)r<i!EO7XHw@ftDb=umt|5(E7An~>
zEQw3Cj<y>}zCdyr$UGZ7XiB3J5}_yKQme0E$#9gHK+fVD;@~&%=u<#Gp{w*9{8s2C
z>QL{+8XGt9LTkiT?}N?K1`CwLD!|mz__rY-tMudtou=`lNE8VG>ow4tz<R!(=QBut
zcRpS3jdI(;;>?5#S$&N!!4@%Mv+?d&c(>&-D=(YM3xZ!`f@`xb@GXW^W5?knpe=fe
Kdd?|!`sDvy&pjjn

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba624d87e89303e64e1f29b1fb1b3dbf84126f4f
GIT binary patch
literal 2441
zcmah~-EZ7P5a0FMKHpbT+K_%wAmssid?X@G5rPV#R!XJPMip%Y@{8qo_bzUI_I1}s
z=*f9X5l{IaE-y$t@L%vZ@UX8u-M@gu$IRN!g|t!E^33e)cy~NI^PAh<Zi~S9?vG#i
zZy^1NlX}=7d=0Pq9tbBs;gnkm^{L_3kok<3I(x`0LdnqaUC^)r^&58yx4H9za7VBw
z-U0KQpm8|^4XZRQZapHs#^lnyEKc*4htFj=jQPs;NQJ{u5~qV1oJ+PeyZ3NALa`oh
zC8!M$1ObPLZ=qA>!R_t7`!nfN<3iJS;NZp!;)Bj6egh8m^x`8i3T3#Hh&x&O!#bZa
z*lR|CY(~v$f8-b*TvGRe<RqsBIk2YI5&Uir=M)qkR@jA8xF9t+J@g6^IE7cx1F#L;
z$_jjgRd#5DuE7cTU~ly-?G9u%9w}|_#G#T7oYAAQfy~p68jpmOc)Iq2AWq{v2(*=^
z+AV$7b_Bj_YbVvs5yo&YR-)I`wh~F-_u_PvgsD)zTXNlgDr72>K*bZGU6sq23*8un
zoI|j+$Kxc-<197j>sFe{VUUE+h3rw?41y>Ll?sAi$zR{B?Pf!<HrWj`o~45|nW^<)
zPpv5#t>rR|lYom{M7URwW?Z~l`D8R+9X*$Ikd+7jNvs8WmA2^Q(y8lNt^Yr=&<qB0
z49y*Q)q6k+G9?8)qWci`DO^h>S(QW~<aDdYWCv_z7s&#Uo+TH7Y5JpFMx7xSQPb#W
zaxawp4VaY9fn)egE}nL-vV=Q>drHHhfO~2M!7$_F1m#W;JR65exgs&8bo+LgN4r}P
z<8^LgATOi3Tg5pNNfHEemmn+NgmsCYnT)`&DJ%q!x^&q!x(KGn1FIK@`WVQ(NKA29
zrZ_C9Ml23frzeWTl^EL?BOKMcU}mD<ZFtpVD3jBrFts7kodU4oGAXbS8SZ=NKyg?H
zG-p$nyGQhhVfw?Ywr;%E+B;$Gz1F&EtN~dHYpM1FJ!u}gukfV(l68x>&b02lWZmZN
zGp)NXS$BBnOzQ;$3Ei#Pzc3_5-GIR+r002@AS67V{R4}$zkxs+8})^HZH8Ai!|!HT
zN4-Uf%v@xdT_)*TkHoXFNb@*MB;KU9zZLhlwSzEnvt%13yHUbUv&Mu^^|81<7jMkP
zjh<5$QaetAXg5p&Xq0yLVxI5HB|OW03e_}FbtWGdn(^-nSg0?65V~O5bQzL*fu7=L
z=_|WQ2l~VuClJbUVCG`<?!v2n2U6k$=IK#|6x^z0zzWV#9<Y7LAhemXBkW}4C$QOP
zxeYlE*$sKfxM?c@=rF%UsulS9e=7`D+$RmN@gN7SecQ~))GKUrdb8rKinoyu?AjXq
zX~B+^W9CCU18VneK(h9hd>8&jt{}OF1R+p+J25m)5z5EVTWr7|p}S!c58z5NfPPuG
z7|nP*lo+C3M}B~xUq{lzJ#5n+=%$97%!M3f&=rJs@=Qj%nnhtQKSbM)kRZ0mPk_|7
z??TfV=gN2bBFvS%2}{0>@*K)a3`4a05?*x<2%*>M61@V?0)3x))})PBd5o$OvqQdx
z<SG)(W%)J|L_q_b@*R|p5xh<^1D9ADc$~uW@aWRDURyVUfM*dP?B}4<p82`eG%d0D
zLOosWk5kje!bG>`viuA`f-OP>Y3)8RIBzPZthi%8PP7y6R@n}|!l)~3LN@hihn}}w
HcK+OdIXN?e

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc
index 9b9029ed969ff988e7ccbe4405900b9c4afb469e..40bfbde6c5e6e7fef1fc9362c1c3bcd7a5d67f7a 100644
GIT binary patch
literal 6824
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

delta 1114
zcmZuw&rcIk5Z>4Q*>1a(QlLN)L?Nz31O#IuQU#QFpo#HkysTw+DVSxK%(m#oc#yLZ
z-w7`s^=QJ$gC?HzUvO_8Ie7J`&OAt~#!dFin|brTnfczlx3eGnttgkvNceq!^3{7|
z?OJ8#?T(+hu`GFtr|w9e>a&OXGx@%O9?jFyqaS(F=rO!BdeTRpjK^+DcIJTiss{|w
zW{J98uTPzKcRP#wL+lId%b^=Af({DkPSm)$<pU@$<q@Xw6Y}*Eg(TWy6mCy@?NG?`
z9eJE}@ptkIwSXbo{#B*MX6#g=Y(}1+<Z8i2J#^d%LLXu~2Yr;KpJ0GMWTvEG@kAY2
z?4o5JAyFI6t-!ZCV3;iS_@9%B9yJ?V%|@IUF|zy48i?YNr=l&CP7#j)n~v*i5j?7a
z*U$H~)my#fG8bwMcfA_HCN@N+!zFU(9LEi6aqRj*;5dgAf@h3Ehzt}275`X6Fr*U8
z7eV2lGK2epKER&R7U%?YiI61_ZBkpPKqont2t-!Vu}o%>fH<L>pogGL&^isr$Q&XN
z<+K_UR2R@67r2)Guz4Dnb{eKAQZNdNvt&*ZOcS)UhI44zx=<QsXiFRv7c@)eMS?kk
zzjYOoUE`CPsRtF>y-aWgA<-Sji(C|tw1x$Omd3D1W}8X0B9tXnC}B*Z8Ir=Zl)|iE
zc?*_M-zqEfy!o8j{IyvgtH0W#?|lXP6p{+5L=us+L`equH?z!!`A>6T;v_jn5fW=7
zZ1~`~>$NcSgZO`1-sQ{L+v7H?+6-3kjGg*Jop$M>YMPr>{y95XnWq%(-F9PC+a3Im
zMy9~>rnp+$OpHbZ?)pR+LNEW(H+qjQDUtDk0u4o?twdfk@Ws#_PL1fZokXm}kQ;OO
X<S=%gUb&DkD-~Fl6;g%Cp5wm(5j@cB

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..382efff7be9cea03567df6d79de8c371fa85d9b9
GIT binary patch
literal 6861
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
B!W#ep

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_store.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_store.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4409cd4cf47bbd56aed593a3913a42d34600acbb
GIT binary patch
literal 1425
zcmZuxzjNC*6b3*_qGU%-oHnVi3x^KTV2b)d+v??Vy=yxrm%FqbbnWpV0yODRgbF}*
zDpMV5ckI-EARhBa^dG_6DO=}EeV}Y7%@sU6;sJQXd*Ang;?A88f>!<Y4}0z+^tW|B
zYz{bIL08{_VQ7jNW~9J#G9}oKox+(q_1m4g%w>&ZGHtLXYh5DdeS<FWw8`4j7VAts
zw#BwD(X`EWSeG>}@wCI77pQl4wf|HwUieB2$^Ek|PcnZY#c9sCf&tf(<|SwT-0o7r
zTSx@;u<0&jUg|hqmWj?q`OI{WxsK~iahez0>{wrNRl>_oB-ln?H(M9fi@t`g9)QVF
zg??)NNY;2wDpKJ;$<O2kdV^#G7JH5%L1?@r<H<|4oEx{Kb6zji=H2)GOw4(Il~KV&
zdEA#m4dXM_pDpu(^=$=3%(&)ts&NUG{Qu-8{Thj2@r&s^W_h9$F<(4s+e8VN2S{4V
zdQOj+N5d!?&!TV=O?Vm($7zy;Q8*loXm~I?7>ti5lXNnkjhOK^Kty33MWaJL9y2~k
zj-pXY!$C9~91cg}gbp}A<U<znF&|RX-b4+;fej1Uc*G7SN6EnfO*o~)SrS4_8bv&1
z>@ZEov%z>o)7!9Uxbict7wXG?KcnUGDht#opmVwsB|TFC6xLt$&Lv-ncqxlDFB8FX
zfNw)}|J>3RTd3E;DqsAEKuhK=fseqckVdCiZfnf&38@exf8Y!J8`iM02hwHE?_>{w
z;M`}c{pTOa%1?##&+C)?T=}KYK0O7}=&azu8!SCI;H@>Fgsp3lsf-Rx=LcFW`L|LE
zX`1knIo0wW?0c^bX_+$}l?kcijH>KD_^JuU!*}74R(<bwe(eXK|0KJvJ+V~ZG%G>d
zYq3sY02SJLaRnC)>LhET$%*sYt?(6I<9ghva7CE&5M7bAqnj3kwOg;WD(4EzFDkfv
z+GFl(Wc>>a*V&@ec(%H~0b>9Bea`D1sWGUNUAe(RXRFVj*4Nf@<e#r^U`xfaWI?Yj
zKZQK&?S=?t+y&K{>F`$zTC%0$(zqugFQo;;H2JGsX=NJqmF_j_ql_zs(58K>f$L%Y
zp|%CTM)M<}rPah9bkzm3i?{JE@xZ!x*Xd#T5GH$DrWMCbBynsyG5kREQt~*K7IFC*
z7}El=*<<ZKS`@HWr+M#2pYT`NC>FE;x{a@Sw?x+Ge~^=<ZKDA1F{pZ3@F!Ne>Ju<7
S+QuGa=aDXPn=ba8Zu4IxGJEL&

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c382683ae99ab55aac4a2c2309d76d554616133a
GIT binary patch
literal 2194
zcma)7&2Jnv6t_K}yO~W>NWa8~MruVEXp(NyNGL@JQBfpRqC&!DIE*H1XEV)=XYqKG
zc9~q-O1<$Ha7YlB{taCCC*a^Kr`$Mm;@La9*;GB?m7m}9duu=c-p7=kP8-2^`1?Qf
zPY<ELwJ<wu5I%=lJp@8gj3}lg#|4QAM%1EqZWVTH8{WyC!j0X+i@m~+eb{sRIBtD~
zs7KuwATjc|{oIP@DA`7lKf3irTCwn(lCnJ9D@C}?ij>Q&2TZ?UT&6NB`5D}cw$3on
z2rKLBN8d-53IwY-lN)!E!)~QIW2t+mdqLb-GhzUz>5I%gJ$>5j(C^cu+62N-jNy%h
z;@F~{muL@D2Rv`ZHoU-pfntZYXd70S&d~r??<KNP?89s31)zsUfBl~)wc8<#N2y2)
zCYh*=xI7(3+)aB2yCrAgW>`s)@xIwL{}XIkiZtVlhBV7l3G37vKshSKK`5UNSok4j
zd+9Kjn@bb8mhOe;{O#$H%^m=_6ha&(;>Oxiv|@~uKRMySPS4eNHN%J1fjI}W`U8kW
z64&TCIU%PAquLg86mv+KW3MJPN~{{RiCtUNIw0bvbm&~|)E>2eA+`G({#k2Xz65#)
z^y|`lqy8G`UC`f`{u}k4Y*Fu|U0bL4Iev!0iy!1%A5s5T3?YROW_WsAK+!fNHr#8t
zDA;<iBlNQ(qS^z&8mN`mV69ryY@4zhYoo;>Kj7sNpN3*H{OLHd&JaN;gCqe0hbreN
zqjFz#;QUu8>L{lg4wx{xqx>YvcqWrXS?TbJa(ORLt4in$6)jCP&_biHg71b<C<Xgc
zh*BsQil<1Wu(Zm0JQzm4vMZMFiMRDX-qPFtBt^tkEnYf*S+Wboq1=O`RP-yMyTL20
zT1jGVPZDtncK-c#b-ygw>S#YLY03MmqO8`EqiS_`nB{a;W0WTplDVf#HsMgxZ{Dm}
zUthN}cq%T#xr;EX>p<plfL-|c`1*9tliOr;Wwv@(CJ6Na)#=cP=y@Mz^$bXj9-|Xn
z<5PSL`2;+f;UNR3`}Pd)7#?yI?A@Axjb(UGXVI~3c)zxRcYtq+do?;~K~7t>T|1}t
zHk$Bzz(;uWJ_H3IrBJ#dfIThQrb45(iK%jWB|q#cYnOMGEm%HOUXeZ-lx42mJblVU
zw^`Skb-h{dnm|UbxCSp)_=zIDF3dHU>oD({xQ)qs+9J@nCyi6LG*mhf0uli7=RcP$
z;DC&7TtI#HpBIqVQP4?eke>$zFhLqeif=$wMP&35J52K-G;%;;(wmMlxgTbHFqBo8
zavDlVJSHpAw0N)aF(T$^;sZGM^~d<lvFt7=EA7Vo>!~uaxZtpMcIxoEAWR%S)`7<&
zsG;}YKp^Qa6xka4M8s_{HFXqO=T0db;!0n4&8Dm<KLPtnH<7l<X&a9&UqDpbz){-b
z!A{iDrO)AG0HxnflA@%;T=PMa{5VYWM&l(3EqhRqx^TqDnk;Lw3Pg39dhM}1Z)$ez
z*gM)pCxGcOy1J_Xh>vVM-|`pyg#|kb#5!y#UzVb`zrwj9oSW<#ca$q8{@@kMtCex{
yJM8X``_g$!0{2pVw{qb_3;vt?X28*H#5kh-PscC(Ob6U}V<X5wvWQ)B)%p*|pC~r~

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67f274335e318efe69eafe900ba2a1d4da495e86
GIT binary patch
literal 2155
zcma)7y>A>v6rY*>yz`wCAPKRA&;mhb5wUYlEFpss3c^SzI1w?;Hmmi{+<D{uIA-ST
z<XAT(N;+B^3cIAGg?|HzZK={xQ}N#1-r0##FsJwC&Ai!}_kQo=Zuk3L0^`o_|L{LO
zLjK0ZeApm-4y5h?<0K-Sa+cGAMT`<|aXYsPJF<=J<WAv6ZsA2<;YU8~xg#2Nz9QV?
z?h{xE_MrRNik3LLPeOls?RKI>@J+=<9t<lP+!sYs>MR9eRESb1I;+a(@GjYTPJxHC
zvA(|dU1&8uDO4%+=8gDppql<{HMlW&VY#_smOZ!)A2RQxc-wrSZ#dKzFhL>;{xMD?
zi}#<AA>|HO-HB|l-hV<Ohj(}vW|uGV9?ae|Vw1=RPnIR1My7xLA9uRl0LHyUCWX*K
zDzm)47-qSbqz8LdDT1v)X_=KHvunPS;<}beRtg^QEKfAdi_-weQ6&!o{b($L54ad6
zlU#4D&Y@cUBsh~lT3p%g0eGtc#9+SM+*l3Q%%R4g->|)#x`-DHAIJe(0#bhf(?rvn
zJZ2~Clu%OJ@(QOV<Lub0SxsWA25oHD7Pk(V+}6&J)K2Yj`xjQbKeL}u>y|s9cR)YX
z-YfNMpm#z4RQs>gFY6BXPP(;qN*~i7DOmBFUgACmZe&3~LC)yxJ+O_yn>|h-fW4jV
zU5PG*tm%%WXd!OA7UQV1$gqXDxiP&oDG$o(s9c0#EBN6!BaDy?QUe%V**HfT*ZX0=
zanxiiq)C;=kK?S&bR0KUGI`jzWtt~SNlZxDL5A2$1iR^dJAs-g#FtW5vT>nKibP8b
zRn~*?B=j3wiF_z8;1|od?awnpzK+WaXAZ@CPzQ~BaFocAl34UmQk^(9ugCGP<lnpN
z`&A*<r~668t8%n1E42|HsdXjObwnkPIizihg&CJnxUb$+VuUZPjUUNAJaP$0T?Izy
zGVM_pem=cAC$`L{m(SPe+8mq|kTe5<K>7kmJq1>i2jqm-^pqY$=77x3$&hP{efym3
z7#Xq=&bu{(GnSD(%$H-^$bM~u?10>nhc!9rK=xX-T|1}teKMDaAae?N!=`UTJOE7&
zMH&Fki{fl+aVPAWcs5R2m4}1K+A9Z*Ek!<o7MVO8S5+RldGbieK|61>^UZd?Wr7&G
z@(pmip${9D4uCd*ZUWtsi0h24;E5grAGcOrgB^7R7-2mC{@jnb^dg(Cya4<8FBi~b
z2r$_U^q5`%3PB(_UBS{}(+|aAl24#l0|fIHbd>4+AS=fct%9WFfrf+=TFJJHd#!yT
zGj7SZ;NF)V@!M;~El?_x2`}f#{KUdoG<0DsUOG4S7^6<*)f(FS3V{{=0kNH#Jxsof
z@1t{}b!JdwLqPe<X4za6)yHsDVZR`>Ym#~T+6zeH8Mq2hZ1090EcX)nJ(PPlj*E&<
za+G^<{QV@!Ta6dTyh`KPRE&HFK9%nwdmmWSZ)-Fac@9SwF%PMH6AxkNO=rQHR>*wc
zX3H1-i@qK9WC$CLuPd4Eua#xP%F<+&=_1i(6L+vm<Z5l!=MD#ZvtD%8hQPc8-)>y^
g9|il(YiEYcB$I*ur!x;f!(ba*Y}$kTyTn}UKT@J0bN~PV

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc
index da38997b960fee7a3d0a12059864382d75072af4..0b071b712413254dc114f8b93e995c0381dd323d 100644
GIT binary patch
delta 3172
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

delta 2360
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
ajdu|UWKRs&PU@;$&Z*i3HKP&bzyAS<*FEF_

diff --git a/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9ab1214c86a1fa1160d2075f0d950f2c09ada13
GIT binary patch
literal 5925
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
TmgU(6HfuTq2Yz@qb=dy_<UyAR

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc
index 1e2bdc9339a34b12ccf04eccec095a727c47c602..e52eba826c071582ef28a26f2cb32d392f97438d 100644
GIT binary patch
delta 3514
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

delta 2893
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

diff --git a/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42bf6d0e28b9baed1955ee56f4fb47a8eb85cc1d
GIT binary patch
literal 8356
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
VN9`H>C+vznUH&QMvQu=_{{{~wpojnf

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7415bb9207466ed09c1dd577d6510c09b33f3166
GIT binary patch
literal 330
zcmYk1%}T^D5XX~NYn9yxsj!BHJ&O1QA}9!Z3E5<518q_=ao6<?d=bGH@{p@1U%``8
zn}ajt|C?`!UoI~g+0*B{c_V&J$$u*-xuu6262lDd+2c%}S!9-(Cz+?j;(;~gH>cHx
zCw_U?RH-)L5FEr*1wi8VeCB?=OXa?8w`Tx2PL29S!x*i1A1qXK<4=ALqVofY*G_rk
zT`TS(pm(a5&PPBIgR;Fe5J69?LLC5UeuXe77p<nC9l%93bywpt`k*_ZeE>0d13ikJ
gLXbI@(mETZyc&<GzNX@H4>!|)a6wYDn$N!AzgYHM@&Et;

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e121f62b7173ff67fdf64749444896d236734b9
GIT binary patch
literal 328
zcmYk2T}s3-5XYNVYZdk&71kj5DB=l3P!RSdWRsx{q)ExdUDq3U5y1=jkXN6)f=^D|
z2s>f^zxl`nGIFsvtH_={-}M{uD<_9mQ*uj=S0uX9%vO(kvckHsDLg7XCe{yC-+VI~
z?O9^ycYT{W4GzIUOl<%pu1@#dT&`2I8HUvf0M5D5y(pNY@$RDvExqw4KU+Tf3Ha+M
zz4mV4_YlxKX@&C<kjEg66&fO_Jj&%3knS%LCh4M46buu%D06o?@1hTC<jM!&lh<I8
fuO)&gu@J_YD8$9QOWidUpDo<v|6pEQ$NtYRjR9QN

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9952de504bb156c9b825cd00f3ea507fc3c9e57f
GIT binary patch
literal 8119
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74ea74f7d05a50eeebd37f728fd92120c8dadc2f
GIT binary patch
literal 8190
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1bbf58a3706ebf6a2e2d3cc65896c32c3cc20b87
GIT binary patch
literal 6119
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
Z@^fwSd3xJupKm|lZMaTL-T9dR{x2Muk&OTV

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f39dc03db1d4fd716496a926ccd870fbd52f16de
GIT binary patch
literal 6085
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
Rrc=}RO|MoR7jDUB{{^Xxk~9DS

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f38dcd9fc94b313126c383baa111a3da547799e
GIT binary patch
literal 6189
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bcd9afc6b852a07dd136dd5631f403293612cf59
GIT binary patch
literal 6424
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f4574627b35a4711eb4d6c789b90ac795bd2b7e
GIT binary patch
literal 7205
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
OyZDI#)1@Hulm7!H6F@)!

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-37.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc7b1329892392085df974a496e69809b2460bf5
GIT binary patch
literal 8293
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
I1E9M90`fKWO8@`>

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5996a2eb7ccda4dbdd2d28706da994d6f8e1b79d
GIT binary patch
literal 7945
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
LpY9sHKxh90hQ`>z

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60bfbec7ece515c2213c7247625275dee4c7797c
GIT binary patch
literal 5493
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98225cbc36f655be44cd3ec2a071e38164b0bf57
GIT binary patch
literal 5965
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
SP6NOHm{xjh-w!UsY5G4q6q^|U

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bed5e6a80a177186b91ff9ccd15ab7be6f316389
GIT binary patch
literal 9518
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

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..85ec7e51a85d7127e84efe3e6a46a28b659b8906
GIT binary patch
literal 10103
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
X)r-~J)s1ScI#I1wUn+Y1dFFosldSwi

literal 0
HcmV?d00001

diff --git a/trail_detection_node/trail_detection_node/base_models/resnetv1b.py b/trail_detection_node/trail_detection_node/base_models/resnetv1b.py
new file mode 100644
index 00000000..21d67b7a
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/base_models/resnetv1b.py
@@ -0,0 +1,264 @@
+import torch
+import torch.nn as nn
+import torch.utils.model_zoo as model_zoo
+
+__all__ = ['ResNetV1b', 'resnet18_v1b', 'resnet34_v1b', 'resnet50_v1b',
+           'resnet101_v1b', 'resnet152_v1b', 'resnet152_v1s', 'resnet101_v1s', 'resnet50_v1s']
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+
+class BasicBlockV1b(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None,
+                 previous_dilation=1, norm_layer=nn.BatchNorm2d):
+        super(BasicBlockV1b, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, 3, stride,
+                               dilation, dilation, bias=False)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(True)
+        self.conv2 = nn.Conv2d(planes, planes, 3, 1, previous_dilation,
+                               dilation=previous_dilation, bias=False)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class BottleneckV1b(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None,
+                 previous_dilation=1, norm_layer=nn.BatchNorm2d):
+        super(BottleneckV1b, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
+        self.bn1 = norm_layer(planes)
+        self.conv2 = nn.Conv2d(planes, planes, 3, stride,
+                               dilation, dilation, bias=False)
+        self.bn2 = norm_layer(planes)
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNetV1b(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, dilated=True, deep_stem=False,
+                 zero_init_residual=False, norm_layer=nn.BatchNorm2d):
+        self.inplanes = 128 if deep_stem else 64
+        super(ResNetV1b, self).__init__()
+        if deep_stem:
+            self.conv1 = nn.Sequential(
+                nn.Conv2d(3, 64, 3, 2, 1, bias=False),
+                norm_layer(64),
+                nn.ReLU(True),
+                nn.Conv2d(64, 64, 3, 1, 1, bias=False),
+                norm_layer(64),
+                nn.ReLU(True),
+                nn.Conv2d(64, 128, 3, 1, 1, bias=False)
+            )
+        else:
+            self.conv1 = nn.Conv2d(3, 64, 7, 2, 3, bias=False)
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(True)
+        self.maxpool = nn.MaxPool2d(3, 2, 1)
+        self.layer1 = self._make_layer(block, 64, layers[0], norm_layer=norm_layer)
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2, norm_layer=norm_layer)
+        if dilated:
+            self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2, norm_layer=norm_layer)
+            self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4, norm_layer=norm_layer)
+        else:
+            self.layer3 = self._make_layer(block, 256, layers[2], stride=2, norm_layer=norm_layer)
+            self.layer4 = self._make_layer(block, 512, layers[3], stride=2, norm_layer=norm_layer)
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, BottleneckV1b):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlockV1b):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilation=1, norm_layer=nn.BatchNorm2d):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion, 1, stride, bias=False),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        if dilation in (1, 2):
+            layers.append(block(self.inplanes, planes, stride, dilation=1, downsample=downsample,
+                                previous_dilation=dilation, norm_layer=norm_layer))
+        elif dilation == 4:
+            layers.append(block(self.inplanes, planes, stride, dilation=2, downsample=downsample,
+                                previous_dilation=dilation, norm_layer=norm_layer))
+        else:
+            raise RuntimeError("=> unknown dilation size: {}".format(dilation))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes, dilation=dilation,
+                                previous_dilation=dilation, norm_layer=norm_layer))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+        return x
+
+
+def resnet18_v1b(pretrained=False, **kwargs):
+    model = ResNetV1b(BasicBlockV1b, [2, 2, 2, 2], **kwargs)
+    if pretrained:
+        old_dict = model_zoo.load_url(model_urls['resnet18'])
+        model_dict = model.state_dict()
+        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
+        model_dict.update(old_dict)
+        model.load_state_dict(model_dict)
+    return model
+
+
+def resnet34_v1b(pretrained=False, **kwargs):
+    model = ResNetV1b(BasicBlockV1b, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        old_dict = model_zoo.load_url(model_urls['resnet34'])
+        model_dict = model.state_dict()
+        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
+        model_dict.update(old_dict)
+        model.load_state_dict(model_dict)
+    return model
+
+
+def resnet50_v1b(pretrained=False, **kwargs):
+    model = ResNetV1b(BottleneckV1b, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        old_dict = model_zoo.load_url(model_urls['resnet50'])
+        model_dict = model.state_dict()
+        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
+        model_dict.update(old_dict)
+        model.load_state_dict(model_dict)
+    return model
+
+
+def resnet101_v1b(pretrained=False, **kwargs):
+    model = ResNetV1b(BottleneckV1b, [3, 4, 23, 3], **kwargs)
+    if pretrained:
+        old_dict = model_zoo.load_url(model_urls['resnet101'])
+        model_dict = model.state_dict()
+        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
+        model_dict.update(old_dict)
+        model.load_state_dict(model_dict)
+    return model
+
+
+def resnet152_v1b(pretrained=False, **kwargs):
+    model = ResNetV1b(BottleneckV1b, [3, 8, 36, 3], **kwargs)
+    if pretrained:
+        old_dict = model_zoo.load_url(model_urls['resnet152'])
+        model_dict = model.state_dict()
+        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
+        model_dict.update(old_dict)
+        model.load_state_dict(model_dict)
+    return model
+
+
+def resnet50_v1s(pretrained=False, root='~/.torch/models', **kwargs):
+    model = ResNetV1b(BottleneckV1b, [3, 4, 6, 3], deep_stem=True, **kwargs)
+    if pretrained:
+        from ..model_store import get_resnet_file
+        model.load_state_dict(torch.load(get_resnet_file('resnet50', root=root)), strict=False)
+    return model
+
+
+def resnet101_v1s(pretrained=False, root='~/.torch/models', **kwargs):
+    model = ResNetV1b(BottleneckV1b, [3, 4, 23, 3], deep_stem=True, **kwargs)
+    if pretrained:
+        from ..model_store import get_resnet_file
+        model.load_state_dict(torch.load(get_resnet_file('resnet101', root=root)), strict=False)
+    return model
+
+
+def resnet152_v1s(pretrained=False, root='~/.torch/models', **kwargs):
+    model = ResNetV1b(BottleneckV1b, [3, 8, 36, 3], deep_stem=True, **kwargs)
+    if pretrained:
+        from ..model_store import get_resnet_file
+        model.load_state_dict(torch.load(get_resnet_file('resnet152', root=root)), strict=False)
+    return model
+
+
+if __name__ == '__main__':
+    import torch
+
+    img = torch.randn(4, 3, 224, 224)
+    model = resnet50_v1b(True)
+    output = model(img)
diff --git a/trail_detection_node/trail_detection_node/jpu.py b/trail_detection_node/trail_detection_node/jpu.py
new file mode 100644
index 00000000..db23bab8
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/jpu.py
@@ -0,0 +1,68 @@
+"""Joint Pyramid Upsampling"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+__all__ = ['JPU']
+
+
+class SeparableConv2d(nn.Module):
+    def __init__(self, inplanes, planes, kernel_size=3, stride=1, padding=1,
+                 dilation=1, bias=False, norm_layer=nn.BatchNorm2d):
+        super(SeparableConv2d, self).__init__()
+        self.conv = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation, groups=inplanes, bias=bias)
+        self.bn = norm_layer(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, bias=bias)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        x = self.pointwise(x)
+        return x
+
+
+# copy from: https://github.com/wuhuikai/FastFCN/blob/master/encoding/nn/customize.py
+class JPU(nn.Module):
+    def __init__(self, in_channels, width=512, norm_layer=nn.BatchNorm2d, **kwargs):
+        super(JPU, self).__init__()
+
+        self.conv5 = nn.Sequential(
+            nn.Conv2d(in_channels[-1], width, 3, padding=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.conv4 = nn.Sequential(
+            nn.Conv2d(in_channels[-2], width, 3, padding=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(in_channels[-3], width, 3, padding=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+
+        self.dilation1 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=1, dilation=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.dilation2 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=2, dilation=2, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.dilation3 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=4, dilation=4, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.dilation4 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=8, dilation=8, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+
+    def forward(self, *inputs):
+        feats = [self.conv5(inputs[-1]), self.conv4(inputs[-2]), self.conv3(inputs[-3])]
+        size = feats[-1].size()[2:]
+        feats[-2] = F.interpolate(feats[-2], size, mode='bilinear', align_corners=True)
+        feats[-3] = F.interpolate(feats[-3], size, mode='bilinear', align_corners=True)
+        feat = torch.cat(feats, dim=1)
+        feat = torch.cat([self.dilation1(feat), self.dilation2(feat), self.dilation3(feat), self.dilation4(feat)],
+                         dim=1)
+
+        return inputs[0], inputs[1], inputs[2], feat
diff --git a/trail_detection_node/trail_detection_node/model_loader.py b/trail_detection_node/trail_detection_node/model_loader.py
index 908c74f6..6c8e2399 100644
--- a/trail_detection_node/trail_detection_node/model_loader.py
+++ b/trail_detection_node/trail_detection_node/model_loader.py
@@ -2,6 +2,9 @@
 import torch.nn.functional as F
 from .vgg import vgg16
 
+import torch
+from .segbase import SegBaseModel
+
 class FCN8s(nn.Module):
     def __init__(self, nclass, backbone='vgg16', aux=False, pretrained_base=True, norm_layer=nn.BatchNorm2d, **kwargs):
         super(FCN8s, self).__init__()
@@ -96,4 +99,95 @@ def __init__(self, in_channels, channels, norm_layer=nn.BatchNorm2d, **kwargs):
         )
 
     def forward(self, x):
-        return self.block(x)
\ No newline at end of file
+        return self.block(x)
+
+'''
+PSP NET
+'''   
+
+def _PSP1x1Conv(in_channels, out_channels, norm_layer, norm_kwargs):
+    return nn.Sequential(
+        nn.Conv2d(in_channels, out_channels, 1, bias=False),
+        norm_layer(out_channels, **({} if norm_kwargs is None else norm_kwargs)),
+        nn.ReLU(True)
+    )
+
+class _PyramidPooling(nn.Module):
+    def __init__(self, in_channels, **kwargs):
+        super(_PyramidPooling, self).__init__()
+        out_channels = int(in_channels / 4)
+        self.avgpool1 = nn.AdaptiveAvgPool2d(1)
+        self.avgpool2 = nn.AdaptiveAvgPool2d(2)
+        self.avgpool3 = nn.AdaptiveAvgPool2d(3)
+        self.avgpool4 = nn.AdaptiveAvgPool2d(6)
+        self.conv1 = _PSP1x1Conv(in_channels, out_channels, **kwargs)
+        self.conv2 = _PSP1x1Conv(in_channels, out_channels, **kwargs)
+        self.conv3 = _PSP1x1Conv(in_channels, out_channels, **kwargs)
+        self.conv4 = _PSP1x1Conv(in_channels, out_channels, **kwargs)
+
+    def forward(self, x):
+        size = x.size()[2:]
+        feat1 = F.interpolate(self.conv1(self.avgpool1(x)), size, mode='bilinear', align_corners=True)
+        feat2 = F.interpolate(self.conv2(self.avgpool2(x)), size, mode='bilinear', align_corners=True)
+        feat3 = F.interpolate(self.conv3(self.avgpool3(x)), size, mode='bilinear', align_corners=True)
+        feat4 = F.interpolate(self.conv4(self.avgpool4(x)), size, mode='bilinear', align_corners=True)
+        return torch.cat([x, feat1, feat2, feat3, feat4], dim=1)
+
+class _PSPHead(nn.Module):
+    def __init__(self, nclass, norm_layer=nn.BatchNorm2d, norm_kwargs=None, **kwargs):
+        super(_PSPHead, self).__init__()
+        self.psp = _PyramidPooling(2048, norm_layer=norm_layer, norm_kwargs=norm_kwargs)
+        self.block = nn.Sequential(
+            nn.Conv2d(4096, 512, 3, padding=1, bias=False),
+            norm_layer(512, **({} if norm_kwargs is None else norm_kwargs)),
+            nn.ReLU(True),
+            nn.Dropout(0.1),
+            nn.Conv2d(512, nclass, 1)
+        )
+
+    def forward(self, x):
+        x = self.psp(x)
+        return self.block(x)
+
+class PSPNet(SegBaseModel):
+    r"""Pyramid Scene Parsing Network
+
+    Parameters
+    ----------
+    nclass : int
+        Number of categories for the training dataset.
+    backbone : string
+        Pre-trained dilated backbone network type (default:'resnet50'; 'resnet50',
+        'resnet101' or 'resnet152').
+    norm_layer : object
+        Normalization layer used in backbone network (default: :class:`nn.BatchNorm`;
+        for Synchronized Cross-GPU BachNormalization).
+    aux : bool
+        Auxiliary loss.
+
+    Reference:
+        Zhao, Hengshuang, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia.
+        "Pyramid scene parsing network." *CVPR*, 2017
+    """
+
+    def __init__(self, nclass, backbone='resnet50', aux=False, pretrained_base=True, **kwargs):
+        super(PSPNet, self).__init__(nclass, aux, backbone, pretrained_base=pretrained_base, **kwargs)
+        self.head = _PSPHead(nclass, **kwargs)
+        if self.aux:
+            self.auxlayer = _FCNHead(1024, nclass, **kwargs)
+
+        self.__setattr__('exclusive', ['head', 'auxlayer'] if aux else ['head'])
+
+    def forward(self, x):
+        size = x.size()[2:]
+        _, _, c3, c4 = self.base_forward(x)
+        outputs = []
+        x = self.head(c4)
+        x = F.interpolate(x, size, mode='bilinear', align_corners=True)
+        outputs.append(x)
+
+        if self.aux:
+            auxout = self.auxlayer(c3)
+            auxout = F.interpolate(auxout, size, mode='bilinear', align_corners=True)
+            outputs.append(auxout)
+        return tuple(outputs)
\ No newline at end of file
diff --git a/trail_detection_node/trail_detection_node/model_store.py b/trail_detection_node/trail_detection_node/model_store.py
new file mode 100644
index 00000000..a0193c79
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/model_store.py
@@ -0,0 +1,36 @@
+"""Model store which provides pretrained models."""
+from __future__ import print_function
+
+import os
+import zipfile
+
+__all__ = ['get_model_file', 'get_resnet_file']
+
+_model_sha1 = {name: checksum for checksum, name in [
+    ('25c4b50959ef024fcc050213a06b614899f94b3d', 'resnet50'),
+    ('2a57e44de9c853fa015b172309a1ee7e2d0e4e2a', 'resnet101'),
+    ('0d43d698c66aceaa2bc0309f55efdd7ff4b143af', 'resnet152'),
+]}
+
+encoding_repo_url = 'https://hangzh.s3.amazonaws.com/'
+_url_format = '{repo_url}encoding/models/{file_name}.zip'
+
+
+def short_hash(name):
+    if name not in _model_sha1:
+        raise ValueError('Pretrained model for {name} is not available.'.format(name=name))
+    return _model_sha1[name][:8]
+
+
+def get_resnet_file(name, root='~/.torch/models'):
+    file_name = '{name}-{short_hash}'.format(name=name, short_hash=short_hash(name))
+    root = os.path.expanduser(root)
+
+    file_path = os.path.join(root, file_name + '.pth')
+    sha1_hash = _model_sha1[name]
+    if os.path.exists(file_path):
+        return file_path
+
+    else:
+        print('Model file {} is not found.'.format(file_path))
+
diff --git a/trail_detection_node/trail_detection_node/segbase.py b/trail_detection_node/trail_detection_node/segbase.py
new file mode 100644
index 00000000..ae417652
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/segbase.py
@@ -0,0 +1,60 @@
+"""Base Model for Semantic Segmentation"""
+import torch.nn as nn
+
+from .jpu import JPU
+from .base_models.resnetv1b import resnet50_v1s, resnet101_v1s, resnet152_v1s
+
+__all__ = ['SegBaseModel']
+
+
+class SegBaseModel(nn.Module):
+    r"""Base Model for Semantic Segmentation
+
+    Parameters
+    ----------
+    backbone : string
+        Pre-trained dilated backbone network type (default:'resnet50'; 'resnet50',
+        'resnet101' or 'resnet152').
+    """
+
+    def __init__(self, nclass, aux, backbone='resnet50', jpu=False, pretrained_base=True, **kwargs):
+        super(SegBaseModel, self).__init__()
+        dilated = False if jpu else True
+        self.aux = aux
+        self.nclass = nclass
+        if backbone == 'resnet50':
+            self.pretrained = resnet50_v1s(pretrained=pretrained_base, dilated=dilated, **kwargs)
+        elif backbone == 'resnet101':
+            self.pretrained = resnet101_v1s(pretrained=pretrained_base, dilated=dilated, **kwargs)
+        elif backbone == 'resnet152':
+            self.pretrained = resnet152_v1s(pretrained=pretrained_base, dilated=dilated, **kwargs)
+        else:
+            raise RuntimeError('unknown backbone: {}'.format(backbone))
+
+        self.jpu = JPU([512, 1024, 2048], width=512, **kwargs) if jpu else None
+
+    def base_forward(self, x):
+        """forwarding pre-trained network"""
+        x = self.pretrained.conv1(x)
+        x = self.pretrained.bn1(x)
+        x = self.pretrained.relu(x)
+        x = self.pretrained.maxpool(x)
+        c1 = self.pretrained.layer1(x)
+        c2 = self.pretrained.layer2(c1)
+        c3 = self.pretrained.layer3(c2)
+        c4 = self.pretrained.layer4(c3)
+
+        if self.jpu:
+            return self.jpu(c1, c2, c3, c4)
+        else:
+            return c1, c2, c3, c4
+
+    def evaluate(self, x):
+        """evaluating network with inputs and targets"""
+        return self.forward(x)[0]
+
+    def demo(self, x):
+        pred = self.forward(x)
+        if self.aux:
+            pred = pred[0]
+        return pred
diff --git a/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
index 309ab765..d3f96edf 100644
--- a/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
+++ b/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
@@ -1,5 +1,5 @@
 import torch
-from .model_loader import FCN8s
+from .model_loader import FCN8s, PSPNet
 from PIL import Image as ImagePIL
 from torchvision import transforms
 import cv2
@@ -98,9 +98,12 @@ def estimate_depth(x, y, np_2d_array):
     return np.mean(closest_depths)
 
 def load_model(device):
-    model = FCN8s(nclass=6, backbone='vgg16', pretrained_base=True, pretrained=True)
-    model.load_state_dict(torch.load('src/trail_detection_node/trail_detection_node/model/fcn8s_vgg16_pascal_voc.pth'))
+    # model = FCN8s(nclass=6, backbone='vgg16', pretrained_base=True, pretrained=True)
+    model = PSPNet(nclass=2, backbone='resnet50', pretrained_base=True)
+    model_location = 'psp2/psp_resnet50_pascal_voc_best_model.pth'
+    model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
     model = model.to(device)
+    model.eval()
     print('Finished loading model!')
 
     return model
@@ -116,8 +119,8 @@ def find_route(model, device, cv_image):
         output = model(image)
     # pred is prediction generated by the model, route is the variable for the center line
     pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
-    pred[pred != 1] = 0 # only see the trail
-    pred[pred == 1] = 255
+    pred[pred == 0] = 255 # only see the trail
+    pred[pred == 1] = 0
     pred = np.array(pred, dtype=np.uint8)
     route = np.zeros_like(pred)
     # calculate the center line by taking the average
@@ -181,13 +184,31 @@ def trail_callback(self, camera_msg, lidar_msg):
             print("No centerline found!")
             return
 
+        #filter points that have no lidar points near it
+        filtered_route_indices = []
+        for index in route_indices:
+            point = []
+            u = index[1]
+            v = image_height - index[0]
+            point.append(u)
+            point.append(v)
+            point.append(estimate_depth(u, v, points2d))
+            if point[2] == -1:
+                continue
+            else:
+                filtered_route_indices.append(point)
+
+        if not filtered_route_indices:
+            print("No usable centerline found!")
+            return
+
         # find the corresponding lidar points using the center line pixels
         filtered_3dPoints = []
-        for index in route_indices:
+        for index in filtered_route_indices:
             point = []
             point.append(index[0])
             point.append(index[1])
-            point.append(estimate_depth(index[0], index[1], points2d))
+            point.append(index[2])
             point_3d = convert_to_lidar_frame(point)
             filtered_3dPoints.append(point_3d)
 
@@ -200,19 +221,21 @@ def trail_callback(self, camera_msg, lidar_msg):
         trail_location_msg = PoseStamped()
         trail_location_msg.header.stamp = lidar_msg.header.stamp
         trail_location_msg.header.frame_id = "velodyne"
-        #position
+        # position
         trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
         trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
         trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
-        #orientation
+        # orientation
         yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
         trail_location_msg.pose.orientation.x = 0.0  
         trail_location_msg.pose.orientation.y = 0.0 
         trail_location_msg.pose.orientation.z = math.sin(yaw/2)
         trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
-        self.get_logger().info("location published!")
         self.trail_publisher.publish(trail_location_msg)
         
+        # logging
+        self.get_logger().info("location published!")
+        self.get_logger().info(f"Point: {filtered_3dPoints[smallest_index][0]}, {filtered_3dPoints[smallest_index][1]}, {filtered_3dPoints[smallest_index][2]}")
         
 
 
diff --git a/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
index 5055d3f4..da2f0696 100644
--- a/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
+++ b/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
@@ -1,5 +1,5 @@
 import torch
-from .model_loader import FCN8s, FCN32s
+from .model_loader import FCN8s, FCN32s, PSPNet
 from PIL import Image as ImagePIL
 from torchvision import transforms
 import cv2
@@ -99,14 +99,20 @@ def estimate_depth(x, y, np_2d_array):
     return np.mean(closest_depths)
 
 def load_model(device):
-    model = FCN32s(nclass=2, backbone='vgg16', pretrained_base=True, pretrained=True)
+    # model = FCN32s(nclass=2, backbone='vgg16', pretrained_base=True, pretrained=True)
+    model = PSPNet(nclass=2, backbone='resnet50', pretrained_base=True)
+
     # model_location = '32s_batch8/fcn32s_vgg16_pascal_voc_best_model.pth'
-    model_location = '500epoch/fcn32s_vgg16_pascal_voc.pth'
+    # model_location = '32s_self_labelled/fcn32s_vgg16_pascal_voc_best_model.pth'
+    model_location = 'psp2/psp_resnet50_pascal_voc_best_model.pth'
+
     if os.path.isfile(f'src/trail_detection_node/trail_detection_node/model/{model_location}'):
         model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
     else:
         model.load_state_dict(torch.load(f'trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
     model = model.to(device)
+    
+    model.eval()
     print('Finished loading model!')
 
     return model
@@ -169,7 +175,7 @@ def equalize_hist_rgb(img):
 class trailDetector(Node):
     def __init__(self, model, device):
         super().__init__('trail_detector')
-        self.only_camera_mode = True
+        self.only_camera_mode = False
         self.bridge = CvBridge()
 
         # load model and device
@@ -239,14 +245,20 @@ def trail_callback(self, camera_msg, lidar_msg):
         filtered_route_indices = []
         for index in route_indices:
             point = []
-            point.append(index[0])
-            point.append(index[1])
-            point.append(estimate_depth(index[0], index[1], points2d))
+            u = index[1]
+            v = image_height - index[0]
+            point.append(u)
+            point.append(v)
+            point.append(estimate_depth(u, v, points2d))
             if point[2] == -1:
                 continue
             else:
                 filtered_route_indices.append(point)
 
+        if not filtered_route_indices:
+            print("No usable centerline found!")
+            return
+
         # find the corresponding lidar points using the center line pixels
         filtered_3dPoints = []
         for index in filtered_route_indices:
@@ -273,27 +285,35 @@ def trail_callback(self, camera_msg, lidar_msg):
         # visualize after-pocessed image
         visualize_cv_image = cv_image
         print(f"{visualize_cv_image.shape[0]}")
-        circle_x = route_indices[smallest_index][0]
-        circle_y = route_indices[smallest_index][1]
+        circle_y = route_indices[smallest_index][0]
+        circle_x = route_indices[smallest_index][1]
         
-        # # visualize the lidar points in image
-        # uv_x, uv_y, uv_z = points2d
-        # for index_lidar in range(points2d.shape[1]):
-        #     # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
-        #     cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
+        # visualize the lidar points in image
+        uv_x, uv_y, uv_z = points2d
+        for index_lidar in range(points2d.shape[1]):
+            # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
+            cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
         
         # visualize center line in image
         for index_circle in range(len(route_indices)):
             if index_circle == smallest_index:
                 continue
             else:
-                red_circle_x = route_indices[index_circle][0]
-                red_circle_y = route_indices[index_circle][1]
-                cv2.circle(visualize_cv_image, (red_circle_x, red_circle_y), radius=5, color=(0, 0, 255), thickness=-1)
-        
+                green_circle_row = route_indices[index_circle][0]
+                green_circle_coloum = route_indices[index_circle][1]
+                cv2.circle(visualize_cv_image, (green_circle_coloum, green_circle_row), radius=5, color=(0, 125, 125), thickness=-1)
+
+        # visualize filtered center line in image
+        for index_circle in range(len(filtered_route_indices)):
+            if index_circle == smallest_index:
+                continue
+            else:
+                red_circle_row = filtered_route_indices[index_circle][1]
+                red_circle_coloum = filtered_route_indices[index_circle][0]
+                cv2.circle(visualize_cv_image, (red_circle_coloum, image_height - red_circle_row), radius=5, color=(0, 0, 255), thickness=-1)
+
         # visualize the chosen point in image
-        cv2.circle(visualize_cv_image, (circle_x, circle_y), radius=7, color=(0, 255, 0), thickness=-1)
-        cv2.circle(visualize_cv_image, (0, 0), radius=12, color=(0, 255, 0), thickness=-1)
+        cv2.circle(visualize_cv_image, (circle_x, circle_y), radius=7, color=(255, 0, 255), thickness=-1)
         
         cv2.imshow('circled image',visualize_cv_image)
         cv2.waitKey(25)
@@ -313,6 +333,7 @@ def trail_callback(self, camera_msg, lidar_msg):
         trail_location_msg.pose.orientation.z = math.sin(yaw/2)
         trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
         self.get_logger().info("location published!")
+        self.get_logger().info(f"Point: {filtered_3dPoints[smallest_index][0]}, {filtered_3dPoints[smallest_index][1]}, {filtered_3dPoints[smallest_index][2]}")
         self.trail_publisher.publish(trail_location_msg)
         
     def only_camera_callback(self, camera_msg):

From e51e85e6d2db72a1363bbbe501326ca8e5725059 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Wed, 6 Sep 2023 19:45:46 -0400
Subject: [PATCH 03/22] Create README.md

---
 trail_detection_node/README.md | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 trail_detection_node/README.md

diff --git a/trail_detection_node/README.md b/trail_detection_node/README.md
new file mode 100644
index 00000000..ceda4310
--- /dev/null
+++ b/trail_detection_node/README.md
@@ -0,0 +1,33 @@
+SETUP GUIDE
+=============
+1. Create a new folder named ```model``` in trail_detection_node/trail_detection_node
+2. Download ```psp_resnet50_pascal_voc_best_model.pth``` in NCRN Google Drive (Trail detection model folder) and put the file in the ```model``` folder
+3. Download ```resnet50-25c4b509.pth``` in NCRN Google Drive (Trail detection model folder) and put the file in folder ```~/.torch/models```
+4. Build the package
+
+RUN the node
+=============
+The package contains two nodes:
+1. The node that takes the camera and lidar data and sends the Posestamp message
+```
+ros2 run trail_detection_node trail_detection
+```
+2. The node that takes the camera and lidar data and shows the visualization of the output
+```
+ros2 run trail_detection_node visualizer
+```
+
+Possible issues
+=============
+1. **Model doesn't load successfully:**
+   Change the directory in the ```load model``` function in both ```trail_detection_node/trail_detection_node/v2_trailDetectionNode.py```(line 103 and 104) and ```trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py```(line 107 and 110)
+2. **Subfolder package relative import error:**
+   Temporary fix: Move the script to the same folder and change the import code
+
+Scripts explanation
+=============
+1. ```v1_trailDetectionNode.py``` and ```v2_trailDetectionNode.py```: two versions of ros2 node that sends the Posestamp message
+2. ```visualizer_v1_trailDetectionNode.py``` and ```visualizer_v2_trailDetectionNode.py```: two versions of ros2 visualization node
+3. ```GANav_visualizer.py```: ros2 visualization node for GANav model
+4. ```jpu.py```, ```model_loader.py```, ```model_store.py```, ```segbase.py```, ```vgg.py```, and ```base_models``` folder: model loaders for FCN32S. FCN8s, and PSPNet. Copied from: https://github.com/Tramac/awesome-semantic-segmentation-pytorch
+    

From 9beb822852de9e0bbe84f5a887a9af261540be00 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:14:47 -0400
Subject: [PATCH 04/22] Delete
 trail_detection_node/trail_detection_node/__pycache__ directory

---
 .../__pycache__/GANav_visualizer.cpython-310.pyc | Bin 8527 -> 0 bytes
 .../__pycache__/GANav_visualizer.cpython-37.pyc  | Bin 8540 -> 0 bytes
 .../__pycache__/__init__.cpython-310.pyc         | Bin 173 -> 0 bytes
 .../__pycache__/__init__.cpython-37.pyc          | Bin 167 -> 0 bytes
 .../__pycache__/jpu.cpython-310.pyc              | Bin 2452 -> 0 bytes
 .../__pycache__/jpu.cpython-37.pyc               | Bin 2441 -> 0 bytes
 .../__pycache__/model_loader.cpython-310.pyc     | Bin 6824 -> 0 bytes
 .../__pycache__/model_loader.cpython-37.pyc      | Bin 6861 -> 0 bytes
 .../__pycache__/model_loader.cpython-39.pyc      | Bin 2460 -> 0 bytes
 .../__pycache__/model_store.cpython-310.pyc      | Bin 1425 -> 0 bytes
 .../__pycache__/segbase.cpython-310.pyc          | Bin 2194 -> 0 bytes
 .../__pycache__/segbase.cpython-37.pyc           | Bin 2155 -> 0 bytes
 .../v1_trailDetectionNode.cpython-310.pyc        | Bin 7419 -> 0 bytes
 .../v2_trailDetectionNode.cpython-310.pyc        | Bin 7265 -> 0 bytes
 .../__pycache__/vgg.cpython-310.pyc              | Bin 5456 -> 0 bytes
 .../__pycache__/vgg.cpython-37.pyc               | Bin 5925 -> 0 bytes
 .../__pycache__/vgg.cpython-39.pyc               | Bin 5926 -> 0 bytes
 ...ualizer_v1_trailDetectionNode.cpython-310.pyc | Bin 9034 -> 0 bytes
 ...ualizer_v2_trailDetectionNode.cpython-310.pyc | Bin 8830 -> 0 bytes
 ...sualizer_v2_trailDetectionNode.cpython-37.pyc | Bin 8356 -> 0 bytes
 20 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-37.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-37.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-37.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-37.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/model_store.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-37.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/v1_trailDetectionNode.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-37.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/visualizer_v1_trailDetectionNode.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-37.pyc

diff --git a/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-310.pyc
deleted file mode 100644
index 23211bce82b256058757eb70014e788a5350c843..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8527
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
WJpNgGMw=+v%BP)cb^+eu&i?_6kEGrJ

diff --git a/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/GANav_visualizer.cpython-37.pyc
deleted file mode 100644
index 5e803d19b28ae02db23c1203a34cd91860783dc4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8540
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
JEvsV5{{{8MbW{KU

diff --git a/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index a29346dca3da9405d20064e434c475fcbd687b4f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 173
zcmd1j<>g`kg5`EMQ$X}%5P=LBfgA@QE@lA|DGb33nv8xc8Hzx{2;x_Oenx(7s(w{Q
zVtz_~Ub=o!ez8$}d9i+RQL=tXQDSCJd`fCbYH~?teqMZDeo88K!T9*hyv&mLc)fzk
WTO2mI`6;D2sdgZnikW}}3j+XQCM-|@

diff --git a/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/__init__.cpython-37.pyc
deleted file mode 100644
index 108db98bb6506399a21ca2fadf9221c73d5f37da..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 167
zcmZ?b<>g`kg5`EMQ$X}%5CH>>K!yVl7qb9~6oz01O-8?!3`HPe1o10CKO;XkRlh1D
zF+U|gFI~SVzt||gyjZ`uC|SRxC^0i9J|(pzHMt}+KQBHnKP45rV0?ULUS>&ryk0@&
UEe@O9{FKt1R6CGOpMjVG0N*eyod5s;

diff --git a/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-310.pyc
deleted file mode 100644
index 96f976eaeff4e2dbe8bba73d606c4b100bf72eb2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2452
zcmai0Uyl<v5VzOfKiMP)rB^r*l_+gdqqcYDpbu?PRTT*;1SeELt@5(kTRXXh&2F$a
zy%Oy`9aW$1JLFy}@z8J4&(H_I_9<VX5~VZFh6L^qj&^1|p0#JkGrvjEZifWMPk;X*
z{sieCoGcFxlkecsKLZh@O9T~8M!VE<XTZ9Q&UAdh974&!?RubLecJVJ62XQ0ln7U{
zhrvGUHbCPE1{zjtLgCya9e=!bt4Q<m!rdn-9;D*JgQ1QG!z|7FQ#hAw8FuULg9OFp
z;nfp;6$DAZDbjV&G5f<Kc+dNt^r&^C(RJZ)|0(H$j+3qr2M6ZFJvoe3yq(GGMgGgC
zm@?RFN`c%+8uk9jP{vT<vc3(ZBqgoLzB6$S;j>FPtD^8@6|daN1IZWkAgD;>RzXGg
z!8Y=0EAS6i*#QTgF9`U-w>pmT`l=WWwc*=otd$FAbg1%?1;*8*p;QV_H$fDod0Ix1
zaq`@FGrtW_z<=Xx=cX~lSnj4;b{d9jne|MN=EE$`r8Zv8n~$W*WftjlERCm2l?rM6
zVJrj$-2@`d;xa9Ad%g+tLJguUej?Q~Y8p|LWU<y!^o;y_XJe-r$c^z%T!<p?Z>U0V
zM!R}rdz5Bkqf~L4MM9P`!QG;~5b}8C!{KOs_(aXatONMc73Vw+=^7ocy>?0K^9Upk
zn9T>u7@+I$=!-xqG9eW`q<awj30zJsIkiL~@N}!gR10iX8_5cgj-yThGxS$=7Il`K
zLyg}n)NZWAJ20^hhTvXEIUS#Q-ND-OS%9~d#{&ts6-LpZ5Tgv`RunxR#o25{VPcu)
z_i>r*Y(b<qg^hzckLq?E?L=l-6fL=Q238gNWwQbUr*WTvcr>6ZFHZVapMdI>ffbEI
ze+FbxG`3hATPzM#C>D#Y-KApj6h=5DK$H0{xD#e7p4@~---pt9y)-5q65p)=GtQC<
zi<9Br2QCzgvrkJl@q~9s4;hvN%;whqTdjj7>)@@{4QmaEQ#q@1KhTrLfp?52%_G*K
z2;XSkI%3@v%{N-Nk65=v>y6ec79!eP(-$xlM&5$M4M@~goFGKppZ*7n)8{}Sp{@G8
z`Pvk(ZHn(rv8p;J6f%36vplou7v7VPM=~$dI8%6&hW{vUKQJ!B%9k^Cb;hpDV5l+2
zh|A`sxVaFoEX1oFcUDr(G>?*<I0xX-#@$UtxuZ_wS>7Y4tG-q?r(YJF^$s&!{{Uo#
za_2O~<o2F(evITEqdQ_3J|DNBmn;wjp?*FvlQEh%;n9BqnIQ<~?O}}}!l`9I5y4RI
zvpvWtw3)C&?0Doiu-RiJhn$COhrDFMwjKa{m|r9H3cUTw3WF8zp$|3z<fOC5?Tk!<
zirdp0H4kgvMBe9fYw#z89jU-dfR+c8_c&l&b4z^)-=aQ3@-dQ2KuoZmLW7mDx(~gF
z12Rd|j<d86S5!c2Q1cdKm`Dc-!_;Z1Pw{m`4)r<i!EO7XHw@ftDb=umt|5(E7An~>
zEQw3Cj<y>}zCdyr$UGZ7XiB3J5}_yKQme0E$#9gHK+fVD;@~&%=u<#Gp{w*9{8s2C
z>QL{+8XGt9LTkiT?}N?K1`CwLD!|mz__rY-tMudtou=`lNE8VG>ow4tz<R!(=QBut
zcRpS3jdI(;;>?5#S$&N!!4@%Mv+?d&c(>&-D=(YM3xZ!`f@`xb@GXW^W5?knpe=fe
Kdd?|!`sDvy&pjjn

diff --git a/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/jpu.cpython-37.pyc
deleted file mode 100644
index ba624d87e89303e64e1f29b1fb1b3dbf84126f4f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2441
zcmah~-EZ7P5a0FMKHpbT+K_%wAmssid?X@G5rPV#R!XJPMip%Y@{8qo_bzUI_I1}s
z=*f9X5l{IaE-y$t@L%vZ@UX8u-M@gu$IRN!g|t!E^33e)cy~NI^PAh<Zi~S9?vG#i
zZy^1NlX}=7d=0Pq9tbBs;gnkm^{L_3kok<3I(x`0LdnqaUC^)r^&58yx4H9za7VBw
z-U0KQpm8|^4XZRQZapHs#^lnyEKc*4htFj=jQPs;NQJ{u5~qV1oJ+PeyZ3NALa`oh
zC8!M$1ObPLZ=qA>!R_t7`!nfN<3iJS;NZp!;)Bj6egh8m^x`8i3T3#Hh&x&O!#bZa
z*lR|CY(~v$f8-b*TvGRe<RqsBIk2YI5&Uir=M)qkR@jA8xF9t+J@g6^IE7cx1F#L;
z$_jjgRd#5DuE7cTU~ly-?G9u%9w}|_#G#T7oYAAQfy~p68jpmOc)Iq2AWq{v2(*=^
z+AV$7b_Bj_YbVvs5yo&YR-)I`wh~F-_u_PvgsD)zTXNlgDr72>K*bZGU6sq23*8un
zoI|j+$Kxc-<197j>sFe{VUUE+h3rw?41y>Ll?sAi$zR{B?Pf!<HrWj`o~45|nW^<)
zPpv5#t>rR|lYom{M7URwW?Z~l`D8R+9X*$Ikd+7jNvs8WmA2^Q(y8lNt^Yr=&<qB0
z49y*Q)q6k+G9?8)qWci`DO^h>S(QW~<aDdYWCv_z7s&#Uo+TH7Y5JpFMx7xSQPb#W
zaxawp4VaY9fn)egE}nL-vV=Q>drHHhfO~2M!7$_F1m#W;JR65exgs&8bo+LgN4r}P
z<8^LgATOi3Tg5pNNfHEemmn+NgmsCYnT)`&DJ%q!x^&q!x(KGn1FIK@`WVQ(NKA29
zrZ_C9Ml23frzeWTl^EL?BOKMcU}mD<ZFtpVD3jBrFts7kodU4oGAXbS8SZ=NKyg?H
zG-p$nyGQhhVfw?Ywr;%E+B;$Gz1F&EtN~dHYpM1FJ!u}gukfV(l68x>&b02lWZmZN
zGp)NXS$BBnOzQ;$3Ei#Pzc3_5-GIR+r002@AS67V{R4}$zkxs+8})^HZH8Ai!|!HT
zN4-Uf%v@xdT_)*TkHoXFNb@*MB;KU9zZLhlwSzEnvt%13yHUbUv&Mu^^|81<7jMkP
zjh<5$QaetAXg5p&Xq0yLVxI5HB|OW03e_}FbtWGdn(^-nSg0?65V~O5bQzL*fu7=L
z=_|WQ2l~VuClJbUVCG`<?!v2n2U6k$=IK#|6x^z0zzWV#9<Y7LAhemXBkW}4C$QOP
zxeYlE*$sKfxM?c@=rF%UsulS9e=7`D+$RmN@gN7SecQ~))GKUrdb8rKinoyu?AjXq
zX~B+^W9CCU18VneK(h9hd>8&jt{}OF1R+p+J25m)5z5EVTWr7|p}S!c58z5NfPPuG
z7|nP*lo+C3M}B~xUq{lzJ#5n+=%$97%!M3f&=rJs@=Qj%nnhtQKSbM)kRZ0mPk_|7
z??TfV=gN2bBFvS%2}{0>@*K)a3`4a05?*x<2%*>M61@V?0)3x))})PBd5o$OvqQdx
z<SG)(W%)J|L_q_b@*R|p5xh<^1D9ADc$~uW@aWRDURyVUfM*dP?B}4<p82`eG%d0D
zLOosWk5kje!bG>`viuA`f-OP>Y3)8RIBzPZthi%8PP7y6R@n}|!l)~3LN@hihn}}w
HcK+OdIXN?e

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-310.pyc
deleted file mode 100644
index 40bfbde6c5e6e7fef1fc9362c1c3bcd7a5d67f7a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6824
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

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-37.pyc
deleted file mode 100644
index 382efff7be9cea03567df6d79de8c371fa85d9b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6861
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
B!W#ep

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-39.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_loader.cpython-39.pyc
deleted file mode 100644
index 7ed3c2b27a61c9d025239c1628584438152e1683..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2460
zcmZ`*J98XG5T4oh?L8#R@&gA(g$XzpNPftMqA2qa2m(-Gi)53n)y~}Mq`lem%&s3|
zl^|1&L=Mp%nSTHQRs05iz!VwLRS^<F0NryBpIv6IrnkFydZxGM>+VaM&5*!&cl0y6
z3fvzkEDi^Rk6^01Kp0^(BYhfCI^nH8wFo7BJ93Q1%G|yed6axkn9ZCgggKlZ_$PK0
zfW~DWXuPSW#^^oL_Q$X<*=bYlKInF@-%e3n9OwWJbqxq75oIK@7-bf-xqaYtoTsEi
znZw*CwFnMi{u2^;Pl-b!AGQy)yS=sZo{|<=Z||laZZ#b~JYAS|nCf>R1u1AnPOPCd
zf{&`~io|vWXB}Gd?ZT-XW}VUl7qp&e6+W|vL1m5T3H_E9wS%xC2Ob2-`ObQcd{1Ci
zeXa%X=Gw+w>oPLeHj5VXDq6WGc<NG78!j`yqAVDpe8$M|ek!k2w*2)4i?bCOuCf~F
zf9nz!{zQcb&-zbvWZ}g?BpN#=1`z0QAbBB^p5W|gwG@XUe<;@WlJsyd7ySLTZ;r=j
zAQ<C|Kzan?Hilr3F-#KG_@gu{Rqp|BJKEXj3Db3z=90&QJkM?}3Y$7e%12r9n9H^;
zYhW!AX%eH|KBrw(4!D#yNIHn)p6C^EtZgtcZbm_eCq*f_k_Z6ZxLb;%*XN%}nM>_;
za@kJ`Z3&^nd;EUM;boF(cjAS4Y)+(Gusa~&3vksqp}nnKJh;K0J0lx-Ks}BXFOs5=
zaoqN`qj=WQo=CGqDILtBBbRXP((?eudx_#Y6yQ&6zEyjN4-?r{&#11&u`!S1XXNkQ
zjs3jOH;(p`oaLgsA#-&jeyBE-OgHc{vY7FLr$sLpvB(*JwXzRyvN+2V#^w6pv21}m
z2x+wjgwPiCXh4^(7Cmo%ExHUphqf$_uKat{GO4gWi*|}RF&p?{xYHI)^%oET6shQl
z9$Uas1o|;RacEUGa88#TLm~|A$^pp(&M|r)IM=KV3h%(LyviR2Bd8h^sAJMH=hQi_
zRkg~$K#oJRDy)K6uBun{Du7iDv#L?iSFUPS?yy!hM^KX>1w;8K_)s@~wTxZsf9zVu
zu7!3*0}>Cbk-Ia-pumOqGRTia?zS!MVAORp$$DK81K0(Zs@;^Uuuz^uavq66ID*?C
zOVe##?}>uTL7pWA2SD|Xxb~94fD2||G{K!)l!J`7m*gcd)%4Lz+iE{Ai$PhaD466~
zN16;WheSa+FxneY*eTT{2{)tWRBLi_bK%uZZNqMn2T2A``35>`$Q3->hol1NGIT_}
z353uPf0hFipO<Mcogv^Uq?bW=)SO^yYWpm}WEM%ELo$bP43R4{<Qs8(zf7{p8@Yn#
z)jvs!bbkjj2eJ`?EV07t<}_<ko@H^o;N%)EK~GK5z{0JtGz9eGs?nq%yfEgS<0`0U
zox}7DYI+9r5YsbEqgv=0uDk#S>C7DW#LU3EHLW57=A~9a8NCD<QP@MLu%SgjA)jEK
zxu-5P5<nN|J#0^>zzuyU<oI+e$QEXg>=Cw=z!d7*&KQp#+dyOhWE(K(4-&?DqN|;~
zUZQrPiu*k=$dZ(IfBXT*FCVsRvWX_>{3M<jW_cC~)^hFK<zIfS{ZC~+fa}-pUY4ha
zZEu1+0BfA?CqnQH>fMZ!m(lulAW_SpdA>%j;hQ;n%z?K-rSMR!L;=*D6{trcaE*VC
z&djRttIH2&9e(f@Ooe>{lGv0VNJ<L-4&)uswJqbTd<XaiU|c~FvGXxZg*y>?v^+m=
z3Qc((^b1yNC>m1?*e#e-IIYx82-~3!id?4q>p~d7MrUW@dZ!eoQbWsu#GCQ*E!ZTo
q;ctv-VcPr3px=OVaw{fW&k3HcgAXQ2at9l%!uxJO+#1%(wf_K_V@JaP

diff --git a/trail_detection_node/trail_detection_node/__pycache__/model_store.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/model_store.cpython-310.pyc
deleted file mode 100644
index 4409cd4cf47bbd56aed593a3913a42d34600acbb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1425
zcmZuxzjNC*6b3*_qGU%-oHnVi3x^KTV2b)d+v??Vy=yxrm%FqbbnWpV0yODRgbF}*
zDpMV5ckI-EARhBa^dG_6DO=}EeV}Y7%@sU6;sJQXd*Ang;?A88f>!<Y4}0z+^tW|B
zYz{bIL08{_VQ7jNW~9J#G9}oKox+(q_1m4g%w>&ZGHtLXYh5DdeS<FWw8`4j7VAts
zw#BwD(X`EWSeG>}@wCI77pQl4wf|HwUieB2$^Ek|PcnZY#c9sCf&tf(<|SwT-0o7r
zTSx@;u<0&jUg|hqmWj?q`OI{WxsK~iahez0>{wrNRl>_oB-ln?H(M9fi@t`g9)QVF
zg??)NNY;2wDpKJ;$<O2kdV^#G7JH5%L1?@r<H<|4oEx{Kb6zji=H2)GOw4(Il~KV&
zdEA#m4dXM_pDpu(^=$=3%(&)ts&NUG{Qu-8{Thj2@r&s^W_h9$F<(4s+e8VN2S{4V
zdQOj+N5d!?&!TV=O?Vm($7zy;Q8*loXm~I?7>ti5lXNnkjhOK^Kty33MWaJL9y2~k
zj-pXY!$C9~91cg}gbp}A<U<znF&|RX-b4+;fej1Uc*G7SN6EnfO*o~)SrS4_8bv&1
z>@ZEov%z>o)7!9Uxbict7wXG?KcnUGDht#opmVwsB|TFC6xLt$&Lv-ncqxlDFB8FX
zfNw)}|J>3RTd3E;DqsAEKuhK=fseqckVdCiZfnf&38@exf8Y!J8`iM02hwHE?_>{w
z;M`}c{pTOa%1?##&+C)?T=}KYK0O7}=&azu8!SCI;H@>Fgsp3lsf-Rx=LcFW`L|LE
zX`1knIo0wW?0c^bX_+$}l?kcijH>KD_^JuU!*}74R(<bwe(eXK|0KJvJ+V~ZG%G>d
zYq3sY02SJLaRnC)>LhET$%*sYt?(6I<9ghva7CE&5M7bAqnj3kwOg;WD(4EzFDkfv
z+GFl(Wc>>a*V&@ec(%H~0b>9Bea`D1sWGUNUAe(RXRFVj*4Nf@<e#r^U`xfaWI?Yj
zKZQK&?S=?t+y&K{>F`$zTC%0$(zqugFQo;;H2JGsX=NJqmF_j_ql_zs(58K>f$L%Y
zp|%CTM)M<}rPah9bkzm3i?{JE@xZ!x*Xd#T5GH$DrWMCbBynsyG5kREQt~*K7IFC*
z7}El=*<<ZKS`@HWr+M#2pYT`NC>FE;x{a@Sw?x+Ge~^=<ZKDA1F{pZ3@F!Ne>Ju<7
S+QuGa=aDXPn=ba8Zu4IxGJEL&

diff --git a/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-310.pyc
deleted file mode 100644
index c382683ae99ab55aac4a2c2309d76d554616133a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2194
zcma)7&2Jnv6t_K}yO~W>NWa8~MruVEXp(NyNGL@JQBfpRqC&!DIE*H1XEV)=XYqKG
zc9~q-O1<$Ha7YlB{taCCC*a^Kr`$Mm;@La9*;GB?m7m}9duu=c-p7=kP8-2^`1?Qf
zPY<ELwJ<wu5I%=lJp@8gj3}lg#|4QAM%1EqZWVTH8{WyC!j0X+i@m~+eb{sRIBtD~
zs7KuwATjc|{oIP@DA`7lKf3irTCwn(lCnJ9D@C}?ij>Q&2TZ?UT&6NB`5D}cw$3on
z2rKLBN8d-53IwY-lN)!E!)~QIW2t+mdqLb-GhzUz>5I%gJ$>5j(C^cu+62N-jNy%h
z;@F~{muL@D2Rv`ZHoU-pfntZYXd70S&d~r??<KNP?89s31)zsUfBl~)wc8<#N2y2)
zCYh*=xI7(3+)aB2yCrAgW>`s)@xIwL{}XIkiZtVlhBV7l3G37vKshSKK`5UNSok4j
zd+9Kjn@bb8mhOe;{O#$H%^m=_6ha&(;>Oxiv|@~uKRMySPS4eNHN%J1fjI}W`U8kW
z64&TCIU%PAquLg86mv+KW3MJPN~{{RiCtUNIw0bvbm&~|)E>2eA+`G({#k2Xz65#)
z^y|`lqy8G`UC`f`{u}k4Y*Fu|U0bL4Iev!0iy!1%A5s5T3?YROW_WsAK+!fNHr#8t
zDA;<iBlNQ(qS^z&8mN`mV69ryY@4zhYoo;>Kj7sNpN3*H{OLHd&JaN;gCqe0hbreN
zqjFz#;QUu8>L{lg4wx{xqx>YvcqWrXS?TbJa(ORLt4in$6)jCP&_biHg71b<C<Xgc
zh*BsQil<1Wu(Zm0JQzm4vMZMFiMRDX-qPFtBt^tkEnYf*S+Wboq1=O`RP-yMyTL20
zT1jGVPZDtncK-c#b-ygw>S#YLY03MmqO8`EqiS_`nB{a;W0WTplDVf#HsMgxZ{Dm}
zUthN}cq%T#xr;EX>p<plfL-|c`1*9tliOr;Wwv@(CJ6Na)#=cP=y@Mz^$bXj9-|Xn
z<5PSL`2;+f;UNR3`}Pd)7#?yI?A@Axjb(UGXVI~3c)zxRcYtq+do?;~K~7t>T|1}t
zHk$Bzz(;uWJ_H3IrBJ#dfIThQrb45(iK%jWB|q#cYnOMGEm%HOUXeZ-lx42mJblVU
zw^`Skb-h{dnm|UbxCSp)_=zIDF3dHU>oD({xQ)qs+9J@nCyi6LG*mhf0uli7=RcP$
z;DC&7TtI#HpBIqVQP4?eke>$zFhLqeif=$wMP&35J52K-G;%;;(wmMlxgTbHFqBo8
zavDlVJSHpAw0N)aF(T$^;sZGM^~d<lvFt7=EA7Vo>!~uaxZtpMcIxoEAWR%S)`7<&
zsG;}YKp^Qa6xka4M8s_{HFXqO=T0db;!0n4&8Dm<KLPtnH<7l<X&a9&UqDpbz){-b
z!A{iDrO)AG0HxnflA@%;T=PMa{5VYWM&l(3EqhRqx^TqDnk;Lw3Pg39dhM}1Z)$ez
z*gM)pCxGcOy1J_Xh>vVM-|`pyg#|kb#5!y#UzVb`zrwj9oSW<#ca$q8{@@kMtCex{
yJM8X``_g$!0{2pVw{qb_3;vt?X28*H#5kh-PscC(Ob6U}V<X5wvWQ)B)%p*|pC~r~

diff --git a/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/segbase.cpython-37.pyc
deleted file mode 100644
index 67f274335e318efe69eafe900ba2a1d4da495e86..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2155
zcma)7y>A>v6rY*>yz`wCAPKRA&;mhb5wUYlEFpss3c^SzI1w?;Hmmi{+<D{uIA-ST
z<XAT(N;+B^3cIAGg?|HzZK={xQ}N#1-r0##FsJwC&Ai!}_kQo=Zuk3L0^`o_|L{LO
zLjK0ZeApm-4y5h?<0K-Sa+cGAMT`<|aXYsPJF<=J<WAv6ZsA2<;YU8~xg#2Nz9QV?
z?h{xE_MrRNik3LLPeOls?RKI>@J+=<9t<lP+!sYs>MR9eRESb1I;+a(@GjYTPJxHC
zvA(|dU1&8uDO4%+=8gDppql<{HMlW&VY#_smOZ!)A2RQxc-wrSZ#dKzFhL>;{xMD?
zi}#<AA>|HO-HB|l-hV<Ohj(}vW|uGV9?ae|Vw1=RPnIR1My7xLA9uRl0LHyUCWX*K
zDzm)47-qSbqz8LdDT1v)X_=KHvunPS;<}beRtg^QEKfAdi_-weQ6&!o{b($L54ad6
zlU#4D&Y@cUBsh~lT3p%g0eGtc#9+SM+*l3Q%%R4g->|)#x`-DHAIJe(0#bhf(?rvn
zJZ2~Clu%OJ@(QOV<Lub0SxsWA25oHD7Pk(V+}6&J)K2Yj`xjQbKeL}u>y|s9cR)YX
z-YfNMpm#z4RQs>gFY6BXPP(;qN*~i7DOmBFUgACmZe&3~LC)yxJ+O_yn>|h-fW4jV
zU5PG*tm%%WXd!OA7UQV1$gqXDxiP&oDG$o(s9c0#EBN6!BaDy?QUe%V**HfT*ZX0=
zanxiiq)C;=kK?S&bR0KUGI`jzWtt~SNlZxDL5A2$1iR^dJAs-g#FtW5vT>nKibP8b
zRn~*?B=j3wiF_z8;1|od?awnpzK+WaXAZ@CPzQ~BaFocAl34UmQk^(9ugCGP<lnpN
z`&A*<r~668t8%n1E42|HsdXjObwnkPIizihg&CJnxUb$+VuUZPjUUNAJaP$0T?Izy
zGVM_pem=cAC$`L{m(SPe+8mq|kTe5<K>7kmJq1>i2jqm-^pqY$=77x3$&hP{efym3
z7#Xq=&bu{(GnSD(%$H-^$bM~u?10>nhc!9rK=xX-T|1}teKMDaAae?N!=`UTJOE7&
zMH&Fki{fl+aVPAWcs5R2m4}1K+A9Z*Ek!<o7MVO8S5+RldGbieK|61>^UZd?Wr7&G
z@(pmip${9D4uCd*ZUWtsi0h24;E5grAGcOrgB^7R7-2mC{@jnb^dg(Cya4<8FBi~b
z2r$_U^q5`%3PB(_UBS{}(+|aAl24#l0|fIHbd>4+AS=fct%9WFfrf+=TFJJHd#!yT
zGj7SZ;NF)V@!M;~El?_x2`}f#{KUdoG<0DsUOG4S7^6<*)f(FS3V{{=0kNH#Jxsof
z@1t{}b!JdwLqPe<X4za6)yHsDVZR`>Ym#~T+6zeH8Mq2hZ1090EcX)nJ(PPlj*E&<
za+G^<{QV@!Ta6dTyh`KPRE&HFK9%nwdmmWSZ)-Fac@9SwF%PMH6AxkNO=rQHR>*wc
zX3H1-i@qK9WC$CLuPd4Eua#xP%F<+&=_1i(6L+vm<Z5l!=MD#ZvtD%8hQPc8-)>y^
g9|il(YiEYcB$I*ur!x;f!(ba*Y}$kTyTn}UKT@J0bN~PV

diff --git a/trail_detection_node/trail_detection_node/__pycache__/v1_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/v1_trailDetectionNode.cpython-310.pyc
deleted file mode 100644
index 8d94f2c6747331e53919f20480d27449e3c971e8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7419
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
CJ*Tw*

diff --git a/trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/v2_trailDetectionNode.cpython-310.pyc
deleted file mode 100644
index 0b071b712413254dc114f8b93e995c0381dd323d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7265
zcmaJ_Ym6LMR<3tfS3jobJ!6mUwiCx`62{IX3nA-`vvGElu-S=;jev%z=;>S2Q{(EY
z_O0p}Pg5Pij*T}$1|nAcV0T520YL;>e(Xy80W4r82xJ!!%C5M87PKHVNGOZQA3z)P
zom<`Wa01<`Tlb#(tb1PHIZ>(PDER&6d*5L{`>>*Xn;Hjy78=jsiC<6^g(*x8l)Az+
zrUz<Ut7~n&uB${h0;6r#Em=2%T-&bOvaSaCdS1?R>JHvkP-qwHMcJ1NO6_vJEbDeK
zhWTc@Qm+i>jkhQ2lf(K{eOj(DQ=h>*AI!Gr>T|=s`TBfb@umkyS_*USs3;4vETYtR
z)cVn3UrAESvK$-sEqDv-$Lb5i5tTbC#vf<n^%HEOUS*SP>V{H3$)?#1-ly0so5TA7
zHqVaW{UAHa7VtiuSDshcF?Rfh!j5~zZN2^wJH<}0>J7Di#(S8ZysGg#-kEI$=T$Gu
zr}n@u-SP4+?o_F1!u;gL<tJldUAlZ}*-L7wFkfspS{^D+!W&_{8u50Fma!Z$q82Vi
zv3EIXv^yTFY23srMDxSsVi0xN5{B3pH=gA_!y<ZX@t?YPUi|g#XE<%wdg2qOkGy&2
z<})=tYya8ct*^ZO#qDQW7v8%5?w|a|PmeleFW2aVdh3$8zVk0%e(i4S8(&^*{KXs3
z-EA$DU;FK^-h1}~I)C83|N7jo+<W(K>))y$wZ2{M-EIB#cmDo`fB(JL?xOSefB5@5
zcP4umT3^`x-P7;TsN2pjz5f~YB6V)w`_r+%`{tMKw%&T|oo}@N<12StPyXdUf8oXV
z{^qW);H!MaP?RQ}dh|n^Xv#%A@dk=SSy!2wXiU4U_0?2i`n-~=Oh2zAI$FlOGAG;f
z$`rkg^9rbDHfBgOF;-bO24-UIsC{i%&!MiTTB=qQtgEMLV$UhE4kp&D-m^{>zh)F}
zcs!{tv1+r?_ILx7h%-NIBwqEAD)TzYS`~bWs*kg3;Ijs=u5t{NlWXd(j!$?K{AS5k
z$J?dLmNzc%zLpnS*b%1J?j&2nTn(Z|B8omqhP&qZt+hm00d@*nLifWBF`J#h-4mHc
z;zyx-RgCc{$?EM!!u{)FLJkQs+J@ImB3?5@sk`CspI#I?Bv5XXBubpX1|E++_y5{s
zb~NC=z1~##0>0|M-Lq>^+dJD^YeXyxTW5I`FS(oX*_Eyzu(LRiAGpj*a27gq2s!_7
z;>HqvpC3Fo8cQm%*x3>@Lsqy+<jRY7<wc*y=J5oIvQbp$)G4*76;)d;s)ovsgM3K3
z$k>rGN$I+SN~)|wVdo(Mi8|0AQ7Y3`wH<BU=xgXR`buJ^kcw2BRZzF6j<-6<r3%SU
zo}>-)Gr2sfq&ia}Z8qB4J{1zGGfhe+Nv}@QOC>XyaTEJte*<mVN)4u7H6_hVO-Q2I
zTRtR-dveAaNh1?I63%_8j8?13nl}<xc}XKll?(0bJul-5mLY~_yw>P=d<;!tB!1xW
zS*og6_zd2Bni`H2Q(XO3kJEkEEIv<kEAYZrvL*@#WRA~Kj}3W~3L<7!{UGtU$J|3A
zC?zK=j?skK11uiOp*;Q*=!}n`aEuAnlKgcvO`Fo^z~_oKMZ7+P?j~v5=$A)@culnU
zb0|`cfxAr0ZajtEVEQCcjRRCQqs}U?!;19vL>Z``1+R86FV$~KPBH6s^_Fr=UDa5Q
z**EOecuv_?`(~o0<~D2<+`&^U-?vihGVIPkPfbWl4*Te7PV&_T)ky6fvNKNal4Ob(
zCs2IY6k=UwRaUmDt9}Sm)2d2MjjK@A7z3-YHrF3TFOS+7j|mWf2Iq~fef};>-b!1u
zOSj<vRqj4rAX`M1b`noaD%^q;zv}eqdm+)ERj;ZX*6|JPnszzUamguoGi~u43=+Hk
zrY4HakCR5&^kO%@CgwW+bq{Jjq`Ao&_u{oEU<Y{YoDb05jM|;2e-xYkCmmx!>75!~
zKqfJZ=Yy!(2;!$v84cgPhhNRiq_o)Jtxkg{KA97tLk5K@uRs`WuMt9~)$2mt5{0ni
zE-^RjQei5Gcj(g1;@G0J(SSACYo6LW{N@@2c4%qhB<jTOX2h?88=|r&&7(!iqg5s6
z;_P!D!IyC<*X6?>_Yyi{Qmk{Pp_A}VL8J}MP#vwPIU0W&U5CsTi7?ognXOBxBrrOJ
z(U@^t@2e10FlqoNxvn!S)jqF$QA@Oe!QkSUeOud6Rj_mbLk2-qQL}b{RgxUbZ_6GM
z!%SX;4TgnY@{w~_YPzt(X3&UZVXrirS68CY6Js6jk#!EC$t#W6>pjwmJ4<I#xTA?~
zrxAm5?ncyfSMc3#8}>U`gq!R=5%cDU8~qP;4|3w!p4IHK##842d5Y~u$0fNSp7&-y
z>4$#2=E3bo4XGt^!pWM=Nvy>fkzGh<;z1&ti7?>>n`^=#y0DnH0saduiG<-n287w+
zaEAa*&(myEE+)$IwYO=;SW=dZv5wqBj$t6iWKYXrWL0(GgKRLBe;TAicBuq{jYs;R
zDzFdP7_bXi1PnBGz%JMwb70}g?ZE#GY(QRB!dmT)x}&vdgptByY^#Gj0|Xv8DS$03
zP+?HqQGNm7J5|UQ^{pQPbT{zd)>S36A5-EdH^FlH{}_otVNgmfLR1X<4$5+^u^nZ-
zG8o@c`Z;E%xirW0tMFZ9y-+u(o=mJyra6>T%mOMyZ7`h@p0b(V&!@TPlvf|<JIM^_
zv#A3i#11%3AuaIN(}F~B1(usvW))^1Rr*EjW2gCfC7DZ$+wh-ho*D4B`D^Q`4dKi$
z14%mH{I$-<oNrxdy|wX&zk1~CKU`@2^2MJE{`G(UmH_IpI{WCiUjEvJ*4FMrkJ-QT
z_J!8h-j=@$`_69n9xk01sW?Xk@v1g2Y>C7#z4(&IlReE0h2Gp)5_WSVxflfz7p03Y
zzx47e?z7Lovh>RH&vHT$B6krc4CYwaSE4Ik7-Lv|889B!r00ozH;k`!J+J5S7ihCj
z$SGmuwm1nNj90sHUF3#igx>6Qg+UHom|?fw*^)+%KTfmEF2wRl;b5sKmhKlK44Wu&
zA+!KQVe+UOvRa9MinfyCi?h2DNQyi@ZB&&Wnqm!MW}Q~lO*-8~7|?4b*GW8)<I$#z
zQwSXuQQTbfp+VBJ$0FANN(4UrfFh8ma&eBti*SheQ50m^EENv>{VBtNLM+^?>P2$c
zs2iG%9$3DtrScFHns^TV$nMcEeh`JH)K#X`wOh(6oGjCB*mVh^5TO~jAmViimPAR~
zk_<gU-$zT(GUNyM5J3-(MA?S!G3X9y4B<aAsym1)T!S<)B_nCbwmod;nJL>&QrN~E
zx0oU(aZ89J6t~PQskvi7jzECxP79a;Mp!3p9aKOWr=6GrnYNcj`JmN<_zc@41Gh_Y
zyRb4GB*r$pAYxk~I6<gA-X(0?!h_#GUZ_m~!gYb*gzdtW`HAa_N|SqJ`#Rkfhzpz<
zC#xgIvR(J6Vyx}OF@+qNSBr&nxw{fKxxa!bbX_7Zg~g4#E1W=;$Y=1I+SwUbWFUG#
z{EmLS)8Wx|%uBp0e%rge6*kv+6hbw)sBo_Z`Stk4Mi7u|8GSk2hHTeNVZ>grdSF2Z
z%GCATm~=}^VnkGV7m*9Rlk4t-3%-fty@5yK8S<%`N`LFS6|17!nx$K+q0d0(dNYT_
zWN~zBhvbDoEPb%F)b9bPklQ7fnW*a;@Z87&>&#@<4WLAc1C2xnx--Z|BX%$d8G`fH
zdJeG#@FMJ`Me)IUo+Ko-wsqLgLQ=%664}t7CrfFkcKk8yCLJ`%OAFR8wP9Dkx9^}{
zNFC-NYA7aU)Cv>>_e*JEFqRgjEK{vCswI`Qn3muV;3**I1y+Q;F9D_c*FK)+F|t5(
zs>hqyvrJz&+_RkKvFEAbp0ujmZM1TBiUTdIOs!-*E#NE0(lTa@$<=>K-bxv_QclZA
z@hCSnRv<LYiooC_iZi0j?$e6<w0;GvOr#a8GM-xfiDWXFN^wWqDo%N_KbcOZ<M^(3
zu6;etr;}Kl?g%4f9k<k<PNvsq(us5$_ck@B0Kt#33M;Yk+a_+{>&f(BmQAD+I~u-W
zdN9W(<=4z_EB%>NTR*aXG@V&L;vQvF^1YCj({b#AmC-)7e%w7Vq+s76r8=bGW`>lL
z$*I8u2gdEKv7_~8*|Z$>pnGDkR>k<!=`1TA#oZ2jX^n^Oqn&{~Jv^wTGm;<5;CptI
z!6WQ&Yj*#{pI6x2{wWT$a8dwBWJ-pXYJRyl{^`s_RJqsm{0)zt1Wft}G=qO13ZeF{
zASx)V`d+}?5Xp~N<m0P;2lX&M1Y`-Akx99X=RnNy69BP&4cQnKc2sZaABZ^&Uc-$2
zE%_~KN*uNa#`q#=Un2Th6uonY6+E+gBMb9k;RW&`FeeCEqHb#qXtTn+*r$-y3!4$)
z%ih#-RBd`8EElpeUUikc?#cahP8M+yw&)$j$Zp(N2@r;VU;?tR$hc*|gi>F8SrUW=
zXyA8aVKyb`$R}%l^J<8j@0FT9Zw5fR(h%>;u-hIvgrO6_u9G9zQ5{)#cCwd~X~U<g
zJ?+tI?NR=N*h}c0=8`DDJ+PrS*@qi4j^?k?sFL4qwc{4$TL6cohu*iy{3qo?J-@>n
zsL6}~a80M<g-ix8GWn7r9Urk7vYbE-OEmO{Xr`5YlCb<XBE(IR+idvBr@XDqNm*++
z8(f76_}=aaTV?@Vp8=>y$c0h{e)mZPV!sA55hid{h!2dokIR?Qg3x1}LT^T~P&fG&
zogg>7B;mBY1PH%{^9jQbSEJe-{|t?AhB*ja!pP^zYL+)^A>_0&XDsaOy~H?S81B>T
zl0-v$f#rS*<S^X?aPqDr`XIM1)UHrB#Q0u-`8c~I-TiO}_i@GvT8VNDpcznjl}(@6
z@Z+w8p5WCG?iFR1JG|&JiE>s4PTLgY2ihcXz<ZQ6M3!zOMJ|1;zSY>gU(tRBC-^Nq
zaf*V19D{u9`(>Sio{C-}WCwg_z}Heq$vDD)6L@P#&mHV5tMr#6wDTHpA!gfhR8c*S
zv5sm1GXg7W6PUk%wgb$FBp+s-S9=TppOV)sLPKPafQB5G0?}?j^`h%u!)0YX5;Ji6
zBvBedil!F?BUmBL%T4skfR7Wn{Y5-6#Q?SfFgq)0AFy&{=_GDgK_!uhVW988w-b68
z7=$3G%_~d|0cPRRRG<ZTGUTTTD<IywO=E4!P;bLFCe|R2JQQfDK5%3JZw(6cmUz-w
z76t{%{Kv5$te1fhBd!&tzRT!?{}DQnU5?$x2DnVNNrnnCK!tub1LRmC{(d4q2nehL
zjVZzig0LkMw!)6rx(SOm!<xbW7|Ue~P}CvD4{?HWw)aU5>82mPkFjwDMH#tTuw63L
zM*4&QIjsVI(J0rgsmrxm7Bv+|AvjqCPIx|x?{x$=5})#yX=*`6_fP}m24sXL?F|1a
z^*QqE7Afh>b3_<#c}P|#e2Zi}UPLhj$FYp$_Nfx@9z8&HJ6nrVRkOVLk|-W*aRQ(G
zRVv1)7@!b&Xygzf6I|vLdC1UC=2f!{>q(-?oNFNi+nYXvE22EBG^CkXro@osS7wY!
z80Ee3KcL#aJKXb$!ako#{nIK&#FtRmN(I_OIz`t`(U`1LiIl1Vge?ExHOx`XGAX42
WJ=W|odk+7CHea!w&@Mt>@BJ@GjkpH@

diff --git a/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-310.pyc
deleted file mode 100644
index bc47269785bcb8b26e33c6f6351334c0c72468f8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5456
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
WeH_34WbN$m&YwL@7hK%V|NB2(_ce6@

diff --git a/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-37.pyc
deleted file mode 100644
index f9ab1214c86a1fa1160d2075f0d950f2c09ada13..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5925
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
TmgU(6HfuTq2Yz@qb=dy_<UyAR

diff --git a/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-39.pyc b/trail_detection_node/trail_detection_node/__pycache__/vgg.cpython-39.pyc
deleted file mode 100644
index 7ff37c2ace5ee8be1c9f6edf0d90753bd6111841..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5926
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

diff --git a/trail_detection_node/trail_detection_node/__pycache__/visualizer_v1_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/visualizer_v1_trailDetectionNode.cpython-310.pyc
deleted file mode 100644
index cd4e32d62bc9b3ba483c8792aec0f75c18dbad32..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9034
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
E2S8v-)Bpeg

diff --git a/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc b/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-310.pyc
deleted file mode 100644
index e52eba826c071582ef28a26f2cb32d392f97438d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8830
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
WPvAddm$adRt$fm{+Bs<BTmJ_zLrqlx

diff --git a/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-37.pyc b/trail_detection_node/trail_detection_node/__pycache__/visualizer_v2_trailDetectionNode.cpython-37.pyc
deleted file mode 100644
index 42bf6d0e28b9baed1955ee56f4fb47a8eb85cc1d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8356
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
VN9`H>C+vznUH&QMvQu=_{{{~wpojnf


From 306fa0562158a9447c2ef924eea9b08e383c19d4 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:15:01 -0400
Subject: [PATCH 05/22] Delete
 trail_detection_node/trail_detection_node/base_models directory

---
 .../__pycache__/__init__.cpython-310.pyc      | Bin 330 -> 0 bytes
 .../__pycache__/__init__.cpython-39.pyc       | Bin 328 -> 0 bytes
 .../__pycache__/densenet.cpython-310.pyc      | Bin 8119 -> 0 bytes
 .../__pycache__/densenet.cpython-39.pyc       | Bin 8190 -> 0 bytes
 .../__pycache__/eespnet.cpython-310.pyc       | Bin 6119 -> 0 bytes
 .../__pycache__/eespnet.cpython-39.pyc        | Bin 6085 -> 0 bytes
 .../__pycache__/resnet.cpython-310.pyc        | Bin 6189 -> 0 bytes
 .../__pycache__/resnet.cpython-39.pyc         | Bin 6424 -> 0 bytes
 .../__pycache__/resnetv1b.cpython-310.pyc     | Bin 7205 -> 0 bytes
 .../__pycache__/resnetv1b.cpython-37.pyc      | Bin 8293 -> 0 bytes
 .../__pycache__/resnetv1b.cpython-39.pyc      | Bin 7945 -> 0 bytes
 .../__pycache__/vgg.cpython-310.pyc           | Bin 5493 -> 0 bytes
 .../__pycache__/vgg.cpython-39.pyc            | Bin 5965 -> 0 bytes
 .../__pycache__/xception.cpython-310.pyc      | Bin 9518 -> 0 bytes
 .../__pycache__/xception.cpython-39.pyc       | Bin 10103 -> 0 bytes
 .../base_models/resnetv1b.py                  | 264 ------------------
 16 files changed, 264 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-37.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-310.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-39.pyc
 delete mode 100644 trail_detection_node/trail_detection_node/base_models/resnetv1b.py

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index 7415bb9207466ed09c1dd577d6510c09b33f3166..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 330
zcmYk1%}T^D5XX~NYn9yxsj!BHJ&O1QA}9!Z3E5<518q_=ao6<?d=bGH@{p@1U%``8
zn}ajt|C?`!UoI~g+0*B{c_V&J$$u*-xuu6262lDd+2c%}S!9-(Cz+?j;(;~gH>cHx
zCw_U?RH-)L5FEr*1wi8VeCB?=OXa?8w`Tx2PL29S!x*i1A1qXK<4=ALqVofY*G_rk
zT`TS(pm(a5&PPBIgR;Fe5J69?LLC5UeuXe77p<nC9l%93bywpt`k*_ZeE>0d13ikJ
gLXbI@(mETZyc&<GzNX@H4>!|)a6wYDn$N!AzgYHM@&Et;

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/__init__.cpython-39.pyc
deleted file mode 100644
index 5e121f62b7173ff67fdf64749444896d236734b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 328
zcmYk2T}s3-5XYNVYZdk&71kj5DB=l3P!RSdWRsx{q)ExdUDq3U5y1=jkXN6)f=^D|
z2s>f^zxl`nGIFsvtH_={-}M{uD<_9mQ*uj=S0uX9%vO(kvckHsDLg7XCe{yC-+VI~
z?O9^ycYT{W4GzIUOl<%pu1@#dT&`2I8HUvf0M5D5y(pNY@$RDvExqw4KU+Tf3Ha+M
zz4mV4_YlxKX@&C<kjEg66&fO_Jj&%3knS%LCh4M46buu%D06o?@1hTC<jM!&lh<I8
fuO)&gu@J_YD8$9QOWidUpDo<v|6pEQ$NtYRjR9QN

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-310.pyc
deleted file mode 100644
index 9952de504bb156c9b825cd00f3ea507fc3c9e57f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8119
zcmb7JU5p%8R<6J9uCDI+aeHi!9Vh8Hc9KpqzqZG5lwaHHWP>w_)?R@IhjzJd^-O#E
z&$nvE@u&vE+H7DKFYNNqE-<q~NPa<xCmwh};sGHZct8TFcmRnP=9wp=4dMGvb@%l6
zCsC?Zr|v!X)~S2Xx#zp*p6-l{cm}SY|JT1z-#cL#|HaDil|$t%++k!IhBB1dG?vn*
zxnxS+YS~M+nev>LZ5gJ~$}DAjoLtKlPJSsb9INTI3QGmkST>aXQ*)`P9F<X7l~e9d
zoTZU>43$^jT|;?+ePi^Fy)*_+K^4I%_Bi9<jHpp?Mthun;EbtpaK^zY;jR7P>{BIh
zO2K~AC)9p5v23UVKQ-&NI;akzJSpXre|V^TM9NQKGzZjzdQv@g*IYV?($lJp(joPX
zI(FAsnpDrK<9HrcC)9Iz9#PM$7w~*SRn&`k9#t=?m+^d3O{r--pHeew7SE@HvYK19
z^xp*L)-!5eom8jPscmQJSa4LGzGE&u8$25v!}GW@FGJgxjmnuF+GDX|CWQ~Q3Ur_@
zG-^>LpSTx-b{H%MQBqJWwS#DGer~9;u%~i%w`G2IF4?adO+N}$b@<(fnUL`a=Gljt
zkh$^NN)&a&S7&Ba=T^Jf@zr$qcGS_emFbRNo@sSd&<tmWzBlDBoID%U&Yqd>Mk`<Q
z?S->b*XPfiIa8bUzy8}8>{M-TZuaEqGjm`6?YV`ysaMpg({ujmS-xFyv;!0AED0S(
zXFzJW_gw75E1U%h47$&frA#bYr*3^})J<h6`)+<IBW1Y7U3V$_so@w)IV^*0QmBf-
zFZs6vy#sGFYW!CJV!4Rh#vT3@NMuB2Y}~Q7tZletY;4)ejI*(M$K1B+W{+b<&Q?a*
z+rvC3a&DksY{%Aw0p}F=yq6hz%Y__i-6Jdi2w9%UlD@G8N6y6f(cSOmdh(pusOFS`
z85S3lOuM67b4f-A&9%8JNv76mug~cb%;w^KGjXmr{4nh^pZ39nUFLT<>x!FX!nJOo
zHT96V)oP>Nh^p1Z^OdS%^{q97#A>$_=Uc(0ZztLFd{ZTPr90iKhA&idi4z9RdQxhy
zweWIxEvnW7KU&j4m=u<E=T@{L9h2Pkb~S8l1o}z&lDJZ%(@s2&zuKgQFy4H%T5I}Y
zSgqbSKD#xu(rE=V8!LWCb=u1_9|k(?wEbqa-HC#5CenVR315tYS_DZm{;eQH|EVx&
z`R%AtLt(iUv?HIbQ$4qusdaSF_p9rE7;u)uJ_i5OlNjOw+~GLLs97>6%wy(3(C19g
z+?W_zRMUNp)hu-FUsNsEvn;GPP}p5qvAJz-TCs5hOKa89hhXeXEOqd*%DQK7T2XGx
z#bUCSvADM_nAus>T)Y)4F}sP&dAA$wWifIkuMeRqwO_8@(YJi9QXQKYlN=4zS&MW9
zeUgj-OJdjjsAB7<$TB}pitXUmz-Ib5g*`{|Jjsh7PvZ_<ka5g@!W=g@_77{I_s#n*
zmrvVo1zbMW-r_;ISgqb%^P6dlJ_0#O;hZ1URu*CSc_qr0?<6BV<JW>_vsz6@Aw!Wt
z$#}R-CpaDghigoj6P`@HhU%VcfE;}H%aH?Uk)@LRXmPIDsjZ4~Yn*le;-=5K7<Cba
zU852$BAYmI!T9L#rW-jhsT(^J#vvni;P)ALf9_6pGY?G308?CL9Wo9Yaemt}jhhAW
zWqWa>C_pd1a6+Z#&8Fr(gYSu^;KY7=Igm-~!{AoD)RG<@P+ko+EvBC#DU;CS^f8iW
zK@zi(WTfMR#^$o8mcvnyQLAVcVQ}Y*gO>Aof6<F>28;fFPS2yOK1p(lgyz+!NhnM&
zkcbH%up{R~R?m)E>);ofyvN&-<L}#1@ZS{7#}1I<f6t0Gtat?~3LEtLT7MbfW$X%u
zK_iL*6$*O|*n@j9Bh4c9A+Yap`cQ8T!+fs|hTqB|8iQFWLCoqcCJrGkafr}Y5{KxU
z;<Mg|K_pJM(`oJyJ}Pc%?AK9F^+yAzI(>qrqaaEC?e*mk@yfiyCQ2t3b0_<0f4KTE
z0*k#LW#u`%7E%|ZaOaYF)SM)&?dok{Vf`9E@F)v%kld9+s?{})n3|l2?8iNpSIDK%
zx1W-II}KySmN~H{0$SQK4QGe;@q(twcIf-}ot-Qm`Ws|$iR}=gcitl5Km;du{u}-G
z`0f~*_<8|%_+4P>UeibRmJ`7*BbyK$+sek+XyEL<Y~511I2YS@Oq5*ogn_qN_E3f&
zqi12;u3O6vc6LM$)qHGk<|8k*1P$K2YHfO(g{Tl0;ykdx1Qz5}@m_Yb2*A&871c=W
zse+(EQI=gEJxwA9(87yGC`T10ja6HR(I{l(m2<=p8TRH#PsZp##z-oIeKzwqPock2
z9qaWP!#whgKZsUa<7mrnW9zBz!%{D88^Es9o1@YGc$9j$W9c8`Ik9yh9=&mJ8`00r
z@Aujcq3y4wZIW%6zeq%1)(@+3)(5@E(fjWPy$7x09QzQz&>v>?L0D#oi$$LUxtO|!
z#5S{O+%k*UhMqE;;-V>QyN8(9iP$I9MiE<M&+|{HH0n8>?wm(b&*C~tJxlf>?{aW+
z4G}`aZ)!TAIGCoZCHeRLk5ey8+(AH-58z}0;~oJk!QaGg25njU*h%4ngU;DYjdtMc
z#FK!gQEvn~$)zDxn0Sq_(GDZOT?-P2F;_CS>Ni^0)e+q27Gj(vdn;%xuS9~TNgi5a
z_o%8%7+z&8_53o2T9oNm(WBm2PWEvS62<jLlI{fD1d;+9WjsNcZU)&^1Psfe{slDa
zS4qyYV@6~mVxU43v-KztAvA;}qgK|Q#8y!Rn0P;P+;Kz+2c=fR(>1M6vS!I1wTm`;
z@Gc3pK5_ncW1mFmIFb!8XHO_ar)DU1o*!c<g|%v=K~!XJS%{Fao;PijZTKx<cME%O
z8lNkNE$ENP8$lP^vCC%`uT(5qLMdTfwetn8N=|<pW&IM#n;^-4U-{jru^v?Y_2nwp
z9ztJdy%F3(%*#l23BCFlJj2&0Ah8*5?INaxEexZ$;|S(bQAfD5nj7PT$@e2SBJ<GO
z$5|B-T)MQ6h;WUp<(Z>jjK3hzSOb60)sI`kSHON0>Z+XJt}D3fs=VMXaOf^#p~3m7
zn2cRWPrUtM3hwHQ5USrJ`8g7*P+tPs;b&`kkp4xyWnFOhZ&BFAT?V*_j2wxL-0d8;
z&>TWyD?Eay#pioScib_*V{)Hp+AU|(>-W(YfoPc<*{xjcq2$Wx$Rb7wKR@8RI5q9^
zy=w(&FJ6;~EB%hX`oKFpY3;t#>nmuLU({{PL4Olu<9M13sD?Ga8I)^&yWD9vZ<oU$
zD*Ivim2yXy=N3}%F_T=^*Mc$xH>4%9>C2+O%1DY$EsExrmgMVe?OKHO7U~X}TvkhI
z!b05gWRmf_-R5nC)&$RLDr~sNsind$6wd3nMZhlSWTmi+AKK?Pu9G}NLZHxGQAu%l
zifJstMVt;wR;Da-S)Lp?XAm9*8Mj=-jgyEVT|^d>plPXSI{&vZd13FG+Vy)b@&4tY
z!1{UI;aecFdBeCNUc5!0M+AW#@hG_1t&tph3aiPgTd`SX?46b}v|9hhAu4gsGxl16
zG++RC93hpgKEX0W*~F<g+A1lm2D%+I<-khgDaG^FF}~P~xt94xmv7_+PkFo<@>|hK
zh~^l##M7=h3ZIA5n$G9&{G$(PVaSvS1iw74rsT&5*R(^E-(`dcsDSnX6=Paf82xsq
z3?gp4bB$HTahTXU<Vs{E#(nnzuHIlf$#7rI8TPn4w^82NCb>`Yk02NKz&V33!a0E>
z{C$uJ8aixTwKwfeXETHJ3jx8d+YKYO{@nb5xrwxj{$^w`6$22@F<}xhNW<~zumO%6
z<zjcs-8LlLI*Onvw}l`HEne*D^Rc((F<B!|XWK+rRlw0Kf7k#myhfUT-MIODoZSLn
zAcTj(jK6?@Kwu9!!l`rT%aSH2*L9~=j#dJ%jO*Gl=>V_Cx@sc}5h#|{JIys7KKy1G
z+uE&;UJZ|x2YEhUf81D~W^%8q>N9f-v#(6gE}T7kavIe)u2sujAL*EBPd@OWud%EU
zZG=*t8eCH4UY;KK%CD9i?MRp$*Wz01dZ5dldb!t(&4q(5ulu@z7=kUTm;RhCe}Fv>
z!A05EK^e)=mjPQs&c0km&Tm?zc69*sKs=-Hsp~){!dn>W!6(mw7XSm-{pK3bu+xq-
z;H!LVCBS#_@lKh!O&Np=>i$|YDi6s_Bb~6!af+VPuW~MzBMsN<$<+Z~Le@44Mbe5N
zu0;N_yyll{fsQc5@;cOo32~ASe<BsEJDms<!3180BGTa;zw*Ji&c9oI_k;Jp(Mt~v
zCU>cWj0r_@e5*mw<%p=ybWH%;dsa%NfA-NYy)gZvC|LA=RlRg|`h_=NWndTc5E#?d
zD-|%o{l&TYk63*3)l>`db!6;fz1C)mr`m#22NjsFQaS#a*SB3SM<5Y%rI?KL`PHx+
z)Fd!SEFC1dTBp@*Ad#1s@m4oFoy4U%s%yHLcqtRbFmalVFiM=&;5KrGE#_#F403pD
z-DFJqBLa;AY&XcI7t=V=+f}iay+QVoG8|jB6-Z%rjSw1P86(@bD<ZM+oy2CMFvk=W
zY7YQtQd|zAL9+cf2^o|;Iy!;a$;nvQV@ej2QVs&nqM1dY$+9M{)P^^c5iodc6x8_<
z3Io&u=4@txI!w^uaHh<A&SoyQ^gDt$2m_eR5yU|t*+ZN>5GOx`I3Dl^M>X`tAy2;@
z7l1fG8hK^}af&!<c|e?eTm<5v48%DBoWhY%5J!^L_`5<!7@PhM$sH1oyJuZ}mt{fl
zUt{UJB%hM}I>~R4e2?V&B-E9@NAd#@L>LU}Q|Z6O(j!czf13?IB%y}%?~wd1$?uWK
zPCwZ0lL@iR1AmA7B|4@SLWuvR7WxD9tl=J9CQ1%&TIhe6eu@lbVGl642LO-lMg7a*
zLPdPsPi>5cOl0ra<d22FryL+S5*$*0?8o#UQY^&(3ZJGt^dF(D|Cr<f(cHTJf&3qn
zu=dr0KS3`D=Hu~#vuOP%_7K6WeYN0UMK1{E<MD!XX#HpQ5W%d~sO$bk6%F)WLIrw9
z5~EJtn?2oIsqUd|n(e-ouA@h3-bMSr;1<o7OwIaZKc|0!)(V7E^ZHLn{*>eamFL0x
zH}e0Cgtf1h_zAl{RwARKe`gPo$l6y+6eT}aVgWM#V<3?==E7UpjgZDZ#|8$QJO9a2
z8>C`htenu|$5W^xr7!>ZwcBZWe1E?>Ee8P!B@%D9EN9f@K-vqTMl+n=MfQv^1R9b;
zt<!9#|Bi%`;7D@SsxQfP0gTHW5JR#wo$)%yl6_zP^^xr(#hbhAKui_;r~lh==@0#R
zM?;HkG}Wo8fi#?Ewpz6lyU|(}fJt&`iZUEBvl#q&ypp)DVIKI)=?yN?@I4UM;Mt+X
ugn{K+mSdUxWq($3OQn)m^2X<jhnc4a`hV`_ykqVG*V+3Um(z#y`TqmFfn^r}

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/densenet.cpython-39.pyc
deleted file mode 100644
index 74ea74f7d05a50eeebd37f728fd92120c8dadc2f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8190
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

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-310.pyc
deleted file mode 100644
index 1bbf58a3706ebf6a2e2d3cc65896c32c3cc20b87..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6119
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
Z@^fwSd3xJupKm|lZMaTL-T9dR{x2Muk&OTV

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/eespnet.cpython-39.pyc
deleted file mode 100644
index f39dc03db1d4fd716496a926ccd870fbd52f16de..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6085
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
Rrc=}RO|MoR7jDUB{{^Xxk~9DS

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-310.pyc
deleted file mode 100644
index 5f38dcd9fc94b313126c383baa111a3da547799e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6189
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

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnet.cpython-39.pyc
deleted file mode 100644
index bcd9afc6b852a07dd136dd5631f403293612cf59..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6424
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

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-310.pyc
deleted file mode 100644
index 4f4574627b35a4711eb4d6c789b90ac795bd2b7e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7205
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
OyZDI#)1@Hulm7!H6F@)!

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-37.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-37.pyc
deleted file mode 100644
index cc7b1329892392085df974a496e69809b2460bf5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8293
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
I1E9M90`fKWO8@`>

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/resnetv1b.cpython-39.pyc
deleted file mode 100644
index 5996a2eb7ccda4dbdd2d28706da994d6f8e1b79d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7945
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
LpY9sHKxh90hQ`>z

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-310.pyc
deleted file mode 100644
index 60bfbec7ece515c2213c7247625275dee4c7797c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5493
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

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/vgg.cpython-39.pyc
deleted file mode 100644
index 98225cbc36f655be44cd3ec2a071e38164b0bf57..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5965
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
SP6NOHm{xjh-w!UsY5G4q6q^|U

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-310.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-310.pyc
deleted file mode 100644
index bed5e6a80a177186b91ff9ccd15ab7be6f316389..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9518
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

diff --git a/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-39.pyc b/trail_detection_node/trail_detection_node/base_models/__pycache__/xception.cpython-39.pyc
deleted file mode 100644
index 85ec7e51a85d7127e84efe3e6a46a28b659b8906..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10103
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
X)r-~J)s1ScI#I1wUn+Y1dFFosldSwi

diff --git a/trail_detection_node/trail_detection_node/base_models/resnetv1b.py b/trail_detection_node/trail_detection_node/base_models/resnetv1b.py
deleted file mode 100644
index 21d67b7a..00000000
--- a/trail_detection_node/trail_detection_node/base_models/resnetv1b.py
+++ /dev/null
@@ -1,264 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.utils.model_zoo as model_zoo
-
-__all__ = ['ResNetV1b', 'resnet18_v1b', 'resnet34_v1b', 'resnet50_v1b',
-           'resnet101_v1b', 'resnet152_v1b', 'resnet152_v1s', 'resnet101_v1s', 'resnet50_v1s']
-
-model_urls = {
-    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
-    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
-    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
-    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
-    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
-}
-
-
-class BasicBlockV1b(nn.Module):
-    expansion = 1
-
-    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None,
-                 previous_dilation=1, norm_layer=nn.BatchNorm2d):
-        super(BasicBlockV1b, self).__init__()
-        self.conv1 = nn.Conv2d(inplanes, planes, 3, stride,
-                               dilation, dilation, bias=False)
-        self.bn1 = norm_layer(planes)
-        self.relu = nn.ReLU(True)
-        self.conv2 = nn.Conv2d(planes, planes, 3, 1, previous_dilation,
-                               dilation=previous_dilation, bias=False)
-        self.bn2 = norm_layer(planes)
-        self.downsample = downsample
-        self.stride = stride
-
-    def forward(self, x):
-        identity = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        out = self.bn2(out)
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-        out = self.relu(out)
-
-        return out
-
-
-class BottleneckV1b(nn.Module):
-    expansion = 4
-
-    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None,
-                 previous_dilation=1, norm_layer=nn.BatchNorm2d):
-        super(BottleneckV1b, self).__init__()
-        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
-        self.bn1 = norm_layer(planes)
-        self.conv2 = nn.Conv2d(planes, planes, 3, stride,
-                               dilation, dilation, bias=False)
-        self.bn2 = norm_layer(planes)
-        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
-        self.bn3 = norm_layer(planes * self.expansion)
-        self.relu = nn.ReLU(True)
-        self.downsample = downsample
-        self.stride = stride
-
-    def forward(self, x):
-        identity = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        out = self.bn2(out)
-        out = self.relu(out)
-
-        out = self.conv3(out)
-        out = self.bn3(out)
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-        out = self.relu(out)
-
-        return out
-
-
-class ResNetV1b(nn.Module):
-
-    def __init__(self, block, layers, num_classes=1000, dilated=True, deep_stem=False,
-                 zero_init_residual=False, norm_layer=nn.BatchNorm2d):
-        self.inplanes = 128 if deep_stem else 64
-        super(ResNetV1b, self).__init__()
-        if deep_stem:
-            self.conv1 = nn.Sequential(
-                nn.Conv2d(3, 64, 3, 2, 1, bias=False),
-                norm_layer(64),
-                nn.ReLU(True),
-                nn.Conv2d(64, 64, 3, 1, 1, bias=False),
-                norm_layer(64),
-                nn.ReLU(True),
-                nn.Conv2d(64, 128, 3, 1, 1, bias=False)
-            )
-        else:
-            self.conv1 = nn.Conv2d(3, 64, 7, 2, 3, bias=False)
-        self.bn1 = norm_layer(self.inplanes)
-        self.relu = nn.ReLU(True)
-        self.maxpool = nn.MaxPool2d(3, 2, 1)
-        self.layer1 = self._make_layer(block, 64, layers[0], norm_layer=norm_layer)
-        self.layer2 = self._make_layer(block, 128, layers[1], stride=2, norm_layer=norm_layer)
-        if dilated:
-            self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2, norm_layer=norm_layer)
-            self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4, norm_layer=norm_layer)
-        else:
-            self.layer3 = self._make_layer(block, 256, layers[2], stride=2, norm_layer=norm_layer)
-            self.layer4 = self._make_layer(block, 512, layers[3], stride=2, norm_layer=norm_layer)
-        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
-        self.fc = nn.Linear(512 * block.expansion, num_classes)
-
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-            elif isinstance(m, nn.BatchNorm2d):
-                nn.init.constant_(m.weight, 1)
-                nn.init.constant_(m.bias, 0)
-
-        if zero_init_residual:
-            for m in self.modules():
-                if isinstance(m, BottleneckV1b):
-                    nn.init.constant_(m.bn3.weight, 0)
-                elif isinstance(m, BasicBlockV1b):
-                    nn.init.constant_(m.bn2.weight, 0)
-
-    def _make_layer(self, block, planes, blocks, stride=1, dilation=1, norm_layer=nn.BatchNorm2d):
-        downsample = None
-        if stride != 1 or self.inplanes != planes * block.expansion:
-            downsample = nn.Sequential(
-                nn.Conv2d(self.inplanes, planes * block.expansion, 1, stride, bias=False),
-                norm_layer(planes * block.expansion),
-            )
-
-        layers = []
-        if dilation in (1, 2):
-            layers.append(block(self.inplanes, planes, stride, dilation=1, downsample=downsample,
-                                previous_dilation=dilation, norm_layer=norm_layer))
-        elif dilation == 4:
-            layers.append(block(self.inplanes, planes, stride, dilation=2, downsample=downsample,
-                                previous_dilation=dilation, norm_layer=norm_layer))
-        else:
-            raise RuntimeError("=> unknown dilation size: {}".format(dilation))
-        self.inplanes = planes * block.expansion
-        for _ in range(1, blocks):
-            layers.append(block(self.inplanes, planes, dilation=dilation,
-                                previous_dilation=dilation, norm_layer=norm_layer))
-
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.maxpool(x)
-
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-
-        x = self.avgpool(x)
-        x = x.view(x.size(0), -1)
-        x = self.fc(x)
-
-        return x
-
-
-def resnet18_v1b(pretrained=False, **kwargs):
-    model = ResNetV1b(BasicBlockV1b, [2, 2, 2, 2], **kwargs)
-    if pretrained:
-        old_dict = model_zoo.load_url(model_urls['resnet18'])
-        model_dict = model.state_dict()
-        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
-        model_dict.update(old_dict)
-        model.load_state_dict(model_dict)
-    return model
-
-
-def resnet34_v1b(pretrained=False, **kwargs):
-    model = ResNetV1b(BasicBlockV1b, [3, 4, 6, 3], **kwargs)
-    if pretrained:
-        old_dict = model_zoo.load_url(model_urls['resnet34'])
-        model_dict = model.state_dict()
-        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
-        model_dict.update(old_dict)
-        model.load_state_dict(model_dict)
-    return model
-
-
-def resnet50_v1b(pretrained=False, **kwargs):
-    model = ResNetV1b(BottleneckV1b, [3, 4, 6, 3], **kwargs)
-    if pretrained:
-        old_dict = model_zoo.load_url(model_urls['resnet50'])
-        model_dict = model.state_dict()
-        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
-        model_dict.update(old_dict)
-        model.load_state_dict(model_dict)
-    return model
-
-
-def resnet101_v1b(pretrained=False, **kwargs):
-    model = ResNetV1b(BottleneckV1b, [3, 4, 23, 3], **kwargs)
-    if pretrained:
-        old_dict = model_zoo.load_url(model_urls['resnet101'])
-        model_dict = model.state_dict()
-        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
-        model_dict.update(old_dict)
-        model.load_state_dict(model_dict)
-    return model
-
-
-def resnet152_v1b(pretrained=False, **kwargs):
-    model = ResNetV1b(BottleneckV1b, [3, 8, 36, 3], **kwargs)
-    if pretrained:
-        old_dict = model_zoo.load_url(model_urls['resnet152'])
-        model_dict = model.state_dict()
-        old_dict = {k: v for k, v in old_dict.items() if (k in model_dict)}
-        model_dict.update(old_dict)
-        model.load_state_dict(model_dict)
-    return model
-
-
-def resnet50_v1s(pretrained=False, root='~/.torch/models', **kwargs):
-    model = ResNetV1b(BottleneckV1b, [3, 4, 6, 3], deep_stem=True, **kwargs)
-    if pretrained:
-        from ..model_store import get_resnet_file
-        model.load_state_dict(torch.load(get_resnet_file('resnet50', root=root)), strict=False)
-    return model
-
-
-def resnet101_v1s(pretrained=False, root='~/.torch/models', **kwargs):
-    model = ResNetV1b(BottleneckV1b, [3, 4, 23, 3], deep_stem=True, **kwargs)
-    if pretrained:
-        from ..model_store import get_resnet_file
-        model.load_state_dict(torch.load(get_resnet_file('resnet101', root=root)), strict=False)
-    return model
-
-
-def resnet152_v1s(pretrained=False, root='~/.torch/models', **kwargs):
-    model = ResNetV1b(BottleneckV1b, [3, 8, 36, 3], deep_stem=True, **kwargs)
-    if pretrained:
-        from ..model_store import get_resnet_file
-        model.load_state_dict(torch.load(get_resnet_file('resnet152', root=root)), strict=False)
-    return model
-
-
-if __name__ == '__main__':
-    import torch
-
-    img = torch.randn(4, 3, 224, 224)
-    model = resnet50_v1b(True)
-    output = model(img)

From b3034b06ec99b6ae198b4bf28d3767b141bbb1c8 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:15:23 -0400
Subject: [PATCH 06/22] Delete
 trail_detection_node/trail_detection_node/GANav_visualizer.py

---
 .../trail_detection_node/GANav_visualizer.py  | 412 ------------------
 1 file changed, 412 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/GANav_visualizer.py

diff --git a/trail_detection_node/trail_detection_node/GANav_visualizer.py b/trail_detection_node/trail_detection_node/GANav_visualizer.py
deleted file mode 100644
index 9919553f..00000000
--- a/trail_detection_node/trail_detection_node/GANav_visualizer.py
+++ /dev/null
@@ -1,412 +0,0 @@
-import torch
-from .mmseg.apis import inference_segmentor, init_segmentor
-from PIL import Image as ImagePIL
-from torchvision import transforms
-import cv2
-import os
-
-import rclpy
-from rclpy.node import Node
-from geometry_msgs.msg import PoseStamped
-from sensor_msgs.msg import Image, PointCloud2
-import sensor_msgs_py.point_cloud2 as pc2
-import numpy as np
-import math
-from cv_bridge import CvBridge
-
-'''
-    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
-'''
-camera_transformation_k = np.array([
-    [628.5359544,0,676.9575694],
-    [0,627.7249542,532.7206716],
-    [0,0,1]])
-
-rotation_matrix = np.array([
-    [-0.007495781893,-0.0006277316155,0.9999717092],
-    [-0.9999516401,-0.006361853422,-0.007499625104],
-    [0.006366381192,-0.9999795662,-0.0005800141927]])
-
-rotation_matrix = rotation_matrix.T
-
-translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
-image_width=1280
-image_height=1024
-
-def convert_to_lidar_frame(uv_coordinate):
-    """
-    convert 2d camera coordinate + depth into 3d lidar frame
-    """
-    point_cloud = np.empty( (3,) , dtype=float)
-    point_cloud[2] = uv_coordinate[2]
-    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
-    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
-
-    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
-    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
-    point_cloud = inverse_camera_transformation_k @ point_cloud
-    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
-    return point_cloud
-
-def convert_to_camera_frame(point_cloud):
-    """
-    convert 3d lidar data into 2d coordinate of the camera frame + depth
-    """
-    length = point_cloud.shape[0]
-    translation = np.tile(translation_vector, (length, 1)).T
-    
-    point_cloud = point_cloud.T
-    point_cloud = rotation_matrix@point_cloud + translation
-    point_cloud = camera_transformation_k @ point_cloud
-
-    uv_coordinate = np.empty_like(point_cloud)
-
-    """
-    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
-    """
-    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
-    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
-    uv_coordinate[2] = point_cloud[2]
-
-    uv_depth = uv_coordinate[2, :]
-    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
-    return filtered_uv_coordinate
-
-def estimate_depth(x, y, np_2d_array):
-    """
-    estimate the depth by finding points closest to x,y from thhe 2d array
-    """
-    # Calculate the distance between each point and the target coordinates (x, y)
-    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
-
-    # Find the indices of the k nearest points
-    k = 5     # Number of nearest neighbors we want
-    closest_indices = np.argpartition(distances_sq, k)[:k]
-    pixel_distance_threshold = 2000
-
-    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
-    if len(valid_indices) == 0:
-        # lidar points disappears usually around 0.4m
-        distance_where_lidar_stops_working = -1
-        return distance_where_lidar_stops_working
-
-    filtered_indices = np.array(valid_indices)
-    # Get the depth value of the closest point
-    closest_depths = np_2d_array[2,filtered_indices]
-
-    return np.mean(closest_depths)
-
-def load_model(device):
-
-    config = "./trail_detection_node/trained_models/rugd_group6/ganav_rugd_6.py"
-    checkpoint = "./trail_detection_node/trained_models/rugd_group6/ganav_rugd_6.pth"
-    model = init_segmentor(config, checkpoint, device="cuda:0")
-    print('Finished loading model!')
-
-    return model
-
-def find_route(model, device, cv_image):    
-    result = inference_segmentor(model, cv_image)
-    result_np = np.vstack(result).astype(np.uint8)
-    pred = np.where(result_np == 0, 255, 0)
-
-    # # prediction visualize
-    # cv2.imshow('prediction',pred)
-    # cv2.waitKey(25)
-
-    route = np.zeros_like(pred)
-    # calculate the center line by taking the average
-    row_num = 0
-    for row in pred:
-        white_pixels = list(np.nonzero(row)[0])
-        if white_pixels:
-            average = (white_pixels[0] + white_pixels[-1]) / 2
-            route[row_num][round(average)] = 255
-        row_num = row_num + 1
-    return route, pred
-
-def equalize_hist_rgb(img):
-    # Split the image into its color channels
-    r, g, b = cv2.split(img)
-
-    # Equalize the histograms for each channel
-    r_eq = cv2.equalizeHist(r)
-    g_eq = cv2.equalizeHist(g)
-    b_eq = cv2.equalizeHist(b)
-
-    # Merge the channels
-    img_eq = cv2.merge((r_eq, g_eq, b_eq))
-    # img_eq = cv2.fastNlMeansDenoisingColored(img_eq,None,10,20,7,42)
-    # img_eq = cv2.GaussianBlur(img_eq, (25,25), 0)
-    return img_eq
-
-'''
-    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
-    it detects the trail in the image and sends the corresponding lidar position as the trail location.
-    The msgs are synchornized before processing, using buffer and sync function.
-    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
-    and choose to go to the closest point. 
-    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
-'''
-class trailDetector(Node):
-    def __init__(self, model, device):
-        super().__init__('trail_detector')
-        # define trail subscription
-        self.trail_publisher = self.create_publisher(
-            PoseStamped,
-            'trail_location',
-            10)
-        
-        # define camera subscription
-        self.camera_subscription = self.create_subscription(
-            Image,
-            'camera',
-            self.camera_callback,
-            10)
-        self.camera_subscription
-        
-        # define lidar subscription
-        self.lidar_subscription = self.create_subscription(
-            PointCloud2,
-            'velodyne_points',  
-            self.lidar_callback,
-            10)
-        self.lidar_subscription
-
-        self.bridge = CvBridge()
-
-        # load model and device
-        self.model = model
-        self.device = device
-
-        # buffers to hold msgs for sync
-        self.buffer_size = 50   # 30 is a random choice, to be discussed 
-        self.lidar_buffer = []
-        self.camera_buffer = []
-        self.only_camera_mode = True
-    
-    def camera_callback(self, msg):
-        if len(self.camera_buffer) >= self.buffer_size:
-            self.camera_buffer.pop(0)
-        self.camera_buffer.append(msg)
-        self.sync()
-
-    def lidar_callback(self, msg):           
-        if len(self.lidar_buffer) >= self.buffer_size:
-            self.lidar_buffer.pop(0)
-        self.lidar_buffer.append(msg)
-        self.sync()
-
-    def sync(self):
-        # if one of the sensor has no msg, then return
-        if self.only_camera_mode and self.camera_buffer:
-            camera_msg = self.camera_buffer[0]
-            self.camera_buffer.pop(0)
-            self.only_camera_callback(camera_msg)
-        elif not self.lidar_buffer or not self.camera_buffer:
-            return
-        
-        while self.lidar_buffer and self.camera_buffer:
-            lidar_msg = self.lidar_buffer[0]
-            camera_msg = self.camera_buffer[0]
-
-            time_tolerance = 20000000    # nanosec, random choice to be discussed
-            time_difference = abs(lidar_msg.header.stamp.nanosec - camera_msg.header.stamp.nanosec)
-            # print(time_difference)
-            
-            # compare the time difference, if it's within tolerance, then pass to the trail_callback, otherwise discard the older msg
-            if time_difference <= time_tolerance:
-                self.lidar_buffer.pop(0)
-                self.camera_buffer.pop(0)
-                self.get_logger().info("msgs received!")
-                self.trail_callback(lidar_msg, camera_msg)
-            elif lidar_msg.header.stamp.nanosec > camera_msg.header.stamp.nanosec:
-                self.camera_buffer.pop(0)
-            else:
-                self.lidar_buffer.pop(0)
-
-    def trail_callback(self, lidar_msg, camera_msg):
-        # process lidar msg
-        point_gen = pc2.read_points(
-            lidar_msg, field_names=(
-                "x", "y", "z"), skip_nans=True)
-        points = [[x, y, z] for x, y, z in point_gen]
-        points = np.array(points)
-        points2d = convert_to_camera_frame(points)
-
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-        
-        # increase brightness
-        M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
-        cv_image = cv2.add(cv_image, M)
-
-        # # image visualizer
-        # cv2.imshow('raw image',cv_image)
-        # cv2.waitKey(25)
-
-        route = find_route(self.model, self.device, cv_image)
-
-        # # visualize route purely
-        # cv2.imshow("white_route",route)
-        # cv2.waitKey(25)
-
-        route_indices = list(zip(*np.nonzero(route)))
-        if not route_indices:
-            print("No centerline found!")
-            return
-        
-        # #filter points that have no lidar points near it
-        # filtered_route_indices = []
-        # for index in route_indices:
-        #     point = []
-        #     point.append(index[0])
-        #     point.append(index[1])
-        #     point.append(estimate_depth(index[0], index[1], points2d))
-        #     if point[2] == -1:
-        #         continue
-        #     else:
-        #         filtered_route_indices.append(point)
-
-        # find the corresponding lidar points using the center line pixels
-        filtered_3dPoints = []
-        # for index in filtered_route_indices:
-        for index in route_indices:
-            point = []
-            # point.append(index[0])
-            # point.append(index[1])
-            # point.append(index[2])
-
-            point.append(index[0])
-            point.append(index[1])
-            point.append(estimate_depth(index[0], index[1], points2d))
-
-            point_3d = convert_to_lidar_frame(point)
-            filtered_3dPoints.append(point_3d)
-
-        filtered_3dPoints = np.array(filtered_3dPoints)
-        # find the nearest 3d point and set that as goal
-        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
-        smallest_index = np.argmin(distances_sq)
-        # print(math.sqrt(distances_sq[smallest_index]))
-        # smallest_index = np.argmin(filtered_3dPoints[:,2])
-
-        # visualize after-pocessed image
-        visualize_cv_image = cv_image
-        print(f"{visualize_cv_image.shape[0]}")
-        circle_x = route_indices[smallest_index][0]
-        circle_y = route_indices[smallest_index][1]
-        
-        # # visualize the lidar points in image
-        # uv_x, uv_y, uv_z = points2d
-        # for index_lidar in range(points2d.shape[1]):
-        #     # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
-        #     cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
-        
-        # visualize center line in image
-        for index_circle in range(len(route_indices)):
-            if index_circle == smallest_index:
-                continue
-            else:
-                red_circle_x = route_indices[index_circle][0]
-                red_circle_y = route_indices[index_circle][1]
-                cv2.circle(visualize_cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
-        
-        # visualize the chosen point in image
-        cv2.circle(visualize_cv_image, (circle_y, circle_x), radius=7, color=(0, 255, 0), thickness=-1)
-        cv2.circle(visualize_cv_image, (0, 0), radius=12, color=(0, 255, 0), thickness=-1)
-        
-        cv2.imshow('circled image',visualize_cv_image)
-        cv2.waitKey(25)
-
-        # publsih message
-        trail_location_msg = PoseStamped()
-        trail_location_msg.header.stamp = lidar_msg.header.stamp
-        trail_location_msg.header.frame_id = "velodyne"
-        #position
-        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
-        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
-        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
-        #orientation
-        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
-        trail_location_msg.pose.orientation.x = 0.0  
-        trail_location_msg.pose.orientation.y = 0.0 
-        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
-        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
-        self.get_logger().info("location published!")
-        self.trail_publisher.publish(trail_location_msg)
-        
-    def only_camera_callback(self, camera_msg):
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-
-        # cv_image = cv2.fastNlMeansDenoisingColored(cv_image,None,5,10,7,14)
-        
-        # # histogram equalization method 1
-        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2YCrCb)
-        # cv_image[:,:,0] = cv2.equalizeHist(cv_image[:,:,0])
-        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_YCrCb2BGR)
-
-        # # histogram equalization method 2
-        # cv_image = equalize_hist_rgb(cv_image)
-
-        # # histogram equalization method 3 CLAHE
-        # image_bw = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
-        # clahe = cv2.createCLAHE(clipLimit=5)
-        # cv_image = clahe.apply(image_bw) + 30
-
-        # # histogram equalization method 4 CLAHE
-        # cla = cv2.createCLAHE(clipLimit=4.0)
-        # H, S, V = cv2.split(cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV))
-        # eq_V = cla.apply(V)
-        # cv_image = cv2.cvtColor(cv2.merge([H, S, eq_V]), cv2.COLOR_HSV2BGR)
-
-        # # increase brightness
-        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
-        # cv_image = cv2.add(cv_image, M)
-
-        # # image visualizer
-        # cv2.imshow('raw image',cv_image)
-        # cv2.waitKey(25)
-
-        route, pred = find_route(self.model, self.device, cv_image)
-
-        # # visualize route purely
-        # cv2.imshow("white_route",route)
-        # cv2.waitKey(25)
-
-        # increase the brightness of image where is predicted as road
-        sign = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR)
-        cv_image = cv2.add(cv_image, sign)
-
-        route_indices = list(zip(*np.nonzero(route)))
-        if not route_indices:
-            print("No centerline found!")
-            return
-        
-        for index_circle in range(len(route_indices)):
-            red_circle_x = route_indices[index_circle][0]
-            red_circle_y = route_indices[index_circle][1]
-            cv2.circle(cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
-
-        cv2.imshow('circled image',cv_image)
-        cv2.waitKey(25)
-        
-
-
-
-def main(args=None):
-    print(torch.cuda.is_available())
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model = load_model(device)
-    
-    rclpy.init(args=args)
-    trailDetectorNode = trailDetector(model, device)
-    rclpy.spin(trailDetectorNode)
-
-    trailDetectorNode.destroy_node()
-    rclpy.shutdown()
-    cv2.destroyAllWindows()
-
-if __name__ == '__main__':
-    main()
\ No newline at end of file

From a5ea74b6ff3a1293d75d0adf19c8d9e332aad043 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:15:45 -0400
Subject: [PATCH 07/22] Delete trail_detection_node/trail_detection_node/jpu.py

---
 .../trail_detection_node/jpu.py               | 68 -------------------
 1 file changed, 68 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/jpu.py

diff --git a/trail_detection_node/trail_detection_node/jpu.py b/trail_detection_node/trail_detection_node/jpu.py
deleted file mode 100644
index db23bab8..00000000
--- a/trail_detection_node/trail_detection_node/jpu.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""Joint Pyramid Upsampling"""
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-__all__ = ['JPU']
-
-
-class SeparableConv2d(nn.Module):
-    def __init__(self, inplanes, planes, kernel_size=3, stride=1, padding=1,
-                 dilation=1, bias=False, norm_layer=nn.BatchNorm2d):
-        super(SeparableConv2d, self).__init__()
-        self.conv = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation, groups=inplanes, bias=bias)
-        self.bn = norm_layer(inplanes)
-        self.pointwise = nn.Conv2d(inplanes, planes, 1, bias=bias)
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        x = self.pointwise(x)
-        return x
-
-
-# copy from: https://github.com/wuhuikai/FastFCN/blob/master/encoding/nn/customize.py
-class JPU(nn.Module):
-    def __init__(self, in_channels, width=512, norm_layer=nn.BatchNorm2d, **kwargs):
-        super(JPU, self).__init__()
-
-        self.conv5 = nn.Sequential(
-            nn.Conv2d(in_channels[-1], width, 3, padding=1, bias=False),
-            norm_layer(width),
-            nn.ReLU(True))
-        self.conv4 = nn.Sequential(
-            nn.Conv2d(in_channels[-2], width, 3, padding=1, bias=False),
-            norm_layer(width),
-            nn.ReLU(True))
-        self.conv3 = nn.Sequential(
-            nn.Conv2d(in_channels[-3], width, 3, padding=1, bias=False),
-            norm_layer(width),
-            nn.ReLU(True))
-
-        self.dilation1 = nn.Sequential(
-            SeparableConv2d(3 * width, width, 3, padding=1, dilation=1, bias=False),
-            norm_layer(width),
-            nn.ReLU(True))
-        self.dilation2 = nn.Sequential(
-            SeparableConv2d(3 * width, width, 3, padding=2, dilation=2, bias=False),
-            norm_layer(width),
-            nn.ReLU(True))
-        self.dilation3 = nn.Sequential(
-            SeparableConv2d(3 * width, width, 3, padding=4, dilation=4, bias=False),
-            norm_layer(width),
-            nn.ReLU(True))
-        self.dilation4 = nn.Sequential(
-            SeparableConv2d(3 * width, width, 3, padding=8, dilation=8, bias=False),
-            norm_layer(width),
-            nn.ReLU(True))
-
-    def forward(self, *inputs):
-        feats = [self.conv5(inputs[-1]), self.conv4(inputs[-2]), self.conv3(inputs[-3])]
-        size = feats[-1].size()[2:]
-        feats[-2] = F.interpolate(feats[-2], size, mode='bilinear', align_corners=True)
-        feats[-3] = F.interpolate(feats[-3], size, mode='bilinear', align_corners=True)
-        feat = torch.cat(feats, dim=1)
-        feat = torch.cat([self.dilation1(feat), self.dilation2(feat), self.dilation3(feat), self.dilation4(feat)],
-                         dim=1)
-
-        return inputs[0], inputs[1], inputs[2], feat

From 4b7abe5485f4e4e0a6ca41d47296af7c068b9356 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:16:16 -0400
Subject: [PATCH 08/22] Delete
 trail_detection_node/trail_detection_node/model_store.py

---
 .../trail_detection_node/model_store.py       | 36 -------------------
 1 file changed, 36 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/model_store.py

diff --git a/trail_detection_node/trail_detection_node/model_store.py b/trail_detection_node/trail_detection_node/model_store.py
deleted file mode 100644
index a0193c79..00000000
--- a/trail_detection_node/trail_detection_node/model_store.py
+++ /dev/null
@@ -1,36 +0,0 @@
-"""Model store which provides pretrained models."""
-from __future__ import print_function
-
-import os
-import zipfile
-
-__all__ = ['get_model_file', 'get_resnet_file']
-
-_model_sha1 = {name: checksum for checksum, name in [
-    ('25c4b50959ef024fcc050213a06b614899f94b3d', 'resnet50'),
-    ('2a57e44de9c853fa015b172309a1ee7e2d0e4e2a', 'resnet101'),
-    ('0d43d698c66aceaa2bc0309f55efdd7ff4b143af', 'resnet152'),
-]}
-
-encoding_repo_url = 'https://hangzh.s3.amazonaws.com/'
-_url_format = '{repo_url}encoding/models/{file_name}.zip'
-
-
-def short_hash(name):
-    if name not in _model_sha1:
-        raise ValueError('Pretrained model for {name} is not available.'.format(name=name))
-    return _model_sha1[name][:8]
-
-
-def get_resnet_file(name, root='~/.torch/models'):
-    file_name = '{name}-{short_hash}'.format(name=name, short_hash=short_hash(name))
-    root = os.path.expanduser(root)
-
-    file_path = os.path.join(root, file_name + '.pth')
-    sha1_hash = _model_sha1[name]
-    if os.path.exists(file_path):
-        return file_path
-
-    else:
-        print('Model file {} is not found.'.format(file_path))
-

From f902b9ec500812f34de9710200072580d9addb8e Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:16:37 -0400
Subject: [PATCH 09/22] Delete
 trail_detection_node/trail_detection_node/segbase.py

---
 .../trail_detection_node/segbase.py           | 60 -------------------
 1 file changed, 60 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/segbase.py

diff --git a/trail_detection_node/trail_detection_node/segbase.py b/trail_detection_node/trail_detection_node/segbase.py
deleted file mode 100644
index ae417652..00000000
--- a/trail_detection_node/trail_detection_node/segbase.py
+++ /dev/null
@@ -1,60 +0,0 @@
-"""Base Model for Semantic Segmentation"""
-import torch.nn as nn
-
-from .jpu import JPU
-from .base_models.resnetv1b import resnet50_v1s, resnet101_v1s, resnet152_v1s
-
-__all__ = ['SegBaseModel']
-
-
-class SegBaseModel(nn.Module):
-    r"""Base Model for Semantic Segmentation
-
-    Parameters
-    ----------
-    backbone : string
-        Pre-trained dilated backbone network type (default:'resnet50'; 'resnet50',
-        'resnet101' or 'resnet152').
-    """
-
-    def __init__(self, nclass, aux, backbone='resnet50', jpu=False, pretrained_base=True, **kwargs):
-        super(SegBaseModel, self).__init__()
-        dilated = False if jpu else True
-        self.aux = aux
-        self.nclass = nclass
-        if backbone == 'resnet50':
-            self.pretrained = resnet50_v1s(pretrained=pretrained_base, dilated=dilated, **kwargs)
-        elif backbone == 'resnet101':
-            self.pretrained = resnet101_v1s(pretrained=pretrained_base, dilated=dilated, **kwargs)
-        elif backbone == 'resnet152':
-            self.pretrained = resnet152_v1s(pretrained=pretrained_base, dilated=dilated, **kwargs)
-        else:
-            raise RuntimeError('unknown backbone: {}'.format(backbone))
-
-        self.jpu = JPU([512, 1024, 2048], width=512, **kwargs) if jpu else None
-
-    def base_forward(self, x):
-        """forwarding pre-trained network"""
-        x = self.pretrained.conv1(x)
-        x = self.pretrained.bn1(x)
-        x = self.pretrained.relu(x)
-        x = self.pretrained.maxpool(x)
-        c1 = self.pretrained.layer1(x)
-        c2 = self.pretrained.layer2(c1)
-        c3 = self.pretrained.layer3(c2)
-        c4 = self.pretrained.layer4(c3)
-
-        if self.jpu:
-            return self.jpu(c1, c2, c3, c4)
-        else:
-            return c1, c2, c3, c4
-
-    def evaluate(self, x):
-        """evaluating network with inputs and targets"""
-        return self.forward(x)[0]
-
-    def demo(self, x):
-        pred = self.forward(x)
-        if self.aux:
-            pred = pred[0]
-        return pred

From 7fd0167d0ae7ffc59d342d4cc14e4ffd371f5669 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:16:50 -0400
Subject: [PATCH 10/22] Delete
 trail_detection_node/trail_detection_node/v1_trailDetectionNode.py

---
 .../v1_trailDetectionNode.py                  | 278 ------------------
 1 file changed, 278 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/v1_trailDetectionNode.py

diff --git a/trail_detection_node/trail_detection_node/v1_trailDetectionNode.py b/trail_detection_node/trail_detection_node/v1_trailDetectionNode.py
deleted file mode 100644
index c20f7df5..00000000
--- a/trail_detection_node/trail_detection_node/v1_trailDetectionNode.py
+++ /dev/null
@@ -1,278 +0,0 @@
-import torch
-from .model_loader import FCN8s
-from PIL import Image as ImagePIL
-from torchvision import transforms
-import cv2
-
-import rclpy
-from rclpy.node import Node
-from geometry_msgs.msg import PoseStamped
-from sensor_msgs.msg import Image, PointCloud2
-import sensor_msgs_py.point_cloud2 as pc2
-import numpy as np
-import math
-from cv_bridge import CvBridge
-
-'''
-    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
-'''
-camera_transformation_k = np.array([
-    [628.5359544,0,676.9575694],
-    [0,627.7249542,532.7206716],
-    [0,0,1]])
-
-rotation_matrix = np.array([
-    [-0.007495781893,-0.0006277316155,0.9999717092],
-    [-0.9999516401,-0.006361853422,-0.007499625104],
-    [0.006366381192,-0.9999795662,-0.0005800141927]])
-
-rotation_matrix = rotation_matrix.T
-
-translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
-image_width=1280
-image_height=1024
-
-def convert_to_lidar_frame(uv_coordinate):
-    """
-    convert 2d camera coordinate + depth into 3d lidar frame
-    """
-    point_cloud = np.empty( (3,) , dtype=float)
-    point_cloud[2] = uv_coordinate[2]
-    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
-    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
-
-    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
-    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
-    point_cloud = inverse_camera_transformation_k @ point_cloud
-    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
-    return point_cloud
-
-def convert_to_camera_frame(point_cloud):
-    """
-    convert 3d lidar data into 2d coordinate of the camera frame + depth
-    """
-    length = point_cloud.shape[0]
-    translation = np.tile(translation_vector, (length, 1)).T
-    
-    point_cloud = point_cloud.T
-    point_cloud = rotation_matrix@point_cloud + translation
-    point_cloud = camera_transformation_k @ point_cloud
-
-    uv_coordinate = np.empty_like(point_cloud)
-
-    """
-    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
-    """
-    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
-    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
-    uv_coordinate[2] = point_cloud[2]
-
-    uv_depth = uv_coordinate[2, :]
-    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
-    return filtered_uv_coordinate
-
-def estimate_depth(x, y, np_2d_array):
-    """
-    estimate the depth by finding points closest to x,y from thhe 2d array
-    """
-    # Calculate the distance between each point and the target coordinates (x, y)
-    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
-
-    # Find the indices of the k nearest points
-    k = 5     # Number of nearest neighbors we want
-    closest_indices = np.argpartition(distances_sq, k)[:k]
-    pixel_distance_threshold = 2000
-
-    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
-    if len(valid_indices) == 0:
-        # lidar points disappears usually around 0.4m
-        distance_where_lidar_stops_working = -1
-        return distance_where_lidar_stops_working
-
-    filtered_indices = np.array(valid_indices)
-    # Get the depth value of the closest point
-    closest_depths = np_2d_array[2,filtered_indices]
-
-    return np.mean(closest_depths)
-
-def load_model(device):
-    model = FCN8s(nclass=6, backbone='vgg16', pretrained_base=True, pretrained=True)
-    model.load_state_dict(torch.load('src/trail_detection_node/trail_detection_node/model/fcn8s_vgg16_pascal_voc.pth'))
-    model = model.to(device)
-    print('Finished loading model!')
-
-    return model
-
-def find_route(model, device, cv_image):
-    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
-    transform = transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
-    ])
-    image = transform(PIL_image).unsqueeze(0).to(device)
-    with torch.no_grad():
-        output = model(image)
-    # pred is prediction generated by the model, route is the variable for the center line
-    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
-    pred[pred != 1] = 0 # only see the trail
-    pred[pred == 1] = 255
-    pred = np.array(pred, dtype=np.uint8)
-    route = np.zeros_like(pred)
-    # calculate the center line by taking the average
-    row_num = 0
-    for row in pred:
-        white_pixels = list(np.nonzero(row)[0])
-        if white_pixels:
-            average = (white_pixels[0] + white_pixels[-1]) / 2
-            route[row_num][round(average)] = 255
-        row_num = row_num + 1
-    return route
-
-'''
-    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
-    it detects the trail in the image and sends the corresponding lidar position as the trail location.
-    The msgs are synchornized before processing, using buffer and sync function.
-    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
-    and choose to go to the closest point. 
-    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
-'''
-class trailDetector(Node):
-    def __init__(self, model, device):
-        super().__init__('trail_detector')
-        # define trail subscription
-        self.trail_publisher = self.create_publisher(
-            PoseStamped,
-            'trail_location',
-            10)
-        
-        # define camera subscription
-        self.camera_subscription = self.create_subscription(
-            Image,
-            'camera',
-            self.camera_callback,
-            10)
-        self.camera_subscription
-        
-        # define lidar subscription
-        self.lidar_subscription = self.create_subscription(
-            PointCloud2,
-            'velodyne_points',  
-            self.lidar_callback,
-            10)
-        self.lidar_subscription
-
-        self.bridge = CvBridge()
-
-        # load model and device
-        self.model = model
-        self.device = device
-
-        # buffers to hold msgs for sync
-        self.buffer_size = 30   # 30 is a random choice, to be discussed 
-        self.lidar_buffer = []
-        self.camera_buffer = []
-    
-    def camera_callback(self, msg):
-        if len(self.camera_buffer) >= self.buffer_size:
-            self.camera_buffer.pop(0)
-        self.camera_buffer.append(msg)
-        self.sync()
-
-    def lidar_callback(self, msg):           
-        if len(self.lidar_buffer) >= self.buffer_size:
-            self.lidar_buffer.pop(0)
-        self.lidar_buffer.append(msg)
-        self.sync()
-
-    def sync(self):
-        # if one of the sensor has no msg, then return
-        if not self.lidar_buffer or not self.camera_buffer:
-            return
-        
-        while self.lidar_buffer and self.camera_buffer:
-            lidar_msg = self.lidar_buffer[0]
-            camera_msg = self.camera_buffer[0]
-
-            time_tolerance = 5000000    # nanosec, random choice to be discussed
-            time_difference = abs(lidar_msg.header.stamp.nanosec - camera_msg.header.stamp.nanosec)
-            print(time_difference)
-            
-            # compare the time difference, if it's within tolerance, then pass to the trail_callback, otherwise discard the older msg
-            if time_difference <= time_tolerance:
-                self.lidar_buffer.pop(0)
-                self.camera_buffer.pop(0)
-                self.get_logger().info("msgs received!")
-                self.trail_callback(lidar_msg, camera_msg)
-            elif lidar_msg.header.stamp.nanosec > camera_msg.header.stamp.nanosec:
-                self.camera_buffer.pop(0)
-            else:
-                self.lidar_buffer.pop(0)
-
-    def trail_callback(self, lidar_msg, camera_msg):
-        # process lidar msg
-        point_gen = pc2.read_points(
-            lidar_msg, field_names=(
-                "x", "y", "z"), skip_nans=True)
-        points = [[x, y, z] for x, y, z in point_gen]
-        points = np.array(points)
-        points2d = convert_to_camera_frame(points)
-
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-        route = find_route(self.model, self.device, cv_image)
-        route_indices = list(zip(*np.nonzero(route)))
-
-        if not route_indices:
-            print("No centerline found!")
-            return
-
-        # find the corresponding lidar points using the center line pixels
-        filtered_3dPoints = []
-        for index in route_indices:
-            point = []
-            point.append(index[0])
-            point.append(index[1])
-            point.append(estimate_depth(index[0], index[1], points2d))
-            point_3d = convert_to_lidar_frame(point)
-            filtered_3dPoints.append(point_3d)
-
-        filtered_3dPoints = np.array(filtered_3dPoints)
-        # find the nearest 3d point and set that as goal
-        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
-        smallest_index = np.argmin(distances_sq)
-
-        # publsih message
-        trail_location_msg = PoseStamped()
-        trail_location_msg.header.stamp = lidar_msg.header.stamp
-        trail_location_msg.header.frame_id = "velodyne"
-        #position
-        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
-        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
-        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
-        #orientation
-        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
-        trail_location_msg.pose.orientation.x = 0.0  
-        trail_location_msg.pose.orientation.y = 0.0 
-        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
-        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
-        self.get_logger().info("location published!")
-        self.trail_publisher.publish(trail_location_msg)
-        
-        
-
-
-
-def main(args=None):
-    print(torch.cuda.is_available())
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model = load_model(device)
-    
-    rclpy.init(args=args)
-    trailDetectorNode = trailDetector(model, device)
-    rclpy.spin(trailDetectorNode)
-
-    trailDetectorNode.destroy_node()
-    rclpy.shutdown()
-
-if __name__ == '__main__':
-    main()
\ No newline at end of file

From ff03ab6f656896e7bf39772d3da28169dddefa9b Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:17:02 -0400
Subject: [PATCH 11/22] Delete
 trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py

---
 .../visualizer_v1_trailDetectionNode.py       | 431 ------------------
 1 file changed, 431 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py

diff --git a/trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py b/trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py
deleted file mode 100644
index 616b689d..00000000
--- a/trail_detection_node/trail_detection_node/visualizer_v1_trailDetectionNode.py
+++ /dev/null
@@ -1,431 +0,0 @@
-import torch
-from .model_loader import FCN8s, FCN32s
-from PIL import Image as ImagePIL
-from torchvision import transforms
-import cv2
-import os
-
-import rclpy
-from rclpy.node import Node
-from geometry_msgs.msg import PoseStamped
-from sensor_msgs.msg import Image, PointCloud2
-import sensor_msgs_py.point_cloud2 as pc2
-import numpy as np
-import math
-from cv_bridge import CvBridge
-
-'''
-    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
-'''
-camera_transformation_k = np.array([
-    [628.5359544,0,676.9575694],
-    [0,627.7249542,532.7206716],
-    [0,0,1]])
-
-rotation_matrix = np.array([
-    [-0.007495781893,-0.0006277316155,0.9999717092],
-    [-0.9999516401,-0.006361853422,-0.007499625104],
-    [0.006366381192,-0.9999795662,-0.0005800141927]])
-
-rotation_matrix = rotation_matrix.T
-
-translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
-image_width=1280
-image_height=1024
-
-def convert_to_lidar_frame(uv_coordinate):
-    """
-    convert 2d camera coordinate + depth into 3d lidar frame
-    """
-    point_cloud = np.empty( (3,) , dtype=float)
-    point_cloud[2] = uv_coordinate[2]
-    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
-    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
-
-    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
-    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
-    point_cloud = inverse_camera_transformation_k @ point_cloud
-    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
-    return point_cloud
-
-def convert_to_camera_frame(point_cloud):
-    """
-    convert 3d lidar data into 2d coordinate of the camera frame + depth
-    """
-    length = point_cloud.shape[0]
-    translation = np.tile(translation_vector, (length, 1)).T
-    
-    point_cloud = point_cloud.T
-    point_cloud = rotation_matrix@point_cloud + translation
-    point_cloud = camera_transformation_k @ point_cloud
-
-    uv_coordinate = np.empty_like(point_cloud)
-
-    """
-    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
-    """
-    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
-    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
-    uv_coordinate[2] = point_cloud[2]
-
-    uv_depth = uv_coordinate[2, :]
-    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
-    return filtered_uv_coordinate
-
-def estimate_depth(x, y, np_2d_array):
-    """
-    estimate the depth by finding points closest to x,y from thhe 2d array
-    """
-    # Calculate the distance between each point and the target coordinates (x, y)
-    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
-
-    # Find the indices of the k nearest points
-    k = 5     # Number of nearest neighbors we want
-    closest_indices = np.argpartition(distances_sq, k)[:k]
-    pixel_distance_threshold = 2000
-
-    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
-    if len(valid_indices) == 0:
-        # lidar points disappears usually around 0.4m
-        distance_where_lidar_stops_working = -1
-        return distance_where_lidar_stops_working
-
-    filtered_indices = np.array(valid_indices)
-    # Get the depth value of the closest point
-    closest_depths = np_2d_array[2,filtered_indices]
-
-    return np.mean(closest_depths)
-
-def load_model(device):
-    model = FCN32s(nclass=2, backbone='vgg16', pretrained_base=True, pretrained=True)
-    # model_location = '32s_batch8/fcn32s_vgg16_pascal_voc_best_model.pth'
-    model_location = '500epoch/fcn32s_vgg16_pascal_voc.pth'
-    if os.path.isfile(f'src/trail_detection_node/trail_detection_node/model/{model_location}'):
-        model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
-    else:
-        model.load_state_dict(torch.load(f'trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
-    model = model.to(device)
-    print('Finished loading model!')
-
-    return model
-
-def find_route(model, device, cv_image):
-    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
-    transform = transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
-    ])
-    image = transform(PIL_image).unsqueeze(0).to(device)
-    with torch.no_grad():
-        output = model(image)
-    # pred is prediction generated by the model, route is the variable for the center line
-    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
-    pred[pred == 0] = 255 # only see the trail
-    pred[pred == 1] = 0
-    pred[pred == 2] = 0
-    pred[pred == 3] = 0
-    pred[pred == 4] = 0
-    pred[pred == 5] = 0    
-    pred = np.array(pred, dtype=np.uint8)
-    
-    # # prediction visualize
-    # cv2.imshow('prediction',pred)
-    # cv2.waitKey(25)
-
-    route = np.zeros_like(pred)
-    # calculate the center line by taking the average
-    row_num = 0
-    for row in pred:
-        white_pixels = list(np.nonzero(row)[0])
-        if white_pixels:
-            average = (white_pixels[0] + white_pixels[-1]) / 2
-            route[row_num][round(average)] = 255
-        row_num = row_num + 1
-    return route, pred
-
-def equalize_hist_rgb(img):
-    # Split the image into its color channels
-    r, g, b = cv2.split(img)
-
-    # Equalize the histograms for each channel
-    r_eq = cv2.equalizeHist(r)
-    g_eq = cv2.equalizeHist(g)
-    b_eq = cv2.equalizeHist(b)
-
-    # Merge the channels
-    img_eq = cv2.merge((r_eq, g_eq, b_eq))
-    # img_eq = cv2.fastNlMeansDenoisingColored(img_eq,None,10,20,7,42)
-    # img_eq = cv2.GaussianBlur(img_eq, (25,25), 0)
-    return img_eq
-
-'''
-    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
-    it detects the trail in the image and sends the corresponding lidar position as the trail location.
-    The msgs are synchornized before processing, using buffer and sync function.
-    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
-    and choose to go to the closest point. 
-    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
-'''
-class trailDetector(Node):
-    def __init__(self, model, device):
-        super().__init__('trail_detector')
-        # define trail subscription
-        self.trail_publisher = self.create_publisher(
-            PoseStamped,
-            'trail_location',
-            10)
-        
-        # define camera subscription
-        self.camera_subscription = self.create_subscription(
-            Image,
-            'camera',
-            self.camera_callback,
-            10)
-        self.camera_subscription
-        
-        # define lidar subscription
-        self.lidar_subscription = self.create_subscription(
-            PointCloud2,
-            'velodyne_points',  
-            self.lidar_callback,
-            10)
-        self.lidar_subscription
-
-        self.bridge = CvBridge()
-
-        # load model and device
-        self.model = model
-        self.device = device
-
-        # buffers to hold msgs for sync
-        self.buffer_size = 50   # 30 is a random choice, to be discussed 
-        self.lidar_buffer = []
-        self.camera_buffer = []
-        self.only_camera_mode = False
-    
-    def camera_callback(self, msg):
-        if len(self.camera_buffer) >= self.buffer_size:
-            self.camera_buffer.pop(0)
-        self.camera_buffer.append(msg)
-        self.sync()
-
-    def lidar_callback(self, msg):           
-        if len(self.lidar_buffer) >= self.buffer_size:
-            self.lidar_buffer.pop(0)
-        self.lidar_buffer.append(msg)
-        self.sync()
-
-    def sync(self):
-        # if one of the sensor has no msg, then return
-        if self.only_camera_mode and self.camera_buffer:
-            camera_msg = self.camera_buffer[0]
-            self.camera_buffer.pop(0)
-            self.only_camera_callback(camera_msg)
-        elif not self.lidar_buffer or not self.camera_buffer:
-            return
-        
-        while self.lidar_buffer and self.camera_buffer:
-            lidar_msg = self.lidar_buffer[0]
-            camera_msg = self.camera_buffer[0]
-
-            time_tolerance = 20000000    # nanosec, random choice to be discussed
-            time_difference = abs(lidar_msg.header.stamp.nanosec - camera_msg.header.stamp.nanosec)
-            # print(time_difference)
-            
-            # compare the time difference, if it's within tolerance, then pass to the trail_callback, otherwise discard the older msg
-            if time_difference <= time_tolerance:
-                self.lidar_buffer.pop(0)
-                self.camera_buffer.pop(0)
-                self.get_logger().info("msgs received!")
-                self.trail_callback(lidar_msg, camera_msg)
-            elif lidar_msg.header.stamp.nanosec > camera_msg.header.stamp.nanosec:
-                self.camera_buffer.pop(0)
-            else:
-                self.lidar_buffer.pop(0)
-
-    def trail_callback(self, lidar_msg, camera_msg):
-        # process lidar msg
-        point_gen = pc2.read_points(
-            lidar_msg, field_names=(
-                "x", "y", "z"), skip_nans=True)
-        points = [[x, y, z] for x, y, z in point_gen]
-        points = np.array(points)
-        points2d = convert_to_camera_frame(points)
-
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-        
-        # increase brightness
-        M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
-        cv_image = cv2.add(cv_image, M)
-
-        # # image visualizer
-        # cv2.imshow('raw image',cv_image)
-        # cv2.waitKey(25)
-
-        route = find_route(self.model, self.device, cv_image)
-
-        # # visualize route purely
-        # cv2.imshow("white_route",route)
-        # cv2.waitKey(25)
-
-        route_indices = list(zip(*np.nonzero(route)))
-        if not route_indices:
-            print("No centerline found!")
-            return
-        
-        # #filter points that have no lidar points near it
-        # filtered_route_indices = []
-        # for index in route_indices:
-        #     point = []
-        #     point.append(index[0])
-        #     point.append(index[1])
-        #     point.append(estimate_depth(index[0], index[1], points2d))
-        #     if point[2] == -1:
-        #         continue
-        #     else:
-        #         filtered_route_indices.append(point)
-
-        # find the corresponding lidar points using the center line pixels
-        filtered_3dPoints = []
-        # for index in filtered_route_indices:
-        for index in route_indices:
-            point = []
-            # point.append(index[0])
-            # point.append(index[1])
-            # point.append(index[2])
-
-            point.append(index[0])
-            point.append(index[1])
-            point.append(estimate_depth(index[0], index[1], points2d))
-
-            point_3d = convert_to_lidar_frame(point)
-            filtered_3dPoints.append(point_3d)
-
-        filtered_3dPoints = np.array(filtered_3dPoints)
-        # find the nearest 3d point and set that as goal
-        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
-        smallest_index = np.argmin(distances_sq)
-        # print(math.sqrt(distances_sq[smallest_index]))
-        # smallest_index = np.argmin(filtered_3dPoints[:,2])
-
-        # visualize after-pocessed image
-        visualize_cv_image = cv_image
-        print(f"{visualize_cv_image.shape[0]}")
-        circle_x = route_indices[smallest_index][0]
-        circle_y = route_indices[smallest_index][1]
-        
-        # # visualize the lidar points in image
-        # uv_x, uv_y, uv_z = points2d
-        # for index_lidar in range(points2d.shape[1]):
-        #     # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
-        #     cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
-        
-        # visualize center line in image
-        for index_circle in range(len(route_indices)):
-            if index_circle == smallest_index:
-                continue
-            else:
-                red_circle_x = route_indices[index_circle][0]
-                red_circle_y = route_indices[index_circle][1]
-                cv2.circle(visualize_cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
-        
-        # visualize the chosen point in image
-        cv2.circle(visualize_cv_image, (circle_y, circle_x), radius=7, color=(0, 255, 0), thickness=-1)
-        cv2.circle(visualize_cv_image, (0, 0), radius=12, color=(0, 255, 0), thickness=-1)
-        
-        cv2.imshow('circled image',visualize_cv_image)
-        cv2.waitKey(25)
-
-        # publsih message
-        trail_location_msg = PoseStamped()
-        trail_location_msg.header.stamp = lidar_msg.header.stamp
-        trail_location_msg.header.frame_id = "velodyne"
-        #position
-        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
-        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
-        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
-        #orientation
-        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
-        trail_location_msg.pose.orientation.x = 0.0  
-        trail_location_msg.pose.orientation.y = 0.0 
-        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
-        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
-        self.get_logger().info("location published!")
-        self.trail_publisher.publish(trail_location_msg)
-        
-    def only_camera_callback(self, camera_msg):
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-        # cv_image = cv2.resize(cv_image,(480,480))
-
-        # cv_image = cv2.fastNlMeansDenoisingColored(cv_image,None,5,5,5,11)
-        
-        # # histogram equalization method 1
-        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2YCrCb)
-        # cv_image[:,:,0] = cv2.equalizeHist(cv_image[:,:,0])
-        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_YCrCb2BGR)
-
-        # histogram equalization method 2
-        # cv_image = equalize_hist_rgb(cv_image)
-
-        # # histogram equalization method 3 CLAHE
-        # image_bw = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
-        # clahe = cv2.createCLAHE(clipLimit=5)
-        # cv_image = clahe.apply(image_bw) + 30
-
-        # # histogram equalization method 4 CLAHE
-        # cla = cv2.createCLAHE(clipLimit=4.0)
-        # H, S, V = cv2.split(cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV))
-        # eq_V = cla.apply(V)
-        # cv_image = cv2.cvtColor(cv2.merge([H, S, eq_V]), cv2.COLOR_HSV2BGR)
-
-        # # increase brightness
-        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
-        # cv_image = cv2.add(cv_image, M)
-
-        # # image visualizer
-        # cv2.imshow('raw image',cv_image)
-        # cv2.waitKey(25)
-
-        route, pred = find_route(self.model, self.device, cv_image)
-
-        # # visualize route purely
-        # cv2.imshow("white_route",route)
-        # cv2.waitKey(25)
-
-        # increase the brightness of image where is predicted as road
-        sign = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR)
-        cv_image = cv2.add(cv_image, sign)
-
-        route_indices = list(zip(*np.nonzero(route)))
-        if not route_indices:
-            print("No centerline found!")
-            return
-        
-        # for index_circle in range(len(route_indices)):
-        #     red_circle_x = route_indices[index_circle][0]
-        #     red_circle_y = route_indices[index_circle][1]
-        #     cv2.circle(cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
-
-        cv2.imshow('circled image',cv_image)
-        cv2.waitKey(25)
-        
-
-
-
-def main(args=None):
-    print(torch.cuda.is_available())
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model = load_model(device)
-    
-    rclpy.init(args=args)
-    trailDetectorNode = trailDetector(model, device)
-    rclpy.spin(trailDetectorNode)
-
-    trailDetectorNode.destroy_node()
-    rclpy.shutdown()
-    cv2.destroyAllWindows()
-
-if __name__ == '__main__':
-    main()

From de2828e5b81e793d2650b9612555599fd1793edd Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:17:10 -0400
Subject: [PATCH 12/22] Delete trail_detection_node/trail_detection_node/vgg.py

---
 .../trail_detection_node/vgg.py               | 191 ------------------
 1 file changed, 191 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/vgg.py

diff --git a/trail_detection_node/trail_detection_node/vgg.py b/trail_detection_node/trail_detection_node/vgg.py
deleted file mode 100644
index fe5c163c..00000000
--- a/trail_detection_node/trail_detection_node/vgg.py
+++ /dev/null
@@ -1,191 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.utils.model_zoo as model_zoo
-
-__all__ = [
-    'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
-    'vgg19_bn', 'vgg19',
-]
-
-model_urls = {
-    'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
-    'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
-    'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
-    'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
-    'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
-    'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
-    'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
-    'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',
-}
-
-
-class VGG(nn.Module):
-    def __init__(self, features, num_classes=1000, init_weights=True):
-        super(VGG, self).__init__()
-        self.features = features
-        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
-        self.classifier = nn.Sequential(
-            nn.Linear(512 * 7 * 7, 4096),
-            nn.ReLU(True),
-            nn.Dropout(),
-            nn.Linear(4096, 4096),
-            nn.ReLU(True),
-            nn.Dropout(),
-            nn.Linear(4096, num_classes)
-        )
-        if init_weights:
-            self._initialize_weights()
-
-    def forward(self, x):
-        x = self.features(x)
-        x = self.avgpool(x)
-        x = x.view(x.size(0), -1)
-        x = self.classifier(x)
-        return x
-
-    def _initialize_weights(self):
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.BatchNorm2d):
-                nn.init.constant_(m.weight, 1)
-                nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, 0, 0.01)
-                nn.init.constant_(m.bias, 0)
-
-
-def make_layers(cfg, batch_norm=False):
-    layers = []
-    in_channels = 3
-    for v in cfg:
-        if v == 'M':
-            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
-        else:
-            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
-            if batch_norm:
-                layers += (conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True))
-            else:
-                layers += [conv2d, nn.ReLU(inplace=True)]
-            in_channels = v
-    return nn.Sequential(*layers)
-
-
-cfg = {
-    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
-    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
-    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
-    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
-}
-
-
-def vgg11(pretrained=False, **kwargs):
-    """VGG 11-layer model (configuration "A")
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['A']), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg11']))
-    return model
-
-
-def vgg11_bn(pretrained=False, **kwargs):
-    """VGG 11-layer model (configuration "A") with batch normalization
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['A'], batch_norm=True), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg11_bn']))
-    return model
-
-
-def vgg13(pretrained=False, **kwargs):
-    """VGG 13-layer model (configuration "B")
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['B']), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg13']))
-    return model
-
-
-def vgg13_bn(pretrained=False, **kwargs):
-    """VGG 13-layer model (configuration "B") with batch normalization
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['B'], batch_norm=True), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg13_bn']))
-    return model
-
-
-def vgg16(pretrained=False, **kwargs):
-    """VGG 16-layer model (configuration "D")
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['D']), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg16']))
-    return model
-
-
-def vgg16_bn(pretrained=False, **kwargs):
-    """VGG 16-layer model (configuration "D") with batch normalization
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['D'], batch_norm=True), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg16_bn']))
-    return model
-
-
-def vgg19(pretrained=False, **kwargs):
-    """VGG 19-layer model (configuration "E")
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['E']), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg19']))
-    return model
-
-
-def vgg19_bn(pretrained=False, **kwargs):
-    """VGG 19-layer model (configuration 'E') with batch normalization
-    Args:
-        pretrained (bool): If True, returns a model pre-trained on ImageNet
-    """
-    if pretrained:
-        kwargs['init_weights'] = False
-    model = VGG(make_layers(cfg['E'], batch_norm=True), **kwargs)
-    if pretrained:
-        model.load_state_dict(model_zoo.load_url(model_urls['vgg19_bn']))
-    return model
-
-
-if __name__ == '__main__':
-    img = torch.randn((4, 3, 480, 480))
-    model = vgg16(pretrained=False)
-    out = model(img)

From 7e21927f85bfab9068047782c082ef4dcf61fad3 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:17:46 -0400
Subject: [PATCH 13/22] merged all the model loading part into one file

---
 .../trail_detection_node/model_loader.py      | 350 ++++++++++++++----
 1 file changed, 285 insertions(+), 65 deletions(-)

diff --git a/trail_detection_node/trail_detection_node/model_loader.py b/trail_detection_node/trail_detection_node/model_loader.py
index 6c8e2399..d8934ae3 100644
--- a/trail_detection_node/trail_detection_node/model_loader.py
+++ b/trail_detection_node/trail_detection_node/model_loader.py
@@ -1,90 +1,310 @@
 import torch.nn as nn
 import torch.nn.functional as F
-from .vgg import vgg16
 
 import torch
-from .segbase import SegBaseModel
-
-class FCN8s(nn.Module):
-    def __init__(self, nclass, backbone='vgg16', aux=False, pretrained_base=True, norm_layer=nn.BatchNorm2d, **kwargs):
-        super(FCN8s, self).__init__()
-        self.aux = aux
-        if backbone == 'vgg16':
-            self.pretrained = vgg16(pretrained=pretrained_base).features
-        else:
-            raise RuntimeError('unknown backbone: {}'.format(backbone))
-        self.pool3 = nn.Sequential(*self.pretrained[:17])
-        self.pool4 = nn.Sequential(*self.pretrained[17:24])
-        self.pool5 = nn.Sequential(*self.pretrained[24:])
-        self.head = _FCNHead(512, nclass, norm_layer)
-        self.score_pool3 = nn.Conv2d(256, nclass, 1)
-        self.score_pool4 = nn.Conv2d(512, nclass, 1)
-        if aux:
-            self.auxlayer = _FCNHead(512, nclass, norm_layer)
-
-        self.__setattr__('exclusive',
-                         ['head', 'score_pool3', 'score_pool4', 'auxlayer'] if aux else ['head', 'score_pool3',
-                                                                                         'score_pool4'])
+import os
+
+# all the code below are copied from https://github.com/Tramac/awesome-semantic-segmentation-pytorch
+
+class BasicBlockV1b(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None,
+                 previous_dilation=1, norm_layer=nn.BatchNorm2d):
+        super(BasicBlockV1b, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, 3, stride,
+                               dilation, dilation, bias=False)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(True)
+        self.conv2 = nn.Conv2d(planes, planes, 3, 1, previous_dilation,
+                               dilation=previous_dilation, bias=False)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
 
     def forward(self, x):
-        pool3 = self.pool3(x)
-        pool4 = self.pool4(pool3)
-        pool5 = self.pool5(pool4)
+        identity = x
 
-        outputs = []
-        score_fr = self.head(pool5)
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
 
-        score_pool4 = self.score_pool4(pool4)
-        score_pool3 = self.score_pool3(pool3)
+        out = self.conv2(out)
+        out = self.bn2(out)
 
-        upscore2 = F.interpolate(score_fr, score_pool4.size()[2:], mode='bilinear', align_corners=True)
-        fuse_pool4 = upscore2 + score_pool4
+        if self.downsample is not None:
+            identity = self.downsample(x)
 
-        upscore_pool4 = F.interpolate(fuse_pool4, score_pool3.size()[2:], mode='bilinear', align_corners=True)
-        fuse_pool3 = upscore_pool4 + score_pool3
+        out += identity
+        out = self.relu(out)
 
-        out = F.interpolate(fuse_pool3, x.size()[2:], mode='bilinear', align_corners=True)
-        outputs.append(out)
+        return out
 
-        if self.aux:
-            auxout = self.auxlayer(pool5)
-            auxout = F.interpolate(auxout, x.size()[2:], mode='bilinear', align_corners=True)
-            outputs.append(auxout)
 
-        return tuple(outputs)
+class BottleneckV1b(nn.Module):
+    expansion = 4
 
-class FCN32s(nn.Module):
-    """There are some difference from original fcn"""
+    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None,
+                 previous_dilation=1, norm_layer=nn.BatchNorm2d):
+        super(BottleneckV1b, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
+        self.bn1 = norm_layer(planes)
+        self.conv2 = nn.Conv2d(planes, planes, 3, stride,
+                               dilation, dilation, bias=False)
+        self.bn2 = norm_layer(planes)
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(True)
+        self.downsample = downsample
+        self.stride = stride
 
-    def __init__(self, nclass, backbone='vgg16', aux=False, pretrained_base=True,
-                 norm_layer=nn.BatchNorm2d, **kwargs):
-        super(FCN32s, self).__init__()
-        self.aux = aux
-        if backbone == 'vgg16':
-            self.pretrained = vgg16(pretrained=pretrained_base).features
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+class ResNetV1b(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, dilated=True, deep_stem=False,
+                 zero_init_residual=False, norm_layer=nn.BatchNorm2d):
+        self.inplanes = 128 if deep_stem else 64
+        super(ResNetV1b, self).__init__()
+        if deep_stem:
+            self.conv1 = nn.Sequential(
+                nn.Conv2d(3, 64, 3, 2, 1, bias=False),
+                norm_layer(64),
+                nn.ReLU(True),
+                nn.Conv2d(64, 64, 3, 1, 1, bias=False),
+                norm_layer(64),
+                nn.ReLU(True),
+                nn.Conv2d(64, 128, 3, 1, 1, bias=False)
+            )
         else:
-            raise RuntimeError('unknown backbone: {}'.format(backbone))
-        self.head = _FCNHead(512, nclass, norm_layer)
-        if aux:
-            self.auxlayer = _FCNHead(512, nclass, norm_layer)
+            self.conv1 = nn.Conv2d(3, 64, 7, 2, 3, bias=False)
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(True)
+        self.maxpool = nn.MaxPool2d(3, 2, 1)
+        self.layer1 = self._make_layer(block, 64, layers[0], norm_layer=norm_layer)
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2, norm_layer=norm_layer)
+        if dilated:
+            self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2, norm_layer=norm_layer)
+            self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4, norm_layer=norm_layer)
+        else:
+            self.layer3 = self._make_layer(block, 256, layers[2], stride=2, norm_layer=norm_layer)
+            self.layer4 = self._make_layer(block, 512, layers[3], stride=2, norm_layer=norm_layer)
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, BottleneckV1b):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlockV1b):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilation=1, norm_layer=nn.BatchNorm2d):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion, 1, stride, bias=False),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        if dilation in (1, 2):
+            layers.append(block(self.inplanes, planes, stride, dilation=1, downsample=downsample,
+                                previous_dilation=dilation, norm_layer=norm_layer))
+        elif dilation == 4:
+            layers.append(block(self.inplanes, planes, stride, dilation=2, downsample=downsample,
+                                previous_dilation=dilation, norm_layer=norm_layer))
+        else:
+            raise RuntimeError("=> unknown dilation size: {}".format(dilation))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes, dilation=dilation,
+                                previous_dilation=dilation, norm_layer=norm_layer))
 
-        self.__setattr__('exclusive', ['head', 'auxlayer'] if aux else ['head'])
+        return nn.Sequential(*layers)
 
     def forward(self, x):
-        size = x.size()[2:]
-        pool5 = self.pretrained(x)
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+        return x
+
+_model_sha1 = {name: checksum for checksum, name in [
+    ('25c4b50959ef024fcc050213a06b614899f94b3d', 'resnet50'),
+    ('2a57e44de9c853fa015b172309a1ee7e2d0e4e2a', 'resnet101'),
+    ('0d43d698c66aceaa2bc0309f55efdd7ff4b143af', 'resnet152'),
+]}
+
+def short_hash(name):
+    if name not in _model_sha1:
+        raise ValueError('Pretrained model for {name} is not available.'.format(name=name))
+    return _model_sha1[name][:8]
+
+def get_resnet_file(name, root='~/.torch/models'):
+    file_name = '{name}-{short_hash}'.format(name=name, short_hash=short_hash(name))
+    root = os.path.expanduser(root)
+
+    file_path = os.path.join(root, file_name + '.pth')
+    sha1_hash = _model_sha1[name]
+    if os.path.exists(file_path):
+        return file_path
+
+    else:
+        print('Model file {} is not found.'.format(file_path))
+
+def resnet50_v1s(pretrained=False, root='~/.torch/models', **kwargs):
+    model = ResNetV1b(BottleneckV1b, [3, 4, 6, 3], deep_stem=True, **kwargs)
+    if pretrained:
+        model.load_state_dict(torch.load(get_resnet_file('resnet50', root=root)), strict=False)
+    return model
+
+class SeparableConv2d(nn.Module):
+    def __init__(self, inplanes, planes, kernel_size=3, stride=1, padding=1,
+                 dilation=1, bias=False, norm_layer=nn.BatchNorm2d):
+        super(SeparableConv2d, self).__init__()
+        self.conv = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation, groups=inplanes, bias=bias)
+        self.bn = norm_layer(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, bias=bias)
 
-        outputs = []
-        out = self.head(pool5)
-        out = F.interpolate(out, size, mode='bilinear', align_corners=True)
-        outputs.append(out)
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        x = self.pointwise(x)
+        return x
+
+# copy from: https://github.com/wuhuikai/FastFCN/blob/master/encoding/nn/customize.py
+class JPU(nn.Module):
+    def __init__(self, in_channels, width=512, norm_layer=nn.BatchNorm2d, **kwargs):
+        super(JPU, self).__init__()
+
+        self.conv5 = nn.Sequential(
+            nn.Conv2d(in_channels[-1], width, 3, padding=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.conv4 = nn.Sequential(
+            nn.Conv2d(in_channels[-2], width, 3, padding=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(in_channels[-3], width, 3, padding=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+
+        self.dilation1 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=1, dilation=1, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.dilation2 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=2, dilation=2, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.dilation3 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=4, dilation=4, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+        self.dilation4 = nn.Sequential(
+            SeparableConv2d(3 * width, width, 3, padding=8, dilation=8, bias=False),
+            norm_layer(width),
+            nn.ReLU(True))
+
+    def forward(self, *inputs):
+        feats = [self.conv5(inputs[-1]), self.conv4(inputs[-2]), self.conv3(inputs[-3])]
+        size = feats[-1].size()[2:]
+        feats[-2] = F.interpolate(feats[-2], size, mode='bilinear', align_corners=True)
+        feats[-3] = F.interpolate(feats[-3], size, mode='bilinear', align_corners=True)
+        feat = torch.cat(feats, dim=1)
+        feat = torch.cat([self.dilation1(feat), self.dilation2(feat), self.dilation3(feat), self.dilation4(feat)],
+                         dim=1)
+
+        return inputs[0], inputs[1], inputs[2], feat
+
+
+
+class SegBaseModel(nn.Module):
+    r"""Base Model for Semantic Segmentation
 
-        if self.aux:
-            auxout = self.auxlayer(pool5)
-            auxout = F.interpolate(auxout, size, mode='bilinear', align_corners=True)
-            outputs.append(auxout)
+    Parameters
+    ----------
+    backbone : string
+        Pre-trained dilated backbone network type (default:'resnet50'; 'resnet50',
+        'resnet101' or 'resnet152').
+    """
 
-        return tuple(outputs)
+    def __init__(self, nclass, aux, backbone='resnet50', jpu=False, pretrained_base=True, **kwargs):
+        super(SegBaseModel, self).__init__()
+        dilated = False if jpu else True
+        self.aux = aux
+        self.nclass = nclass
+        if backbone == 'resnet50':
+            self.pretrained = resnet50_v1s(pretrained=pretrained_base, dilated=dilated, **kwargs)
+        else:
+            raise RuntimeError('unknown backbone: {}'.format(backbone))
+
+        self.jpu = JPU([512, 1024, 2048], width=512, **kwargs) if jpu else None
+
+    def base_forward(self, x):
+        """forwarding pre-trained network"""
+        x = self.pretrained.conv1(x)
+        x = self.pretrained.bn1(x)
+        x = self.pretrained.relu(x)
+        x = self.pretrained.maxpool(x)
+        c1 = self.pretrained.layer1(x)
+        c2 = self.pretrained.layer2(c1)
+        c3 = self.pretrained.layer3(c2)
+        c4 = self.pretrained.layer4(c3)
+
+        if self.jpu:
+            return self.jpu(c1, c2, c3, c4)
+        else:
+            return c1, c2, c3, c4
+
+    def evaluate(self, x):
+        """evaluating network with inputs and targets"""
+        return self.forward(x)[0]
+
+    def demo(self, x):
+        pred = self.forward(x)
+        if self.aux:
+            pred = pred[0]
+        return pred
 
 class _FCNHead(nn.Module):
     def __init__(self, in_channels, channels, norm_layer=nn.BatchNorm2d, **kwargs):

From b27a0cc001b6f85c39bed5b0c9f073a3d4600fad Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:19:43 -0400
Subject: [PATCH 14/22] deleted the fcn8s and fcn32s from the script

---
 .../trail_detection_node/v2_trailDetectionNode.py          | 2 +-
 .../visualizer_v2_trailDetectionNode.py                    | 7 ++-----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
index d3f96edf..d70e89fc 100644
--- a/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
+++ b/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
@@ -1,5 +1,5 @@
 import torch
-from .model_loader import FCN8s, PSPNet
+from .model_loader import PSPNet
 from PIL import Image as ImagePIL
 from torchvision import transforms
 import cv2
diff --git a/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
index da2f0696..7c2ceabc 100644
--- a/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
+++ b/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
@@ -1,5 +1,5 @@
 import torch
-from .model_loader import FCN8s, FCN32s, PSPNet
+from .model_loader import PSPNet
 from PIL import Image as ImagePIL
 from torchvision import transforms
 import cv2
@@ -15,7 +15,6 @@
 from cv_bridge import CvBridge
 
 import message_filters
-from scipy.ndimage import grey_erosion
 '''
     The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
 '''
@@ -131,8 +130,6 @@ def find_route(model, device, cv_image):
     pred[pred == 0] = 255 # only see the trail
     pred[pred == 1] = 0    
     pred = np.array(pred, dtype=np.uint8)
-
-    pred = grey_erosion(pred, size=(4,4))
     
     # # prediction visualize
     # cv2.imshow('prediction',pred)
@@ -313,7 +310,7 @@ def trail_callback(self, camera_msg, lidar_msg):
                 cv2.circle(visualize_cv_image, (red_circle_coloum, image_height - red_circle_row), radius=5, color=(0, 0, 255), thickness=-1)
 
         # visualize the chosen point in image
-        cv2.circle(visualize_cv_image, (circle_x, circle_y), radius=7, color=(255, 0, 255), thickness=-1)
+        cv2.circle(visualize_cv_image, (circle_x, circle_y), radius=7, color=(255, 255, 255), thickness=-1)
         
         cv2.imshow('circled image',visualize_cv_image)
         cv2.waitKey(25)

From 6d7d9784260473a047f30c32d32257f977006d75 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Mon, 11 Sep 2023 14:42:35 -0400
Subject: [PATCH 15/22] Delete
 trail_detection_node/trail_detection_node/v2_trailDetectionNode.py

---
 .../v2_trailDetectionNode.py                  | 256 ------------------
 1 file changed, 256 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/v2_trailDetectionNode.py

diff --git a/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
deleted file mode 100644
index d70e89fc..00000000
--- a/trail_detection_node/trail_detection_node/v2_trailDetectionNode.py
+++ /dev/null
@@ -1,256 +0,0 @@
-import torch
-from .model_loader import PSPNet
-from PIL import Image as ImagePIL
-from torchvision import transforms
-import cv2
-
-import rclpy
-from rclpy.node import Node
-from geometry_msgs.msg import PoseStamped
-from sensor_msgs.msg import Image, PointCloud2
-import sensor_msgs_py.point_cloud2 as pc2
-import numpy as np
-import math
-from cv_bridge import CvBridge
-
-import message_filters
-
-'''
-    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
-'''
-camera_transformation_k = np.array([
-    [628.5359544,0,676.9575694],
-    [0,627.7249542,532.7206716],
-    [0,0,1]])
-
-rotation_matrix = np.array([
-    [-0.007495781893,-0.0006277316155,0.9999717092],
-    [-0.9999516401,-0.006361853422,-0.007499625104],
-    [0.006366381192,-0.9999795662,-0.0005800141927]])
-
-rotation_matrix = rotation_matrix.T
-
-translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
-image_width=1280
-image_height=1024
-
-def convert_to_lidar_frame(uv_coordinate):
-    """
-    convert 2d camera coordinate + depth into 3d lidar frame
-    """
-    point_cloud = np.empty( (3,) , dtype=float)
-    point_cloud[2] = uv_coordinate[2]
-    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
-    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
-
-    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
-    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
-    point_cloud = inverse_camera_transformation_k @ point_cloud
-    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
-    return point_cloud
-
-def convert_to_camera_frame(point_cloud):
-    """
-    convert 3d lidar data into 2d coordinate of the camera frame + depth
-    """
-    length = point_cloud.shape[0]
-    translation = np.tile(translation_vector, (length, 1)).T
-    
-    point_cloud = point_cloud.T
-    point_cloud = rotation_matrix@point_cloud + translation
-    point_cloud = camera_transformation_k @ point_cloud
-
-    uv_coordinate = np.empty_like(point_cloud)
-
-    """
-    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
-    """
-    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
-    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
-    uv_coordinate[2] = point_cloud[2]
-
-    uv_depth = uv_coordinate[2, :]
-    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
-    return filtered_uv_coordinate
-
-def estimate_depth(x, y, np_2d_array):
-    """
-    estimate the depth by finding points closest to x,y from thhe 2d array
-    """
-    # Calculate the distance between each point and the target coordinates (x, y)
-    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
-
-    # Find the indices of the k nearest points
-    k = 5     # Number of nearest neighbors we want
-    closest_indices = np.argpartition(distances_sq, k)[:k]
-    pixel_distance_threshold = 2000
-
-    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
-    if len(valid_indices) == 0:
-        # lidar points disappears usually around 0.4m
-        distance_where_lidar_stops_working = -1
-        return distance_where_lidar_stops_working
-
-    filtered_indices = np.array(valid_indices)
-    # Get the depth value of the closest point
-    closest_depths = np_2d_array[2,filtered_indices]
-
-    return np.mean(closest_depths)
-
-def load_model(device):
-    # model = FCN8s(nclass=6, backbone='vgg16', pretrained_base=True, pretrained=True)
-    model = PSPNet(nclass=2, backbone='resnet50', pretrained_base=True)
-    model_location = 'psp2/psp_resnet50_pascal_voc_best_model.pth'
-    model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
-    model = model.to(device)
-    model.eval()
-    print('Finished loading model!')
-
-    return model
-
-def find_route(model, device, cv_image):
-    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
-    transform = transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
-    ])
-    image = transform(PIL_image).unsqueeze(0).to(device)
-    with torch.no_grad():
-        output = model(image)
-    # pred is prediction generated by the model, route is the variable for the center line
-    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
-    pred[pred == 0] = 255 # only see the trail
-    pred[pred == 1] = 0
-    pred = np.array(pred, dtype=np.uint8)
-    route = np.zeros_like(pred)
-    # calculate the center line by taking the average
-    row_num = 0
-    for row in pred:
-        white_pixels = list(np.nonzero(row)[0])
-        if white_pixels:
-            average = (white_pixels[0] + white_pixels[-1]) / 2
-            route[row_num][round(average)] = 255
-        row_num = row_num + 1
-    return route
-
-'''
-    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
-    it detects the trail in the image and sends the corresponding lidar position as the trail location.
-    The msgs are synchornized before processing, using buffer and sync function.
-    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
-    and choose to go to the closest point. 
-    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
-'''
-class trailDetector(Node):
-    def __init__(self, model, device):
-        super().__init__('trail_detector')
-        # define trail publisher
-        self.trail_publisher = self.create_publisher(
-            PoseStamped,
-            'trail_location',
-            10)
-
-        # create subscribers
-        self.image_sub = message_filters.Subscriber(self, Image, 'camera')
-        self.lidar_sub = message_filters.Subscriber(self, PointCloud2, 'velodyne_points')
-
-        self.bridge = CvBridge()
-
-        # load model and device
-        self.model = model
-        self.device = device
-
-        # create callback
-        queue_size = 30
-        ts = message_filters.ApproximateTimeSynchronizer([self.image_sub, self.lidar_sub], queue_size, 0.5)
-        ts.registerCallback(self.trail_callback)  
-    
-    def trail_callback(self, camera_msg, lidar_msg):
-        print("Message received!")
-        # process lidar msg
-        point_gen = pc2.read_points(
-            lidar_msg, field_names=(
-                "x", "y", "z"), skip_nans=True)
-        points = [[x, y, z] for x, y, z in point_gen]
-        points = np.array(points)
-        points2d = convert_to_camera_frame(points)
-
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-        route = find_route(self.model, self.device, cv_image)
-        route_indices = list(zip(*np.nonzero(route)))
-
-        if not route_indices:
-            print("No centerline found!")
-            return
-
-        #filter points that have no lidar points near it
-        filtered_route_indices = []
-        for index in route_indices:
-            point = []
-            u = index[1]
-            v = image_height - index[0]
-            point.append(u)
-            point.append(v)
-            point.append(estimate_depth(u, v, points2d))
-            if point[2] == -1:
-                continue
-            else:
-                filtered_route_indices.append(point)
-
-        if not filtered_route_indices:
-            print("No usable centerline found!")
-            return
-
-        # find the corresponding lidar points using the center line pixels
-        filtered_3dPoints = []
-        for index in filtered_route_indices:
-            point = []
-            point.append(index[0])
-            point.append(index[1])
-            point.append(index[2])
-            point_3d = convert_to_lidar_frame(point)
-            filtered_3dPoints.append(point_3d)
-
-        filtered_3dPoints = np.array(filtered_3dPoints)
-        # find the nearest 3d point and set that as goal
-        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
-        smallest_index = np.argmin(distances_sq)
-
-        # publsih message
-        trail_location_msg = PoseStamped()
-        trail_location_msg.header.stamp = lidar_msg.header.stamp
-        trail_location_msg.header.frame_id = "velodyne"
-        # position
-        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
-        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
-        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
-        # orientation
-        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
-        trail_location_msg.pose.orientation.x = 0.0  
-        trail_location_msg.pose.orientation.y = 0.0 
-        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
-        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
-        self.trail_publisher.publish(trail_location_msg)
-        
-        # logging
-        self.get_logger().info("location published!")
-        self.get_logger().info(f"Point: {filtered_3dPoints[smallest_index][0]}, {filtered_3dPoints[smallest_index][1]}, {filtered_3dPoints[smallest_index][2]}")
-        
-
-
-
-def main(args=None):
-    print(torch.cuda.is_available())
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model = load_model(device)
-    
-    rclpy.init(args=args)
-    trailDetectorNode = trailDetector(model, device)
-    rclpy.spin(trailDetectorNode)
-
-    trailDetectorNode.destroy_node()
-    rclpy.shutdown()
-
-if __name__ == '__main__':
-    main()
\ No newline at end of file

From d52f6b4f5e12efb380535a27962d8a079ae2d20f Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Mon, 11 Sep 2023 14:42:47 -0400
Subject: [PATCH 16/22] Delete
 trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py

---
 .../visualizer_v2_trailDetectionNode.py       | 410 ------------------
 1 file changed, 410 deletions(-)
 delete mode 100644 trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py

diff --git a/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py b/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
deleted file mode 100644
index 7c2ceabc..00000000
--- a/trail_detection_node/trail_detection_node/visualizer_v2_trailDetectionNode.py
+++ /dev/null
@@ -1,410 +0,0 @@
-import torch
-from .model_loader import PSPNet
-from PIL import Image as ImagePIL
-from torchvision import transforms
-import cv2
-import os
-
-import rclpy
-from rclpy.node import Node
-from geometry_msgs.msg import PoseStamped
-from sensor_msgs.msg import Image, PointCloud2
-import sensor_msgs_py.point_cloud2 as pc2
-import numpy as np
-import math
-from cv_bridge import CvBridge
-
-import message_filters
-'''
-    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
-'''
-camera_transformation_k = np.array([
-    [628.5359544,0,676.9575694],
-    [0,627.7249542,532.7206716],
-    [0,0,1]])
-
-rotation_matrix = np.array([
-    [-0.007495781893,-0.0006277316155,0.9999717092],
-    [-0.9999516401,-0.006361853422,-0.007499625104],
-    [0.006366381192,-0.9999795662,-0.0005800141927]])
-
-rotation_matrix = rotation_matrix.T
-
-translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
-image_width=1280
-image_height=1024
-
-def convert_to_lidar_frame(uv_coordinate):
-    """
-    convert 2d camera coordinate + depth into 3d lidar frame
-    """
-    point_cloud = np.empty( (3,) , dtype=float)
-    point_cloud[2] = uv_coordinate[2]
-    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
-    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
-
-    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
-    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
-    point_cloud = inverse_camera_transformation_k @ point_cloud
-    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
-    return point_cloud
-
-def convert_to_camera_frame(point_cloud):
-    """
-    convert 3d lidar data into 2d coordinate of the camera frame + depth
-    """
-    length = point_cloud.shape[0]
-    translation = np.tile(translation_vector, (length, 1)).T
-    
-    point_cloud = point_cloud.T
-    point_cloud = rotation_matrix@point_cloud + translation
-    point_cloud = camera_transformation_k @ point_cloud
-
-    uv_coordinate = np.empty_like(point_cloud)
-
-    """
-    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
-    """
-    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
-    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
-    uv_coordinate[2] = point_cloud[2]
-
-    uv_depth = uv_coordinate[2, :]
-    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
-    return filtered_uv_coordinate
-
-def estimate_depth(x, y, np_2d_array):
-    """
-    estimate the depth by finding points closest to x,y from thhe 2d array
-    """
-    # Calculate the distance between each point and the target coordinates (x, y)
-    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
-
-    # Find the indices of the k nearest points
-    k = 5     # Number of nearest neighbors we want
-    closest_indices = np.argpartition(distances_sq, k)[:k]
-    pixel_distance_threshold = 2000
-
-    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
-    if len(valid_indices) == 0:
-        # lidar points disappears usually around 0.4m
-        distance_where_lidar_stops_working = -1
-        return distance_where_lidar_stops_working
-
-    filtered_indices = np.array(valid_indices)
-    # Get the depth value of the closest point
-    closest_depths = np_2d_array[2,filtered_indices]
-
-    return np.mean(closest_depths)
-
-def load_model(device):
-    # model = FCN32s(nclass=2, backbone='vgg16', pretrained_base=True, pretrained=True)
-    model = PSPNet(nclass=2, backbone='resnet50', pretrained_base=True)
-
-    # model_location = '32s_batch8/fcn32s_vgg16_pascal_voc_best_model.pth'
-    # model_location = '32s_self_labelled/fcn32s_vgg16_pascal_voc_best_model.pth'
-    model_location = 'psp2/psp_resnet50_pascal_voc_best_model.pth'
-
-    if os.path.isfile(f'src/trail_detection_node/trail_detection_node/model/{model_location}'):
-        model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
-    else:
-        model.load_state_dict(torch.load(f'trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
-    model = model.to(device)
-    
-    model.eval()
-    print('Finished loading model!')
-
-    return model
-
-def find_route(model, device, cv_image):
-    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
-    transform = transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
-    ])
-    image = transform(PIL_image).unsqueeze(0).to(device)
-    with torch.no_grad():
-        output = model(image)
-    # pred is prediction generated by the model, route is the variable for the center line
-    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
-    pred[pred == 0] = 255 # only see the trail
-    pred[pred == 1] = 0    
-    pred = np.array(pred, dtype=np.uint8)
-    
-    # # prediction visualize
-    # cv2.imshow('prediction',pred)
-    # cv2.waitKey(25)
-
-    route = np.zeros_like(pred)
-    # calculate the center line by taking the average
-    row_num = 0
-    for row in pred:
-        white_pixels = list(np.nonzero(row)[0])
-        if white_pixels:
-            average = (white_pixels[0] + white_pixels[-1]) / 2
-            route[row_num][round(average)] = 255
-        row_num = row_num + 1
-    return route, pred
-
-def equalize_hist_rgb(img):
-    # Split the image into its color channels
-    r, g, b = cv2.split(img)
-
-    # Equalize the histograms for each channel
-    r_eq = cv2.equalizeHist(r)
-    g_eq = cv2.equalizeHist(g)
-    b_eq = cv2.equalizeHist(b)
-
-    # Merge the channels
-    img_eq = cv2.merge((r_eq, g_eq, b_eq))
-    # img_eq = cv2.fastNlMeansDenoisingColored(img_eq,None,10,20,7,42)
-    # img_eq = cv2.GaussianBlur(img_eq, (25,25), 0)
-    return img_eq
-
-'''
-    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
-    it detects the trail in the image and sends the corresponding lidar position as the trail location.
-    The msgs are synchornized before processing, using buffer and sync function.
-    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
-    and choose to go to the closest point. 
-    V1_traildetection assumes that the path is pointing frontward and has only one path in front.
-'''
-class trailDetector(Node):
-    def __init__(self, model, device):
-        super().__init__('trail_detector')
-        self.only_camera_mode = False
-        self.bridge = CvBridge()
-
-        # load model and device
-        self.model = model
-        self.device = device
-
-        # define trail publication
-        self.trail_publisher = self.create_publisher(
-            PoseStamped,
-            'trail_location',
-            10)
-        
-        if self.only_camera_mode:
-            # define camera subscription
-            print("Mode: Only Camera")
-            self.camera_subscription = self.create_subscription(
-                Image,
-                'camera',
-                self.only_camera_callback,
-                10)
-            self.camera_subscription
-        else:
-            # create subscribers and synchronizer
-            print("Mode: Lidar and Camera")
-            self.image_sub = message_filters.Subscriber(self, Image, 'camera')
-            self.lidar_sub = message_filters.Subscriber(self, PointCloud2, 'velodyne_points')
-            queue_size = 30
-            ts = message_filters.ApproximateTimeSynchronizer([self.image_sub, self.lidar_sub], queue_size, 0.5)
-            ts.registerCallback(self.trail_callback)
-        
-
-        
-
-    def trail_callback(self, camera_msg, lidar_msg):
-        print("Message received!")
-        # process lidar msg
-        point_gen = pc2.read_points(
-            lidar_msg, field_names=(
-                "x", "y", "z"), skip_nans=True)
-        points = [[x, y, z] for x, y, z in point_gen]
-        points = np.array(points)
-        points2d = convert_to_camera_frame(points)
-
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-        
-        # # increase brightness
-        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
-        # cv_image = cv2.add(cv_image, M)
-
-        # # image visualizer
-        # cv2.imshow('raw image',cv_image)
-        # cv2.waitKey(25)
-
-        route, _ = find_route(self.model, self.device, cv_image)
-
-        # # visualize route purely
-        # cv2.imshow("white_route",route)
-        # cv2.waitKey(25)
-
-        route_indices = list(zip(*np.nonzero(route)))
-        if not route_indices:
-            print("No centerline found!")
-            return
-        
-        #filter points that have no lidar points near it
-        filtered_route_indices = []
-        for index in route_indices:
-            point = []
-            u = index[1]
-            v = image_height - index[0]
-            point.append(u)
-            point.append(v)
-            point.append(estimate_depth(u, v, points2d))
-            if point[2] == -1:
-                continue
-            else:
-                filtered_route_indices.append(point)
-
-        if not filtered_route_indices:
-            print("No usable centerline found!")
-            return
-
-        # find the corresponding lidar points using the center line pixels
-        filtered_3dPoints = []
-        for index in filtered_route_indices:
-        # for index in route_indices:
-            point = []
-            point.append(index[0])
-            point.append(index[1])
-            point.append(index[2])
-
-            # point.append(index[0])
-            # point.append(index[1])
-            # point.append(estimate_depth(index[0], index[1], points2d))
-
-            point_3d = convert_to_lidar_frame(point)
-            filtered_3dPoints.append(point_3d)
-
-        filtered_3dPoints = np.array(filtered_3dPoints)
-        # find the nearest 3d point and set that as goal
-        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
-        smallest_index = np.argmin(distances_sq)
-        # print(math.sqrt(distances_sq[smallest_index]))
-        # smallest_index = np.argmin(filtered_3dPoints[:,2])
-
-        # visualize after-pocessed image
-        visualize_cv_image = cv_image
-        print(f"{visualize_cv_image.shape[0]}")
-        circle_y = route_indices[smallest_index][0]
-        circle_x = route_indices[smallest_index][1]
-        
-        # visualize the lidar points in image
-        uv_x, uv_y, uv_z = points2d
-        for index_lidar in range(points2d.shape[1]):
-            # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
-            cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
-        
-        # visualize center line in image
-        for index_circle in range(len(route_indices)):
-            if index_circle == smallest_index:
-                continue
-            else:
-                green_circle_row = route_indices[index_circle][0]
-                green_circle_coloum = route_indices[index_circle][1]
-                cv2.circle(visualize_cv_image, (green_circle_coloum, green_circle_row), radius=5, color=(0, 125, 125), thickness=-1)
-
-        # visualize filtered center line in image
-        for index_circle in range(len(filtered_route_indices)):
-            if index_circle == smallest_index:
-                continue
-            else:
-                red_circle_row = filtered_route_indices[index_circle][1]
-                red_circle_coloum = filtered_route_indices[index_circle][0]
-                cv2.circle(visualize_cv_image, (red_circle_coloum, image_height - red_circle_row), radius=5, color=(0, 0, 255), thickness=-1)
-
-        # visualize the chosen point in image
-        cv2.circle(visualize_cv_image, (circle_x, circle_y), radius=7, color=(255, 255, 255), thickness=-1)
-        
-        cv2.imshow('circled image',visualize_cv_image)
-        cv2.waitKey(25)
-
-        # publsih message
-        trail_location_msg = PoseStamped()
-        trail_location_msg.header.stamp = lidar_msg.header.stamp
-        trail_location_msg.header.frame_id = "velodyne"
-        #position
-        trail_location_msg.pose.position.x = filtered_3dPoints[smallest_index][0]  
-        trail_location_msg.pose.position.y = filtered_3dPoints[smallest_index][1]
-        trail_location_msg.pose.position.z = filtered_3dPoints[smallest_index][2]
-        #orientation
-        yaw = math.atan2(filtered_3dPoints[smallest_index][1], filtered_3dPoints[smallest_index][0])
-        trail_location_msg.pose.orientation.x = 0.0  
-        trail_location_msg.pose.orientation.y = 0.0 
-        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
-        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
-        self.get_logger().info("location published!")
-        self.get_logger().info(f"Point: {filtered_3dPoints[smallest_index][0]}, {filtered_3dPoints[smallest_index][1]}, {filtered_3dPoints[smallest_index][2]}")
-        self.trail_publisher.publish(trail_location_msg)
-        
-    def only_camera_callback(self, camera_msg):
-        # process camera msg
-        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
-        # cv_image = cv2.resize(cv_image,(480,480))
-
-        # cv_image = cv2.fastNlMeansDenoisingColored(cv_image,None,5,5,5,11)
-        
-        # # histogram equalization method 1
-        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2YCrCb)
-        # cv_image[:,:,0] = cv2.equalizeHist(cv_image[:,:,0])
-        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_YCrCb2BGR)
-
-        # histogram equalization method 2
-        # cv_image = equalize_hist_rgb(cv_image)
-
-        # # histogram equalization method 3 CLAHE
-        # image_bw = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
-        # clahe = cv2.createCLAHE(clipLimit=5)
-        # cv_image = clahe.apply(image_bw) + 30
-
-        # # histogram equalization method 4 CLAHE
-        # cla = cv2.createCLAHE(clipLimit=4.0)
-        # H, S, V = cv2.split(cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV))
-        # eq_V = cla.apply(V)
-        # cv_image = cv2.cvtColor(cv2.merge([H, S, eq_V]), cv2.COLOR_HSV2BGR)
-
-        # # increase brightness
-        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
-        # cv_image = cv2.add(cv_image, M)
-
-        # # image visualizer
-        # cv2.imshow('raw image',cv_image)
-        # cv2.waitKey(25)
-
-        route, pred = find_route(self.model, self.device, cv_image)
-
-        # # visualize route purely
-        # cv2.imshow("white_route",route)
-        # cv2.waitKey(25)
-
-        # increase the brightness of image where is predicted as road
-        sign = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR)
-        cv_image = cv2.add(cv_image, sign)
-
-        route_indices = list(zip(*np.nonzero(route)))
-        if not route_indices:
-            print("No centerline found!")
-            return
-        
-        # for index_circle in range(len(route_indices)):
-        #     red_circle_x = route_indices[index_circle][0]
-        #     red_circle_y = route_indices[index_circle][1]
-        #     cv2.circle(cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
-
-        cv2.imshow('circled image',cv_image)
-        cv2.waitKey(25)
-        
-
-
-
-def main(args=None):
-    print(torch.cuda.is_available())
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model = load_model(device)
-    
-    rclpy.init(args=args)
-    trailDetectorNode = trailDetector(model, device)
-    rclpy.spin(trailDetectorNode)
-
-    trailDetectorNode.destroy_node()
-    rclpy.shutdown()
-    cv2.destroyAllWindows()
-
-if __name__ == '__main__':
-    main()

From 3849886f5e77acadc453df3a2a58770a5cca7946 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Mon, 11 Sep 2023 14:45:04 -0400
Subject: [PATCH 17/22] merge visualization and msg publish node

---
 .../trailDetectionNode.py                     | 420 ++++++++++++++++++
 1 file changed, 420 insertions(+)
 create mode 100644 trail_detection_node/trail_detection_node/trailDetectionNode.py

diff --git a/trail_detection_node/trail_detection_node/trailDetectionNode.py b/trail_detection_node/trail_detection_node/trailDetectionNode.py
new file mode 100644
index 00000000..cb9d89ea
--- /dev/null
+++ b/trail_detection_node/trail_detection_node/trailDetectionNode.py
@@ -0,0 +1,420 @@
+import torch
+from .model_loader import PSPNet
+from PIL import Image as ImagePIL
+from torchvision import transforms
+import cv2
+import os
+
+import rclpy
+from rclpy.node import Node
+from geometry_msgs.msg import PoseStamped
+from sensor_msgs.msg import Image, PointCloud2
+import sensor_msgs_py.point_cloud2 as pc2
+import numpy as np
+import math
+from cv_bridge import CvBridge
+
+import message_filters
+'''
+    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
+'''
+camera_transformation_k = np.array([
+    [628.5359544,0,676.9575694],
+    [0,627.7249542,532.7206716],
+    [0,0,1]])
+
+rotation_matrix = np.array([
+    [-0.007495781893,-0.0006277316155,0.9999717092],
+    [-0.9999516401,-0.006361853422,-0.007499625104],
+    [0.006366381192,-0.9999795662,-0.0005800141927]])
+
+rotation_matrix = rotation_matrix.T
+
+translation_vector = np.array([-0.06024059837, -0.08180891509, -0.3117851288])
+image_width=1280
+image_height=1024
+
+def convert_to_lidar_frame(uv_coordinate):
+    """
+    convert 2d camera coordinate + depth into 3d lidar frame
+    """
+    point_cloud = np.empty( (3,) , dtype=float)
+    point_cloud[2] = uv_coordinate[2]
+    point_cloud[1] = ( image_height - uv_coordinate[1] )*point_cloud[2]
+    point_cloud[0] = uv_coordinate[0]*point_cloud[2]
+
+    inverse_camera_transformation_k = np.linalg.inv(camera_transformation_k)
+    inverse_rotation_matrix = np.linalg.inv(rotation_matrix)
+    point_cloud = inverse_camera_transformation_k @ point_cloud
+    point_cloud = inverse_rotation_matrix @ (point_cloud-translation_vector) 
+    return point_cloud
+
+def convert_to_camera_frame(point_cloud):
+    """
+    convert 3d lidar data into 2d coordinate of the camera frame + depth
+    """
+    length = point_cloud.shape[0]
+    translation = np.tile(translation_vector, (length, 1)).T
+    
+    point_cloud = point_cloud.T
+    point_cloud = rotation_matrix@point_cloud + translation
+    point_cloud = camera_transformation_k @ point_cloud
+
+    uv_coordinate = np.empty_like(point_cloud)
+
+    """
+    uv = [x/z, y/z, z], and y is opposite so the minus imageheight
+    """
+    uv_coordinate[0] = point_cloud[0] / point_cloud[2]
+    uv_coordinate[1] = image_height - point_cloud[1] / point_cloud[2]
+    uv_coordinate[2] = point_cloud[2]
+
+    uv_depth = uv_coordinate[2, :]
+    filtered_uv_coordinate = uv_coordinate[:, uv_depth >= 0]
+    return filtered_uv_coordinate
+
+def estimate_depth(x, y, np_2d_array):
+    """
+    estimate the depth by finding points closest to x,y from thhe 2d array
+    """
+    # Calculate the distance between each point and the target coordinates (x, y)
+    distances_sq = (np_2d_array[0,:] - x) ** 2 + (np_2d_array[1,:] - y) ** 2
+
+    # Find the indices of the k nearest points
+    k = 5     # Number of nearest neighbors we want
+    closest_indices = np.argpartition(distances_sq, k)[:k]
+    pixel_distance_threshold = 2000
+
+    valid_indices = [idx for idx in closest_indices if distances_sq[idx]<=pixel_distance_threshold]
+    if len(valid_indices) == 0:
+        # lidar points disappears usually around 0.4m
+        distance_where_lidar_stops_working = -1
+        return distance_where_lidar_stops_working
+
+    filtered_indices = np.array(valid_indices)
+    # Get the depth value of the closest point
+    closest_depths = np_2d_array[2,filtered_indices]
+
+    return np.mean(closest_depths)
+
+def load_model(device):
+    # model = FCN32s(nclass=2, backbone='vgg16', pretrained_base=True, pretrained=True)
+    model = PSPNet(nclass=2, backbone='resnet50', pretrained_base=True)
+
+    # model_location = '32s_batch8/fcn32s_vgg16_pascal_voc_best_model.pth'
+    # model_location = '32s_self_labelled/fcn32s_vgg16_pascal_voc_best_model.pth'
+    model_location = 'psp2/psp_resnet50_pascal_voc_best_model.pth'
+
+    if os.path.isfile(f'src/trail_detection_node/trail_detection_node/model/{model_location}'):
+        model.load_state_dict(torch.load(f'src/trail_detection_node/trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
+    else:
+        model.load_state_dict(torch.load(f'trail_detection_node/model/{model_location}',map_location=torch.device('cuda:0')))
+    model = model.to(device)
+    
+    model.eval()
+    print('Finished loading model!')
+
+    return model
+
+def find_route(model, device, cv_image):
+    PIL_image = ImagePIL.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+    image = transform(PIL_image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        output = model(image)
+    # pred is prediction generated by the model, route is the variable for the center line
+    pred = torch.argmax(output[0], 1).squeeze(0).cpu().data.numpy()
+    pred[pred == 0] = 255 # only see the trail
+    pred[pred == 1] = 0    
+    pred = np.array(pred, dtype=np.uint8)
+    
+    # # prediction visualize
+    # cv2.imshow('prediction',pred)
+    # cv2.waitKey(25)
+
+    route = np.zeros_like(pred)
+    # calculate the center line by taking the average
+    row_num = 0
+    for row in pred:
+        white_pixels = list(np.nonzero(row)[0])
+        if white_pixels:
+            average = (white_pixels[0] + white_pixels[-1]) / 2
+            route[row_num][round(average)] = 255
+        row_num = row_num + 1
+    return route, pred
+
+def equalize_hist_rgb(img):
+    # Split the image into its color channels
+    r, g, b = cv2.split(img)
+
+    # Equalize the histograms for each channel
+    r_eq = cv2.equalizeHist(r)
+    g_eq = cv2.equalizeHist(g)
+    b_eq = cv2.equalizeHist(b)
+
+    # Merge the channels
+    img_eq = cv2.merge((r_eq, g_eq, b_eq))
+    # img_eq = cv2.fastNlMeansDenoisingColored(img_eq,None,10,20,7,42)
+    # img_eq = cv2.GaussianBlur(img_eq, (25,25), 0)
+    return img_eq
+
+'''
+    The traildetector node has two subscriptions(lidar and camera) and one publisher(trail position). After it receives msgs from both lidar and camera,
+    it detects the trail in the image and sends the corresponding lidar position as the trail location.
+    The msgs are synchornized before processing, using buffer and sync function.
+    To find the path, the node will process the image, find a line to follow (by taking the average of left and right of the path), estimate the lidar points depth, 
+    and choose to go to the closest point. 
+    This ediction of node assumes that the path is pointing frontward and has only one path in front.
+'''
+class trailDetector(Node):
+    def __init__(self, model, device):
+        super().__init__('trail_detector')
+        self.only_camera_mode = False
+        self.bridge = CvBridge()
+
+        # load model and device
+        self.model = model
+        self.device = device
+
+        # define trail publication
+        self.trail_publisher = self.create_publisher(
+            PoseStamped,
+            'trail_location',
+            10)
+        
+        self.visualize = False
+
+        if self.only_camera_mode:
+            # define camera subscription
+            self.get_logger().info("Mode: Only Camera")
+            self.camera_subscription = self.create_subscription(
+                Image,
+                'camera',
+                self.only_camera_callback,
+                10)
+            self.camera_subscription
+        else:
+            # create subscribers and synchronizer
+            self.get_logger().info("Mode: Lidar and Camera")
+            self.image_sub = message_filters.Subscriber(self, Image, 'camera')
+            self.lidar_sub = message_filters.Subscriber(self, PointCloud2, 'velodyne_points')
+            queue_size = 30
+            ts = message_filters.ApproximateTimeSynchronizer([self.image_sub, self.lidar_sub], queue_size, 0.5)
+            ts.registerCallback(self.trail_callback)
+        
+
+        
+
+    def trail_callback(self, camera_msg, lidar_msg):
+        # print("Message received!")
+        # process lidar msg
+        point_gen = pc2.read_points(
+            lidar_msg, field_names=(
+                "x", "y", "z"), skip_nans=True)
+        points = [[x, y, z] for x, y, z in point_gen]
+        points = np.array(points)
+        points2d = convert_to_camera_frame(points)
+
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        
+        # # increase brightness
+        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        # cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route, _ = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            self.get_logger().info("No centerline found!")
+            return
+        
+        #filter points that have no lidar points near it
+        filtered_route_indices = []
+        for index in route_indices:
+            point = []
+            u = index[1]
+            v = image_height - index[0]
+            point.append(u)
+            point.append(v)
+            point.append(estimate_depth(u, v, points2d))
+            if point[2] == -1:
+                continue
+            else:
+                filtered_route_indices.append(point)
+
+        if not filtered_route_indices:
+            self.get_logger().info("No usable centerline found!")
+            return
+
+        # find the corresponding lidar points using the center line pixels
+        filtered_3dPoints = []
+        for index in filtered_route_indices:
+        # for index in route_indices:
+            point = []
+            point.append(index[0])
+            point.append(index[1])
+            point.append(index[2])
+
+            # point.append(index[0])
+            # point.append(index[1])
+            # point.append(estimate_depth(index[0], index[1], points2d))
+
+            point_3d = convert_to_lidar_frame(point)
+            filtered_3dPoints.append(point_3d)
+
+        filtered_3dPoints = np.array(filtered_3dPoints)
+        # find the nearest 3d point and set that as goal
+        distances_sq = filtered_3dPoints[:,0]**2 + filtered_3dPoints[:,1]**2 + filtered_3dPoints[:,2]**2
+        self.smallest_index = np.argmin(distances_sq)
+        # print(math.sqrt(distances_sq[smallest_index]))
+        # smallest_index = np.argmin(filtered_3dPoints[:,2])
+
+        if self.visualize == True:
+            self.visualization(route_indices, points2d, filtered_route_indices, cv_image)
+        else:
+            self.publish_msg(lidar_msg, filtered_3dPoints)
+
+
+    def visualization(self, route_indices, points2d, filtered_route_indices, cv_image):
+        # visualize after-pocessed image
+        visualize_cv_image = cv_image
+        # print(f"{visualize_cv_image.shape[0]}")
+        circle_y = route_indices[self.smallest_index][0]
+        circle_x = route_indices[self.smallest_index][1]
+        
+        # visualize the lidar points in image
+        uv_x, uv_y, uv_z = points2d
+        for index_lidar in range(points2d.shape[1]):
+            # print(f"{int(uv_x[index_lidar])},{int(uv_y[index_lidar])}")
+            cv2.circle(visualize_cv_image, (int(uv_x[index_lidar]), int(image_height - uv_y[index_lidar])), radius=5, color=(255, 0, 0), thickness=-1)
+        
+        # visualize center line in image
+        for index_circle in range(len(route_indices)):
+            if index_circle == self.smallest_index:
+                continue
+            else:
+                green_circle_row = route_indices[index_circle][0]
+                green_circle_coloum = route_indices[index_circle][1]
+                cv2.circle(visualize_cv_image, (green_circle_coloum, green_circle_row), radius=5, color=(0, 125, 125), thickness=-1)
+
+        # visualize filtered center line in image
+        for index_circle in range(len(filtered_route_indices)):
+            if index_circle == self.smallest_index:
+                continue
+            else:
+                red_circle_row = filtered_route_indices[index_circle][1]
+                red_circle_coloum = filtered_route_indices[index_circle][0]
+                cv2.circle(visualize_cv_image, (red_circle_coloum, image_height - red_circle_row), radius=5, color=(0, 0, 255), thickness=-1)
+
+        # visualize the chosen point in image
+        cv2.circle(visualize_cv_image, (circle_x, circle_y), radius=7, color=(255, 255, 255), thickness=-1)
+        
+        cv2.imshow('circled image',visualize_cv_image)
+        cv2.waitKey(25)
+
+    def publish_msg(self, lidar_msg, filtered_3dPoints):
+        # publsih message
+        trail_location_msg = PoseStamped()
+        trail_location_msg.header.stamp = lidar_msg.header.stamp
+        trail_location_msg.header.frame_id = "velodyne"
+        #position
+        trail_location_msg.pose.position.x = filtered_3dPoints[self.smallest_index][0]  
+        trail_location_msg.pose.position.y = filtered_3dPoints[self.smallest_index][1]
+        trail_location_msg.pose.position.z = filtered_3dPoints[self.smallest_index][2]
+        #orientation
+        yaw = math.atan2(filtered_3dPoints[self.smallest_index][1], filtered_3dPoints[self.smallest_index][0])
+        trail_location_msg.pose.orientation.x = 0.0  
+        trail_location_msg.pose.orientation.y = 0.0 
+        trail_location_msg.pose.orientation.z = math.sin(yaw/2)
+        trail_location_msg.pose.orientation.w = math.cos(yaw / 2)
+        self.get_logger().info("location published!")
+        self.get_logger().info(f"Point: {filtered_3dPoints[self.smallest_index][0]}, {filtered_3dPoints[self.smallest_index][1]}, {filtered_3dPoints[self.smallest_index][2]}")
+        self.trail_publisher.publish(trail_location_msg)
+        
+    def only_camera_callback(self, camera_msg):
+        # process camera msg
+        cv_image = self.bridge.imgmsg_to_cv2(camera_msg, desired_encoding='passthrough')
+        # cv_image = cv2.resize(cv_image,(480,480))
+
+        # cv_image = cv2.fastNlMeansDenoisingColored(cv_image,None,5,5,5,11)
+        
+        # # histogram equalization method 1
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2YCrCb)
+        # cv_image[:,:,0] = cv2.equalizeHist(cv_image[:,:,0])
+        # cv_image = cv2.cvtColor(cv_image, cv2.COLOR_YCrCb2BGR)
+
+        # histogram equalization method 2
+        # cv_image = equalize_hist_rgb(cv_image)
+
+        # # histogram equalization method 3 CLAHE
+        # image_bw = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
+        # clahe = cv2.createCLAHE(clipLimit=5)
+        # cv_image = clahe.apply(image_bw) + 30
+
+        # # histogram equalization method 4 CLAHE
+        # cla = cv2.createCLAHE(clipLimit=4.0)
+        # H, S, V = cv2.split(cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV))
+        # eq_V = cla.apply(V)
+        # cv_image = cv2.cvtColor(cv2.merge([H, S, eq_V]), cv2.COLOR_HSV2BGR)
+
+        # # increase brightness
+        # M = np.ones(cv_image.shape, dtype = 'uint8') * 50 # increase brightness by 50 
+        # cv_image = cv2.add(cv_image, M)
+
+        # # image visualizer
+        # cv2.imshow('raw image',cv_image)
+        # cv2.waitKey(25)
+
+        route, pred = find_route(self.model, self.device, cv_image)
+
+        # # visualize route purely
+        # cv2.imshow("white_route",route)
+        # cv2.waitKey(25)
+
+        # increase the brightness of image where is predicted as road
+        sign = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR)
+        cv_image = cv2.add(cv_image, sign)
+
+        route_indices = list(zip(*np.nonzero(route)))
+        if not route_indices:
+            self.get_logger().info("No centerline found!")
+            return
+        
+        # for index_circle in range(len(route_indices)):
+        #     red_circle_x = route_indices[index_circle][0]
+        #     red_circle_y = route_indices[index_circle][1]
+        #     cv2.circle(cv_image, (red_circle_y, red_circle_x), radius=5, color=(0, 0, 255), thickness=-1)
+
+        cv2.imshow('circled image',cv_image)
+        cv2.waitKey(25)
+        
+
+
+
+def main(args=None):
+    print(torch.cuda.is_available())
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = load_model(device)
+    
+    rclpy.init(args=args)
+    trailDetectorNode = trailDetector(model, device)
+    rclpy.spin(trailDetectorNode)
+
+    trailDetectorNode.destroy_node()
+    rclpy.shutdown()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    main()

From 975fc45385b60e6d0755aeb2f6980018c8706d5f Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Sat, 16 Sep 2023 20:36:49 -0400
Subject: [PATCH 18/22] Update setup.py

Change entry point and fix email
---
 trail_detection_node/setup.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/trail_detection_node/setup.py b/trail_detection_node/setup.py
index 511d6ad0..83dd74cc 100644
--- a/trail_detection_node/setup.py
+++ b/trail_detection_node/setup.py
@@ -14,15 +14,13 @@
     install_requires=['setuptools'],
     zip_safe=True,
     maintainer='zhaodong',
-    maintainer_email='tom2352759619@hotmail.com',
+    maintainer_email='zhaodong.jiang@mail.utoronto.ca',
     description='TODO: Package description',
     license='TODO: License declaration',
     tests_require=['pytest'],
     entry_points={
         'console_scripts': [
-            'trail_detection = trail_detection_node.v2_trailDetectionNode:main',
-            'visualizer = trail_detection_node.visualizer_v2_trailDetectionNode:main',
-            'original_visualizer = trail_detection_node.visualizer_v1_trailDetectionNode:main',
+            'trail_detection = trail_detection_node.trailDetectionNode:main',
         ],
     },
 )

From 9927b75ced00d1772f1164b7401fe0e9da0ba90a Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Sat, 16 Sep 2023 20:37:24 -0400
Subject: [PATCH 19/22] Update test.py

---
 trail_detection_node/test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trail_detection_node/test.py b/trail_detection_node/test.py
index 5d715cab..c925cc4c 100644
--- a/trail_detection_node/test.py
+++ b/trail_detection_node/test.py
@@ -1,3 +1,3 @@
-from trail_detection_node.visualizer_v2_trailDetectionNode import *
+from trail_detection_node.trailDetectionNode import *
 
 main()

From d42767cc1bfbd8b370b3f329548d6b636e9ce0a0 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Sat, 16 Sep 2023 20:39:18 -0400
Subject: [PATCH 20/22] Update package.xml

fix email
---
 trail_detection_node/package.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trail_detection_node/package.xml b/trail_detection_node/package.xml
index 45159f4b..aa18aeb5 100644
--- a/trail_detection_node/package.xml
+++ b/trail_detection_node/package.xml
@@ -4,7 +4,7 @@
   <name>trail_detection_node</name>
   <version>0.0.0</version>
   <description>TODO: Package description</description>
-  <maintainer email="tom2352759619@hotmail.com">zhaodong</maintainer>
+  <maintainer email="zhaodong.jiang@mail.utortonto.ca">zhaodong</maintainer>
   <license>TODO: License declaration</license>
 
   <depend>sensor_msgs</depend>

From 5bc9924b21ecc8a4386344c2b63ddada5efa2d3f Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Sat, 16 Sep 2023 21:07:42 -0400
Subject: [PATCH 21/22] Update README.md

---
 trail_detection_node/README.md | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/trail_detection_node/README.md b/trail_detection_node/README.md
index ceda4310..f6e7b881 100644
--- a/trail_detection_node/README.md
+++ b/trail_detection_node/README.md
@@ -7,15 +7,16 @@ SETUP GUIDE
 
 RUN the node
 =============
-The package contains two nodes:
-1. The node that takes the camera and lidar data and sends the Posestamp message
 ```
 ros2 run trail_detection_node trail_detection
 ```
-2. The node that takes the camera and lidar data and shows the visualization of the output
-```
-ros2 run trail_detection_node visualizer
-```
+
+Node Usage
+=============
+The node has three modes, which can be controlled by setting the ```only_camera_mode```(line 175) and ```visualize```(line 188) to different value: 
+1. Trail centerline publisher(default, ```only_camera_mode=False```, ```visualize=False```): subscribes to camera and lidar and publishes the centerline point(posestamp type msg) in ```velodyne``` frame in ```trail_location``` topic
+2. Trail centerline visualizer(```only_camera_mode=False```, ```visualize=True```): subscribes to camera and lidar and shows the chosen centerline point in **white**, the lidar points in **blue**, center points with no lidar points around in **yellow**, and center points with lidar points around in **red** in the image in the pop up window
+3. Only Camera mode(```only_camera_mode=True```): subscribes only to camera, runs the segmentation model, and shows the segmented trail in image in the pop up window
 
 Possible issues
 =============
@@ -24,10 +25,5 @@ Possible issues
 2. **Subfolder package relative import error:**
    Temporary fix: Move the script to the same folder and change the import code
 
-Scripts explanation
-=============
-1. ```v1_trailDetectionNode.py``` and ```v2_trailDetectionNode.py```: two versions of ros2 node that sends the Posestamp message
-2. ```visualizer_v1_trailDetectionNode.py``` and ```visualizer_v2_trailDetectionNode.py```: two versions of ros2 visualization node
-3. ```GANav_visualizer.py```: ros2 visualization node for GANav model
-4. ```jpu.py```, ```model_loader.py```, ```model_store.py```, ```segbase.py```, ```vgg.py```, and ```base_models``` folder: model loaders for FCN32S. FCN8s, and PSPNet. Copied from: https://github.com/Tramac/awesome-semantic-segmentation-pytorch
+
     

From 6ca46402905c884c94db1f186e99fa6e660c6353 Mon Sep 17 00:00:00 2001
From: Frank_ZhaodongJiang <69261064+FrankZhaodong@users.noreply.github.com>
Date: Sat, 16 Sep 2023 21:12:31 -0400
Subject: [PATCH 22/22] Update trailDetectionNode.py

Add a comment that line 21 to 98 are from human_detection_node
---
 trail_detection_node/trail_detection_node/trailDetectionNode.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trail_detection_node/trail_detection_node/trailDetectionNode.py b/trail_detection_node/trail_detection_node/trailDetectionNode.py
index cb9d89ea..e4eef73e 100644
--- a/trail_detection_node/trail_detection_node/trailDetectionNode.py
+++ b/trail_detection_node/trail_detection_node/trailDetectionNode.py
@@ -16,7 +16,7 @@
 
 import message_filters
 '''
-    The transformation matrix as well as the coordinate conversion and depth estimation functions are copied from human_detection_node
+    The transformation matrix as well as the coordinate conversion and depth estimation functions (from line 21 to line 98) are copied from human_detection_node
 '''
 camera_transformation_k = np.array([
     [628.5359544,0,676.9575694],