significant improvements and streamlining to the RQT GUI interface

src/rqt_rover_gui/src/MapData.cpp

@@ -2,9 +2,9 @@
 
 using namespace std;
 
-MapData::MapData( )
+MapData::MapData()
 {
-
+    display_global_offset = false;
 }
 
 void MapData::addToGPSRoverPath(string rover, float x, float y)
@@ -18,7 +18,13 @@ void MapData::addToGPSRoverPath(string rover, float x, float y)
     if (y < min_gps_seen_y[rover]) min_gps_seen_y[rover] = y;
 
     update_mutex.lock();
+
+    float offset_x = rover_global_offsets[rover].first;
+    float offset_y = rover_global_offsets[rover].second;
+    global_offset_gps_rover_path[rover].push_back(pair<float,float>(x+offset_x,y-offset_y));
+
     gps_rover_path[rover].push_back(pair<float,float>(x,y));
+
     update_mutex.unlock();
 
 }
@@ -34,7 +40,13 @@ void MapData::addToEncoderRoverPath(string rover, float x, float y)
     if (y < min_encoder_seen_y[rover]) min_encoder_seen_y[rover] = y;
 
     update_mutex.lock();
+
+    float offset_x = rover_global_offsets[rover].first;
+    float offset_y = rover_global_offsets[rover].second;
+    global_offset_encoder_rover_path[rover].push_back(pair<float,float>(x+offset_x,y-offset_y));
+
     encoder_rover_path[rover].push_back(pair<float,float>(x,y));
+
     update_mutex.unlock();
 
 }
@@ -51,7 +63,13 @@ void MapData::addToEKFRoverPath(string rover, float x, float y)
     if (y < min_ekf_seen_y[rover]) min_ekf_seen_y[rover] = y;
 
     update_mutex.lock();
+
+    float offset_x = rover_global_offsets[rover].first;
+    float offset_y = rover_global_offsets[rover].second;
+    global_offset_ekf_rover_path[rover].push_back(pair<float,float>(x+offset_x,y-offset_y));
+
     ekf_rover_path[rover].push_back(pair<float,float>(x,y));
+
     update_mutex.unlock();
 
 }
@@ -79,6 +97,15 @@ void MapData::addCollectionPoint(string rover, float x, float y)
 
 }
 
