Official 14.04 on Indigo

Author: cassinaj

README.md

@@ -20,8 +20,9 @@ The core of this library are two probabilistic tracker
 All trackers require mesh models of the tracked objects in Wavefront (.obj) format.
 
 # Requirements
- * Ubuntu 12.04
- * C++0x or C++11 Compiler (gcc-4.6 or later)
+ * Ubuntu 14.04
+ * C++0x Compiler (gcc-4.6 or later)
+ * C++11 Compiler (gcc-4.7 or later)
  * [CUDA](https://developer.nvidia.com/cuda-downloads) 6.5 or later (optional)
 
 ## Dependecies

source/dbot/builder/gaussian_tracker_builder.cpp

@@ -21,8 +21,8 @@
  *
  */
 
-#include <dbot/simple_wavefront_object_loader.hpp>
-#include <dbot/builder/gaussian_tracker_builder.hpp>
+#include <dbot/builder/gaussian_tracker_builder.h>
+#include <dbot/simple_wavefront_object_loader.h>
 
 namespace dbot
 {
@@ -33,18 +33,17 @@ GaussianTrackerBuilder::GaussianTrackerBuilder(
 {
 }
 
-std::shared_ptr<GaussianTracker>
-GaussianTrackerBuilder::build()
+std::shared_ptr<GaussianTracker> GaussianTrackerBuilder::build()
 {
     auto object_model = create_object_model(param_.ori);
 
     auto filter = create_filter(object_model);
 
-    auto tracker = std::make_shared<GaussianTracker>(
-        filter,
-        object_model,
-        param_.moving_average_update_rate,
-        param_.center_object_frame);
+    auto tracker =
+        std::make_shared<GaussianTracker>(filter,
+                                          object_model,
+                                          param_.moving_average_update_rate,
+                                          param_.center_object_frame);
 
     return tracker;
 }
@@ -99,8 +98,7 @@ auto GaussianTrackerBuilder::create_sensor(
     return Sensor(body_tail_pixel_model, camera_data->pixels());
 }
 
-std::shared_ptr<ObjectModel>
-GaussianTrackerBuilder::create_object_model(
+std::shared_ptr<ObjectModel> GaussianTrackerBuilder::create_object_model(
     const ObjectResourceIdentifier& ori) const
 {
     auto object_model = std::make_shared<ObjectModel>(
@@ -112,18 +110,16 @@ GaussianTrackerBuilder::create_object_model(
 }
 
 auto GaussianTrackerBuilder::create_object_transition(
-    const ObjectTransitionBuilder<
-        GaussianTrackerBuilder::State>::Parameters& param) const
-    -> Transition
+    const ObjectTransitionBuilder<GaussianTrackerBuilder::State>::Parameters&
+        param) const -> Transition
 {
     ObjectTransitionBuilder<State> process_builder(param);
     auto process = process_builder.build_model();
 
     return process;
 }
 
-std::shared_ptr<RigidBodyRenderer>
-GaussianTrackerBuilder::create_renderer(
+std::shared_ptr<RigidBodyRenderer> GaussianTrackerBuilder::create_renderer(
     const std::shared_ptr<ObjectModel>& object_model) const
 {
     std::shared_ptr<RigidBodyRenderer> renderer(

source/dbot/builder/gaussian_tracker_builder.hpp renamed to source/dbot/builder/gaussian_tracker_builder.h

@@ -22,20 +22,19 @@
  */
 
 /**
- * \file gaussian_tracker_builder.hpp
+ * \file gaussian_tracker_builder.h
  * \date December 2015
  * \author Jan Issac (jan.issac@gmail.com)
  */
 
 #pragma once
 
+#include <dbot/builder/object_transition_builder.h>
+#include <dbot/camera_data.h>
+#include <dbot/object_resource_identifier.h>
+#include <dbot/tracker/gaussian_tracker.h>
 #include <exception>
 
-#include <dbot/camera_data.hpp>
-#include <dbot/object_resource_identifier.hpp>
-#include <dbot/tracker/gaussian_tracker.hpp>
-#include <dbot/builder/object_transition_builder.hpp>
-
 namespace dbot
 {
 /**
@@ -72,8 +71,7 @@ class GaussianTrackerBuilder
 
         ObjectResourceIdentifier ori;
         Observation observation;
-        ObjectTransitionBuilder<State>::Parameters
-            object_transition;
+        ObjectTransitionBuilder<State>::Parameters object_transition;
     };
 
 public:
@@ -82,9 +80,8 @@ class GaussianTrackerBuilder
      * \param param			Builder and sub-builder parameters
      * \param camera_data	Tracker camera data object
      */
-    GaussianTrackerBuilder(
-        const Parameters& param,
-        const std::shared_ptr<CameraData>& camera_data);
+    GaussianTrackerBuilder(const Parameters& param,
+                           const std::shared_ptr<CameraData>& camera_data);
 
     /**
      * \brief Builds the Rbc PF tracker
@@ -103,8 +100,7 @@ class GaussianTrackerBuilder
      *        filter
      */
     Transition create_object_transition(
-        const ObjectTransitionBuilder<State>::Parameters& param)
-        const;
+        const ObjectTransitionBuilder<State>::Parameters& param) const;
 
     /**
      * \brief Creates the Rbc particle filter observation model. This can either
@@ -113,10 +109,9 @@ class GaussianTrackerBuilder
      * \throws NoGpuSupportException if compile with DBOT_BUILD_GPU=OFF and
      *         attempting to build a tracker with GPU support
      */
-    Sensor create_sensor(
-        const std::shared_ptr<ObjectModel>& object_model,
-        const std::shared_ptr<CameraData>& camera_data,
-        const Parameters::Observation& param) const;
+    Sensor create_sensor(const std::shared_ptr<ObjectModel>& object_model,
+                         const std::shared_ptr<CameraData>& camera_data,
+                         const Parameters::Observation& param) const;
 
     /**
      * \brief Creates an object model renderer

source/dbot/builder/object_transition_builder.hpp renamed to source/dbot/builder/object_transition_builder.h

@@ -29,15 +29,12 @@
 
 #pragma once
 
-#include <memory>
-
-#include <fl/util/profiling.hpp>
-#include <fl/util/meta.hpp>
-
 #include <Eigen/Dense>
-
-#include <dbot/builder/transition_function_builder.hpp>
+#include <dbot/builder/transition_function_builder.h>
 #include <fl/model/transition/linear_transition.hpp>
+#include <fl/util/meta.hpp>
+#include <fl/util/profiling.hpp>
+#include <memory>
 
 namespace dbot
 {
@@ -57,20 +54,19 @@ struct ObjectStateTrait
 
 template <typename State>
 class ObjectTransitionBuilder
-    : public TransitionFunctionBuilder<
-          State,
-          typename ObjectStateTrait<State>::Noise,
-          typename ObjectStateTrait<State>::Input>
+    : public TransitionFunctionBuilder<State,
+                                       typename ObjectStateTrait<State>::Noise,
+                                       typename ObjectStateTrait<State>::Input>
 {
 public:
     typedef fl::TransitionFunction<State,
-                                        typename ObjectStateTrait<State>::Noise,
-                                        typename ObjectStateTrait<State>::Input>
+                                   typename ObjectStateTrait<State>::Noise,
+                                   typename ObjectStateTrait<State>::Input>
         Model;
-    typedef fl::LinearTransition<
-        State,
-        typename ObjectStateTrait<State>::Noise,
-        typename ObjectStateTrait<State>::Input> DerivedModel;
+    typedef fl::LinearTransition<State,
+                                 typename ObjectStateTrait<State>::Noise,
+                                 typename ObjectStateTrait<State>::Input>
+        DerivedModel;
 
     struct Parameters
     {
@@ -87,8 +83,8 @@ class ObjectTransitionBuilder
     ObjectTransitionBuilder(const Parameters& param) : param_(param) {}
     virtual std::shared_ptr<Model> build() const
     {
-        auto model = std::shared_ptr<DerivedModel>(
-            new DerivedModel(build_model()));
+        auto model =
+            std::shared_ptr<DerivedModel>(new DerivedModel(build_model()));
 
         return std::static_pointer_cast<Model>(model);
     }
@@ -116,17 +112,17 @@ class ObjectTransitionBuilder
         part_A.rightCols(6) *= param_.velocity_factor;
 
         part_B.setZero();
-        part_B.block(0, 0, 3, 3) = Eigen::DiagonalMatrix<double, 3>(
-                    param_.linear_sigma_x,
-                    param_.linear_sigma_y,
-                    param_.linear_sigma_z);
-//            Eigen::Matrix3d::Identity() * param_.linear_sigma;
-        part_B.block(3, 3, 3, 3) = Eigen::DiagonalMatrix<double, 3>(
-                    param_.angular_sigma_x,
-                    param_.angular_sigma_y,
-                    param_.angular_sigma_z);
-
-//            Eigen::Matrix3d::Identity() * param_.angular_sigma;
+        part_B.block(0, 0, 3, 3) =
+            Eigen::DiagonalMatrix<double, 3>(param_.linear_sigma_x,
+                                             param_.linear_sigma_y,
+                                             param_.linear_sigma_z);
+        //            Eigen::Matrix3d::Identity() * param_.linear_sigma;
+        part_B.block(3, 3, 3, 3) =
+            Eigen::DiagonalMatrix<double, 3>(param_.angular_sigma_x,
+                                             param_.angular_sigma_y,
+                                             param_.angular_sigma_z);
+
+        //            Eigen::Matrix3d::Identity() * param_.angular_sigma;
         part_B.bottomRows(6) = part_B.topRows(6);
 
         for (int i = 0; i < param_.part_count; ++i)
@@ -142,7 +138,6 @@ class ObjectTransitionBuilder
         return model;
     }
 
-
 private:
     Parameters param_;
 };

source/dbot/builder/particle_tracker_builder.cpp

@@ -21,48 +21,5 @@
  *
  */
 
-#include <dbot/simple_wavefront_object_loader.hpp>
-#include <dbot/builder/particle_tracker_builder.hpp>
-
-
-//namespace dbot
-//{
-//ParticleTrackerBuilder::ParticleTrackerBuilder(
-//    const std::shared_ptr<TransitionFunctionBuilder>&
-//        transition_builder,
-//    const CameraData& camera_data)
-//    : transition_builder_(transition_builder),
-//      camera_data_(camera_data)
-//{
-//}
-
-//std::shared_ptr<ParticleTracker>
-//ParticleTrackerBuilder::build()
-
-//auto ParticleTrackerBuilder::create_filter(
-//    const ObjectModel& object_model,
-//    double max_kl_divergence) -> std::shared_ptr<Filter>
-
-//auto ParticleTrackerBuilder::create_object_transition() const
-//    -> std::shared_ptr<Transition>
-
-
-//ObjectModel ParticleTrackerBuilder::create_object_model(
-//    const ObjectResourceIdentifier& ori) const
-
-//std::vector<std::vector<size_t>>
-//ParticleTrackerBuilder::create_sampling_blocks(int blocks,
-//                                                        int block_size) const
-//{
-//    std::vector<std::vector<size_t>> sampling_blocks(params_.ori.count_meshes());
-//    for (int i = 0; i < blocks; ++i)
-//    {
-//        for (int k = 0; k < block_size; ++k)
-//        {
-//            sampling_blocks[i].push_back(i * block_size + k);
-//        }
-//    }
-
-//    return sampling_blocks;
-//}
-//}
+#include <dbot/builder/particle_tracker_builder.h>
+#include <dbot/simple_wavefront_object_loader.h>

source/dbot/builder/particle_tracker_builder.hpp renamed to source/dbot/builder/particle_tracker_builder.h

@@ -22,24 +22,22 @@
  */
 
 /**
- * \file particle_tracker_builder.hpp
+ * \file particle_tracker_builder.h
  * \date November 2015
  * \author Jan Issac (jan.issac@gmail.com)
  */
 
 #pragma once
 
-#include <exception>
-
-#include <dbot/object_model_loader.hpp>
-#include <dbot/object_resource_identifier.hpp>
-#include <dbot/tracker/particle_tracker.hpp>
-#include <dbot/builder/object_transition_builder.hpp>
+#include <dbot/builder/object_transition_builder.h>
 #include <dbot/builder/rb_sensor_builder.h>
+#include <dbot/object_model_loader.h>
+#include <dbot/object_resource_identifier.h>
+#include <dbot/tracker/particle_tracker.h>
+#include <exception>
 
 namespace dbot
 {
-
 /**
  * \brief Represents an Rbc Particle filter based tracker builder
  */
@@ -52,8 +50,7 @@ class ParticleTrackerBuilder
     typedef typename Tracker::Input Input;
 
     /* == Model Builder Interfaces ========================================== */
-    typedef TransitionFunctionBuilder<State, Noise, Input>
-        TransitionBuilder;
+    typedef TransitionFunctionBuilder<State, Noise, Input> TransitionBuilder;
     typedef RbSensorBuilder<State> SensorBuilder;
 
     /* == Model Interfaces ================================================== */
@@ -62,8 +59,7 @@ class ParticleTrackerBuilder
     typedef typename Sensor::Observation Obsrv;
 
     /* == Filter algorithm ================================================== */
-    typedef RaoBlackwellCoordinateParticleFilter<Transition,
-                                                 Sensor> Filter;
+    typedef RaoBlackwellCoordinateParticleFilter<Transition, Sensor> Filter;
 
     /* == Tracker parameters ================================================ */
     struct Parameters
@@ -103,7 +99,7 @@ class ParticleTrackerBuilder
             object_model_,
             params_.evaluation_count,
             params_.moving_average_update_rate,
-            params_.center_object_frame);        
+            params_.center_object_frame);
 
         return tracker;
     }
@@ -121,15 +117,12 @@ class ParticleTrackerBuilder
         auto transition = transition_builder_->build();
         auto sensor = sensor_builder_->build();
 
-        auto sampling_blocks =
-            create_sampling_blocks(object_model->count_parts(),
-                                   transition->noise_dimension() /
-                                       object_model->count_parts());
+        auto sampling_blocks = create_sampling_blocks(
+            object_model->count_parts(),
+            transition->noise_dimension() / object_model->count_parts());
 
-        auto filter = std::shared_ptr<Filter>(new Filter(transition,
-                                                         sensor,
-                                                         sampling_blocks,
-                                                         max_kl_divergence));
+        auto filter = std::shared_ptr<Filter>(
+            new Filter(transition, sensor, sampling_blocks, max_kl_divergence));
         return filter;
     }
 

source/dbot/builder/rb_sensor_builder.cpp

@@ -27,13 +27,11 @@
  * \author Jan Issac (jan.issac@gmail.com)
  */
 
-#include <dbot/pose/free_floating_rigid_bodies_state.hpp>
-
 #include <dbot/builder/rb_sensor_builder.h>
 #include <dbot/builder/rb_sensor_builder.hpp>
-
+#include <dbot/pose/free_floating_rigid_bodies_state.h>
 
 namespace dbot
 {
-template class RbSensorBuilder<osr::FreeFloatingRigidBodiesState<>>;
+template class RbSensorBuilder<dbot::FreeFloatingRigidBodiesState<>>;
 }