Segmentation

cloud_merge/include/cloud_merge/cloud_merge_node.h

@@ -434,7 +434,7 @@ void CloudMergeNode<PointType>::controlCallback(const std_msgs::String& controlS
     }
 
     if (controlString.data == "end_sweep")
-    {
+	{
         ROS_INFO_STREAM("Pan tilt sweep stopped");
         m_bAquisitionPhase = false;
 
@@ -483,8 +483,8 @@ void CloudMergeNode<PointType>::controlCallback(const std_msgs::String& controlS
             std::string roomXMLPath = parser.saveRoomAsXML(aSemanticRoom);
             ROS_INFO_STREAM("Saved semantic room");
 
-            if (m_bRegisterAndCorrectSweep)
-            {
+			if (m_bRegisterAndCorrectSweep)
+			{
                 // load precalibrated camera poses
 //                std::vector<tf::StampedTransform> regTransforms = semantic_map_registration_transforms::loadRegistrationTransforms("default", true);
                std::vector<tf::StampedTransform> corresponding_registeredPoses;
@@ -541,7 +541,7 @@ void CloudMergeNode<PointType>::controlCallback(const std_msgs::String& controlS
                     reg.saveOrbFeatures<PointType>(aSemanticRoom,base_path);
 
                 }
-            }
+			}
 
             // Pulbish room observation
             semantic_map::RoomObservation obs_msg;

dynamic_object_retrieval/benchmark/include/object_3d_benchmark/benchmark_visualization.h

@@ -16,15 +16,18 @@ using CloudT = pcl::PointCloud<PointT>;
 namespace benchmark_retrieval {
 
 void put_text(cv::Mat& image, const std::string& text);
-cv::Mat make_image(std::vector<CloudT::Ptr>& results,  const Eigen::Matrix4f& room_transform,
-                   std::vector<boost::filesystem::path>& sweep_paths, const std::vector<std::string>& optional_text);
+std::pair<cv::Mat, std::vector<cv::Mat> > make_image(std::vector<CloudT::Ptr>& results,  const Eigen::Matrix4f& room_transform,
+                                                     std::vector<boost::filesystem::path>& sweep_paths, const std::vector<std::string>& optional_text);
 cv::Mat add_query_image(cv::Mat& results, cv::Mat& query_image, const std::string& query_label);
 
 // this will alter the look of the point clouds, but for the better I think
 //template <typename IndexT, typename PathT>
 cv::Mat make_visualization_image(cv::Mat& query_image, const std::string& query_label, std::vector<CloudT::Ptr>& clouds,
                                  std::vector<boost::filesystem::path>& sweep_paths, const std::vector<std::string>& optional_text,
                                  const Eigen::Matrix4f& T);
+cv::Mat make_visualization_image(cv::Mat& query_image, const std::string& query_label, std::vector<CloudT::Ptr>& clouds,
+                                 std::vector<boost::filesystem::path>& sweep_paths, const std::vector<std::string>& optional_text,
+                                 const Eigen::Matrix4f& T, std::vector<cv::Mat>& individual_images);
 cv::Mat make_visualization_image(CloudT::Ptr& query_cloud, cv::Mat& query_mask, const boost::filesystem::path& query_path,
                                  const Eigen::Matrix3f& K, const Eigen::Matrix4f& query_transform,
                                  const std::string& query_label, std::vector<CloudT::Ptr>& clouds,

dynamic_object_retrieval/benchmark/src/benchmark_visualization.cpp

@@ -28,11 +28,23 @@ cv::Mat make_visualization_image(cv::Mat& query_image, const string& query_label
             p.getVector4fMap() = T*p.getVector4fMap();
         }
     }*/
-    cv::Mat result_image = make_image(clouds, T, sweep_paths, optional_text);
+    cv::Mat result_image;
+    vector<cv::Mat> individual_images;
+    tie(result_image, individual_images) = make_image(clouds, T, sweep_paths, optional_text);
     return add_query_image(result_image, query_image, query_label);
     //return result_image;
 }
 
+cv::Mat make_visualization_image(cv::Mat& query_image, const string& query_label, vector<CloudT::Ptr>& clouds,
+                                 vector<boost::filesystem::path>& sweep_paths, const vector<string>& optional_text,
+                                 const Eigen::Matrix4f& T, vector<cv::Mat>& individual_images)
+{
+    cv::Mat result_image;
+    tie(result_image, individual_images) = make_image(clouds, T, sweep_paths, optional_text);
+    individual_images.insert(individual_images.begin(), query_image.clone());
+    return add_query_image(result_image, query_image, query_label);
+}
+
 cv::Mat make_visualization_image(CloudT::Ptr& query_cloud, cv::Mat& query_mask, const boost::filesystem::path& query_path,
                                  const Eigen::Matrix3f& K, const Eigen::Matrix4f& query_transform,
                                  const string& query_label, vector<CloudT::Ptr>& clouds,
@@ -70,7 +82,9 @@ cv::Mat make_visualization_image(CloudT::Ptr& query_cloud, cv::Mat& query_mask,
     cv::Mat inverted_mask;
     cv::bitwise_not(query_mask, inverted_mask);
     image.setTo(cv::Scalar(255, 255, 255), inverted_mask);
-    cv::Mat result_image = make_image(clouds, T, sweep_paths, optional_text);
+    cv::Mat result_image;
+    vector<cv::Mat> individual_images;
+    tie(result_image, individual_images) = make_image(clouds, T, sweep_paths, optional_text);
     return add_query_image(result_image, image, query_label);
     //return result_image;
 }
@@ -244,15 +258,16 @@ cv::Mat render_image(CloudT::Ptr& cloud, const Eigen::Matrix4f& T, const Eigen::
 }
 
 // the question is if we actually need the paths for this?
-cv::Mat make_image(std::vector<CloudT::Ptr>& results, const Eigen::Matrix4f& room_transform,
-                   vector<boost::filesystem::path>& sweep_paths, const std::vector<std::string>& optional_text)
+pair<cv::Mat, vector<cv::Mat> > make_image(std::vector<CloudT::Ptr>& results, const Eigen::Matrix4f& room_transform,
+                                           vector<boost::filesystem::path>& sweep_paths, const std::vector<std::string>& optional_text)
 {
-    pair<int, int> sizes = make_pair(1, 10);//get_similar_sizes(results.size());
+    pair<int, int> sizes = make_pair(1, std::min(10, int(results.size())));//get_similar_sizes(results.size());
 
     int width = 200;
     int height = 200;
 
     cv::Mat visualization = cv::Mat::zeros(height*sizes.first, width*sizes.second, CV_8UC3);
+    vector<cv::Mat> individual_images;
 
     int counter = 0;
     for (CloudT::Ptr& cloud : results) {
@@ -327,6 +342,7 @@ cv::Mat make_image(std::vector<CloudT::Ptr>& results, const Eigen::Matrix4f& roo
         int offset_height = counter / sizes.second;
         int offset_width = counter % sizes.second;
         sub_image.copyTo(visualization(cv::Rect(offset_width*width, offset_height*height, width, height)));
+        individual_images.push_back(sub_image);
 
         //cv::imshow("test", visualization);
         //cv::waitKey();
@@ -338,7 +354,7 @@ cv::Mat make_image(std::vector<CloudT::Ptr>& results, const Eigen::Matrix4f& roo
         visualization = cv::Mat::zeros(height*2, width*5, CV_8UC3);
     }
 
-    return visualization;
+    return make_pair(visualization, individual_images);
 }
 
 } // namespace benchmark_retrieval

dynamic_object_retrieval/dynamic_object_retrieval/CMakeLists.txt

@@ -16,13 +16,17 @@ add_definitions(-std=c++11 -O3)
 # Show where to find the find package scripts
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
 
+set(stopwatch_dir ${CMAKE_CURRENT_SOURCE_DIR}/stopwatch)
+set(stopwatch_include_dir ${stopwatch_dir}/src)
+
 # Define the locations of the k_means_tree project
 # If using catkin, including it using catkin instead
 if (catkin_FOUND)
     find_package(catkin REQUIRED COMPONENTS roscpp tf tf_conversions pcl_ros
                         metaroom_xml_parser object_manager k_means_tree convex_segmentation)
     set(ROS_LIBRARIES ${catkin_LIBRARIES})
     include_directories(${catkin_INCLUDE_DIRS})
+    #set(stopwatch_library_dir ${CATKIN_DEVEL_PREFIX}/stopwatch/build)
 else()
     set(k_means_tree_dir ${CMAKE_CURRENT_SOURCE_DIR}/../k_means_tree)
     set(k_means_tree_library_dir ${k_means_tree_dir}/build)
@@ -57,24 +61,23 @@ else()
 
     # Define the locations of cereal serialization header files
     set(cereal_include_dir ${CMAKE_CURRENT_SOURCE_DIR}/../k_means_tree/cereal/include)
+
+    # Only compile the stopwatch project if it's not with catkin
     include_directories(${cereal_include_dir})
+    set(stopwatch_library_dir ${stopwatch_dir}/build)
+    # Compile the stopwatch project, needed for this
+    ExternalProject_Add(stopwatch_project
+      DOWNLOAD_COMMAND ""
+      SOURCE_DIR ${stopwatch_include_dir}
+      BINARY_DIR ${stopwatch_library_dir}
+      BUILD_COMMAND ${CMAKE_MAKE_PROGRAM}
+      INSTALL_COMMAND ""
+    )
 endif()
 
 # Eh, we need to somehow build this maybe?
-set(stopwatch_dir ${CMAKE_CURRENT_SOURCE_DIR}/stopwatch)
-set(stopwatch_include_dir ${stopwatch_dir}/src)
-set(stopwatch_library_dir ${stopwatch_dir}/build)
 include_directories(${stopwatch_include_dir})
 
-# Compile the stopwatch project, needed for this
-ExternalProject_Add(stopwatch_project
-  DOWNLOAD_COMMAND ""
-  SOURCE_DIR ${stopwatch_include_dir}
-  BINARY_DIR ${stopwatch_library_dir}
-  BUILD_COMMAND ${CMAKE_MAKE_PROGRAM}
-  INSTALL_COMMAND ""
-)
-
 # Find PCL
 find_package(PCL 1.6 REQUIRED COMPONENTS common io search visualization surface kdtree features surface segmentation octree filter keypoints)
 include_directories(${PCL_INCLUDE_DIRS})