+void MapData::setGlobalOffset(bool display)
+{
+    display_global_offset = display;
+}
+
+void MapData::setGlobalOffsetForRover(string rover, float x, float y)
+{
+    rover_global_offsets[rover] = pair<float,float>(x,y);
+}
 
 void MapData::clear()
 {
@@ -87,6 +114,9 @@ void MapData::clear()
     ekf_rover_path.clear();
     encoder_rover_path.clear();
     gps_rover_path.clear();
+    global_offset_ekf_rover_path.clear();
+    global_offset_encoder_rover_path.clear();
+    global_offset_gps_rover_path.clear();
     target_locations.clear();
     collection_points.clear();
 
@@ -100,6 +130,9 @@ void MapData::clear(string rover)
     ekf_rover_path[rover].clear();
     encoder_rover_path[rover].clear();
     gps_rover_path[rover].clear();
+    global_offset_ekf_rover_path[rover].clear();
+    global_offset_encoder_rover_path[rover].clear();
+    global_offset_gps_rover_path[rover].clear();
     target_locations[rover].clear();
     collection_points[rover].clear();
 
@@ -114,16 +147,31 @@ void MapData::clear(string rover)
 
 std::vector< std::pair<float,float> >* MapData::getEKFPath(std::string rover_name)
 {
+    if(display_global_offset)
+    {
+        return &global_offset_ekf_rover_path[rover_name];
+    }
+
     return &ekf_rover_path[rover_name];
 }
 
 std::vector< std::pair<float,float> >* MapData::getGPSPath(std::string rover_name)
 {
+    if(display_global_offset)
+    {
+        return &global_offset_gps_rover_path[rover_name];
+    }
+
     return &gps_rover_path[rover_name];
 }
 
 std::vector< std::pair<float,float> >* MapData::getEncoderPath(std::string rover_name)
 {
+    if(display_global_offset)
+    {
+        return &global_offset_encoder_rover_path[rover_name];
+    }
+
     return &encoder_rover_path[rover_name];
 }
 
@@ -140,61 +188,121 @@ std::vector< std::pair<float,float> >* MapData::getCollectionPoints(std::string
 // These functions report the maximum and minimum map values seen. This is useful for the GUI when it is calculating the map coordinate system.
 float MapData::getMaxGPSX(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return max_gps_seen_x[rover_name] + rover_global_offsets[rover_name].first;
+    }
+
     return max_gps_seen_x[rover_name];
 }
 
 float MapData::getMaxGPSY(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return max_gps_seen_y[rover_name] - rover_global_offsets[rover_name].second;
+    }
+
     return max_gps_seen_y[rover_name];
 }
 
 float MapData::getMinGPSX(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return min_gps_seen_x[rover_name] + rover_global_offsets[rover_name].first;
+    }
+
     return min_gps_seen_x[rover_name];
 }
 
 float MapData::getMinGPSY(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return min_gps_seen_y[rover_name] - rover_global_offsets[rover_name].second;
+    }
+
     return min_gps_seen_y[rover_name];
 }
 
 float MapData::getMaxEKFX(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return max_ekf_seen_x[rover_name] + rover_global_offsets[rover_name].first;
+    }
+
     return max_ekf_seen_x[rover_name];
 }
 
 float MapData::getMaxEKFY(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return max_ekf_seen_y[rover_name] - rover_global_offsets[rover_name].second;
+    }
+
     return max_ekf_seen_y[rover_name];
 }
 
 float MapData::getMinEKFX(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return min_ekf_seen_x[rover_name] + rover_global_offsets[rover_name].first;
+    }
+
     return min_ekf_seen_x[rover_name];
 }
 
 float MapData::getMinEKFY(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return min_ekf_seen_y[rover_name] - rover_global_offsets[rover_name].second;
+    }
+
     return min_ekf_seen_y[rover_name];
 }
 
 float MapData::getMaxEncoderX(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return max_encoder_seen_x[rover_name] + rover_global_offsets[rover_name].first;
+    }
+
     return max_encoder_seen_x[rover_name];
 }
 
 float MapData::getMaxEncoderY(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return max_encoder_seen_y[rover_name] - rover_global_offsets[rover_name].second;
+    }
+
     return max_encoder_seen_y[rover_name];
 }
 
 float MapData::getMinEncoderX(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return min_encoder_seen_x[rover_name] + rover_global_offsets[rover_name].first;
+    }
+
     return min_encoder_seen_x[rover_name];
 }
 
 float MapData::getMinEncoderY(string rover_name)
 {
+    if(display_global_offset)
+    {
+        return min_encoder_seen_y[rover_name] - rover_global_offsets[rover_name].second;
+    }
+
     return min_encoder_seen_y[rover_name];
 }
 

src/rqt_rover_gui/src/MapData.h

@@ -24,6 +24,9 @@ class MapData
     void addTargetLocation(std::string rover, float x, float y);
     void addCollectionPoint(std::string rover, float x, float y);
 
+    void setGlobalOffset(bool display);
+    void setGlobalOffsetForRover(std::string rover, float x, float y);
+
     void clear();
     void clear(std::string rover_name);
     void lock();
@@ -56,8 +59,13 @@ class MapData
 private:
 
     std::map<std::string, std::vector< std::pair<float,float> > > gps_rover_path;
-    std::map<std::string, std::vector< std::pair<float,float> > >  ekf_rover_path;
-    std::map<std::string, std::vector< std::pair<float,float> > >  encoder_rover_path;
+    std::map<std::string, std::vector< std::pair<float,float> > > ekf_rover_path;
+    std::map<std::string, std::vector< std::pair<float,float> > > encoder_rover_path;
+
+    std::map<std::string, std::pair<float,float> > rover_global_offsets;
+    std::map<std::string, std::vector< std::pair<float,float> > > global_offset_gps_rover_path;
+    std::map<std::string, std::vector< std::pair<float,float> > > global_offset_ekf_rover_path;
+    std::map<std::string, std::vector< std::pair<float,float> > > global_offset_encoder_rover_path;
 
     std::map<std::string, std::vector< std::pair<float,float> > >  collection_points;
     std::map<std::string, std::vector< std::pair<float,float> > >  target_locations;
@@ -77,6 +85,8 @@ class MapData
     std::map<std::string, float> min_ekf_seen_x;
     std::map<std::string, float> min_ekf_seen_y;
 
+    bool display_global_offset;
+
     QMutex update_mutex; // To prevent race conditions when the data is being displayed by MapFrame
 };