diff --git a/.settings/language.settings.xml b/.settings/language.settings.xml
index c588c28637ad0e14480e5c2ed2309f04e8e12931..5c600911b1171a0f9b6c2e8b05326e3a3daa9ed9 100644
--- a/.settings/language.settings.xml
+++ b/.settings/language.settings.xml
@@ -5,7 +5,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider copy-of="extension" id="org.eclipse.cdt.managedbuilder.core.GCCBuildCommandParser"/>
-			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1476617952823822664" id="org.eclipse.cdt.managedbuilder.core.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1504749124108071272" id="org.eclipse.cdt.managedbuilder.core.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e92ae5fb389b4aacb583525642f433153dd7e605..fe494bf234b90dc2d9490a3f08a93a4263b042f4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,8 +1,8 @@
 # library source files
-SET(sources vision_utils.cpp cam_utils/cam_utils.cpp feature_detector/feature_detector.cpp feature_descriptor/feature_descriptor.cpp feature_matcher/feature_matcher.cpp)
+SET(sources vision_utils.cpp vu_base/vu_base.cpp cam_utils/cam_utils.cpp feature_detector/feature_detector.cpp feature_descriptor/feature_descriptor.cpp feature_matcher/feature_matcher.cpp)
 
 # application header files
-SET(headers vision_utils.h cam_utils/cam_utils.h feature_detector/feature_detector.h feature_descriptor/feature_descriptor.h feature_matcher/feature_matcher.h)
+SET(headers vision_utils.h vu_base/vu_base.h cam_utils/cam_utils.h feature_detector/feature_detector.h feature_descriptor/feature_descriptor.h feature_matcher/feature_matcher.h)
 
 # locate the necessary dependencies
 FIND_PACKAGE(Eigen3 REQUIRED)
diff --git a/src/examples/capture.cpp b/src/examples/capture.cpp
index 19a31ad7742c0d34c7b0dc23da5d9a54c997e239..72e9af778dce0d131b7f2b9d17463bbbaacac6af 100644
--- a/src/examples/capture.cpp
+++ b/src/examples/capture.cpp
@@ -1,9 +1,8 @@
 // OWN stuff
-#include "vision_utils.h"
-
-// STD stuff
 #include <string>
 
+#include "../vision_utils.h"
+
 int main(int argc, char *argv[])
 {
     // Open camera
diff --git a/src/examples/feature_detectors.cpp b/src/examples/feature_detectors.cpp
index 93e48e41f8796e0b95453d1c5a80629307542faa..14bf3b2ede694430eae1e98ab9ff336040caae10 100644
--- a/src/examples/feature_detectors.cpp
+++ b/src/examples/feature_detectors.cpp
@@ -1,14 +1,16 @@
 // OWN stuff
-#include "vision_utils.h"
-
-// STD stuff
 #include <string>
 
+#include "../vision_utils.h"
+
 
 int main(int argc, char *argv[])
 {
     CFeature_Detector detector;
-    std::vector<detector::Type> detectors_list;
+    CDetector_Params detector_params;
+
+//    std::vector<detector::Type> detectors_list;
+    std::vector<std::string> detectors_list;
     detectors_list = detector.list();
 
     std::cout << "----------------------------------------" << std::endl;
@@ -22,7 +24,8 @@ int main(int argc, char *argv[])
     std::cout << std::endl << "Which DETECTOR do you want to test?: ";
     int feat_type;
     std::cin >> feat_type;
-    detector.setType(feat_type);
+//    detector.setType(feat_type);
+    detector.set(feat_type,detector_params);
     std::cout << std::endl << "Testing: " << detectors_list[feat_type] << std::endl;
 
     // Open camera
diff --git a/src/examples/feature_detectors_and_descriptors.cpp b/src/examples/feature_detectors_and_descriptors.cpp
index 432aea803161c212565f356676d985aa0b778b6c..56db99b1032a8921f08e85af39f637d3e27bb135 100644
--- a/src/examples/feature_detectors_and_descriptors.cpp
+++ b/src/examples/feature_detectors_and_descriptors.cpp
@@ -1,90 +1,89 @@
 // OWN stuff
-#include "vision_utils.h"
-
-// STD stuff
 #include <string>
 
+#include "../vision_utils.h"
+
 
 int main(int argc, char *argv[])
 {
-    CFeature_Detector detector;
-    std::vector<detector::Type> detectors_list;
-    detectors_list = detector.list();
-
-    std::cout << "---------------------------------------------------------" << std::endl;
-    std::cout << "|       Feature detectors and descriptors example       |" << std::endl;
-    std::cout << "---------------------------------------------------------" << std::endl;
-    std::cout << std::endl;
-
-    for (unsigned int ii=0; ii<detectors_list.size(); ii++)
-    {
-    	if ( (detectors_list[ii]!= detector::LSD) && (detectors_list[ii] != detector::ED) )
-    		std::cout << "[" << ii << "]: " << detectors_list[ii] << std::endl;
-    }
-
-    std::cout << std::endl << "Which DETECTOR do you want to test?: ";
-    int feat_type;
-    std::cin >> feat_type;
-    detector.setType(feat_type);
-
-    CFeature_Descriptor descriptor;
-    std::vector<descriptor::Type> descriptor_list;
-    descriptor_list = descriptor.list();
-
-    for (unsigned int ii=0; ii<descriptor_list.size(); ii++)
-        std::cout << "[" << ii << "]: " << descriptor_list[ii] << std::endl;
-
-    std::cout << std::endl << "Which DESCRIPTOR do you want to test?: ";
-    int desc_type;
-    std::cin >> desc_type;
-    descriptor.setType(desc_type);
-    std::cout << std::endl << "Testing: " << detectors_list[feat_type] << " + " << descriptor_list[feat_type] << " (DETECTOR + DESCRIPTOR)" << std::endl;
-
-    // Open camera
-    cv::VideoCapture cam;
-    CCamUtils cam_fc;
-    cam_fc.openCamera(0, cam);
-
-    // Create displays
-    cv::startWindowThread();
-    cv::namedWindow("Original image", cv::WINDOW_NORMAL);
-    cv::namedWindow("Detections", cv::WINDOW_NORMAL);
-
-    // The following line is used to remove the OpenCV "init done" from the terminal
-    std::cout << "\e[A" << "         " << std::endl;
-
-    for (int nframe = 0; nframe < 1000; ++nframe)
-    {
-        // Get frame
-        cv::Mat frame;
-        cam_fc.getFrame(cam, frame);
-
-        // Show ORIGINAL frame
-        cv::imshow("Original image", frame);
-
-      	// Detector
-        CFeature_Detector::KeyPointVector keypoints;
-        keypoints = detector.detectKeyPoints(frame);
-
-        // Descriptor
-        cv::Mat descriptors;
-        descriptors = descriptor.getDescriptor(frame,keypoints);
-
-        // Show frame with features
-        detector.drawKeyFeatures(frame, keypoints);
-
-        std::cout << "\e[A" <<
-        		"Detection time: " << detector.getTime() << "    " <<
-				"Description time: " << descriptor.getTime() << "    " <<
-        		"TOTAL time: " << detector.getTime() + descriptor.getTime() << std::endl;
-
-        // Show NEW frame
-        cv::imshow("Detections", frame);
-        cv::waitKey(1);
-        // if (cv::waitKey(30) >= 0) break;
-    }
-
-    cv::destroyAllWindows();
+//    CFeature_Detector detector;
+//    std::vector<detector::Type> detectors_list;
+//    detectors_list = detector.list();
+//
+//    std::cout << "---------------------------------------------------------" << std::endl;
+//    std::cout << "|       Feature detectors and descriptors example       |" << std::endl;
+//    std::cout << "---------------------------------------------------------" << std::endl;
+//    std::cout << std::endl;
+//
+//    for (unsigned int ii=0; ii<detectors_list.size(); ii++)
+//    {
+//    	if ( (detectors_list[ii]!= detector::LSD) && (detectors_list[ii] != detector::ED) )
+//    		std::cout << "[" << ii << "]: " << detectors_list[ii] << std::endl;
+//    }
+//
+//    std::cout << std::endl << "Which DETECTOR do you want to test?: ";
+//    int feat_type;
+//    std::cin >> feat_type;
+//    detector.setType(feat_type);
+//
+//    CFeature_Descriptor descriptor;
+//    std::vector<descriptor::Type> descriptor_list;
+//    descriptor_list = descriptor.list();
+//
+//    for (unsigned int ii=0; ii<descriptor_list.size(); ii++)
+//        std::cout << "[" << ii << "]: " << descriptor_list[ii] << std::endl;
+//
+//    std::cout << std::endl << "Which DESCRIPTOR do you want to test?: ";
+//    int desc_type;
+//    std::cin >> desc_type;
+//    descriptor.setType(desc_type);
+//    std::cout << std::endl << "Testing: " << detectors_list[feat_type] << " + " << descriptor_list[feat_type] << " (DETECTOR + DESCRIPTOR)" << std::endl;
+//
+//    // Open camera
+//    cv::VideoCapture cam;
+//    CCamUtils cam_fc;
+//    cam_fc.openCamera(0, cam);
+//
+//    // Create displays
+//    cv::startWindowThread();
+//    cv::namedWindow("Original image", cv::WINDOW_NORMAL);
+//    cv::namedWindow("Detections", cv::WINDOW_NORMAL);
+//
+//    // The following line is used to remove the OpenCV "init done" from the terminal
+//    std::cout << "\e[A" << "         " << std::endl;
+//
+//    for (int nframe = 0; nframe < 1000; ++nframe)
+//    {
+//        // Get frame
+//        cv::Mat frame;
+//        cam_fc.getFrame(cam, frame);
+//
+//        // Show ORIGINAL frame
+//        cv::imshow("Original image", frame);
+//
+//      	// Detector
+//        CFeature_Detector::KeyPointVector keypoints;
+//        keypoints = detector.detectKeyPoints(frame);
+//
+//        // Descriptor
+//        cv::Mat descriptors;
+//        descriptors = descriptor.getDescriptor(frame,keypoints);
+//
+//        // Show frame with features
+//        detector.drawKeyFeatures(frame, keypoints);
+//
+//        std::cout << "\e[A" <<
+//        		"Detection time: " << detector.getTime() << "    " <<
+//				"Description time: " << descriptor.getTime() << "    " <<
+//        		"TOTAL time: " << detector.getTime() + descriptor.getTime() << std::endl;
+//
+//        // Show NEW frame
+//        cv::imshow("Detections", frame);
+//        cv::waitKey(1);
+//        // if (cv::waitKey(30) >= 0) break;
+//    }
+//
+//    cv::destroyAllWindows();
 }
 
 
diff --git a/src/feature_descriptor/feature_descriptor.cpp b/src/feature_descriptor/feature_descriptor.cpp
index 3ab6871d495e09ded1cb3b379b8a0271b46726bf..2ae1a3124091833c6439776f655214f45ac8312a 100644
--- a/src/feature_descriptor/feature_descriptor.cpp
+++ b/src/feature_descriptor/feature_descriptor.cpp
@@ -1,7 +1,8 @@
 #include "feature_descriptor.h"
 
 CFeature_Descriptor::CFeature_Descriptor(const descriptor::Type& _type) :
-		type_(descriptor::__DELIM__), is_init_(false), descript_time_(0.0) {
+		type_(descriptor::__DELIM__)
+{
 
 	is_init_ = init(_type);
 
@@ -13,7 +14,8 @@ CFeature_Descriptor::CFeature_Descriptor(const descriptor::Type& _type) :
 }
 
 CFeature_Descriptor::CFeature_Descriptor(const int&_type) :
-		type_(descriptor::__DELIM__), is_init_(false), descript_time_(0.0) {
+		type_(descriptor::__DELIM__)
+{
 
 	is_init_ = init(intToType(_type));
 
@@ -25,7 +27,8 @@ CFeature_Descriptor::CFeature_Descriptor(const int&_type) :
 }
 
 CFeature_Descriptor::CFeature_Descriptor() :
-		type_(descriptor::__DELIM__), is_init_(false), descript_time_(0.0) {
+		type_(descriptor::__DELIM__)
+{
 }
 
 CFeature_Descriptor::~CFeature_Descriptor() {
@@ -55,11 +58,6 @@ bool CFeature_Descriptor::setType(const int& _type)
     return is_init_;
 }
 
-double CFeature_Descriptor::getTime(void)
-{
-    return descript_time_;
-}
-
 bool CFeature_Descriptor::init(descriptor::Type _type) {
 	if (is_init_)
 		std::cerr
@@ -137,7 +135,7 @@ cv::Mat CFeature_Descriptor::getDescriptor(const cv::Mat& _image, CFeature_Descr
 
     clock_t tStart = clock();
     feature_descriptor_->compute(_image, _kpts, descriptors);
-    descript_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
+    comp_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
 
     return descriptors;
 }
diff --git a/src/feature_descriptor/feature_descriptor.h b/src/feature_descriptor/feature_descriptor.h
index d895cac4ba52cfffa1fd3669f33d91ba02002b56..614b1bbed4827b1e464a77c9bde3c1e5376050bb 100644
--- a/src/feature_descriptor/feature_descriptor.h
+++ b/src/feature_descriptor/feature_descriptor.h
@@ -3,7 +3,10 @@
 
 #include <time.h>
 
-// OpenCV stuff
+// own
+#include "vu_base/vu_base.h"
+
+// OpenCV
 #include <opencv2/core/core.hpp>
 #include <opencv2/core/types.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
@@ -52,7 +55,7 @@ inline std::ostream& operator<<(std::ostream& _os, Type _f) {
 
 } // end of namespace
 
-class CFeature_Descriptor {
+class CFeature_Descriptor: public CVu_Base {
 
 public:
 
@@ -76,11 +79,6 @@ public:
 	bool setType(const descriptor::Type& _type);
 	bool setType(const int& _type);
 
-	/**
-	 * \brief Get detection duration
-	 */
-	double getTime(void);
-
 	/**
 	 * \brief Get descriptors
 	 */
@@ -91,11 +89,6 @@ private:
 
 	descriptor::Type type_;
 
-	// Flags
-	bool is_init_;
-
-	double descript_time_; // Detection time
-
 	FeatureDescriptorPtr feature_descriptor_; // Feature point descriptor
 
 	/**
diff --git a/src/feature_detector/feature_detector.cpp b/src/feature_detector/feature_detector.cpp
index 3e1b93ed00b7a9cc02763063d10063f1b67accf4..9353c9cdcf45af42de64ce0d17accb61398ccf0e 100644
--- a/src/feature_detector/feature_detector.cpp
+++ b/src/feature_detector/feature_detector.cpp
@@ -1,9 +1,9 @@
 #include "feature_detector.h"
 
-CFeature_Detector::CFeature_Detector(const detector::Type& _type) :
-        type_(detector::__DELIM__), is_init_(false), is_line_(false), is_limited_(false), keypoints_limit_(-1), detect_time_(0.0)
+CFeature_Detector::CFeature_Detector(const std::string& _type, const CDetector_Params& _params) :
+        is_line_(false), is_limited_(false), keypoints_limit_(-1)
 {
-    is_init_ = init(_type);
+    is_init_ = init(_type, _params);
 
     if (!is_init_)
     {
@@ -12,11 +12,10 @@ CFeature_Detector::CFeature_Detector(const detector::Type& _type) :
     }
 }
 
-CFeature_Detector::CFeature_Detector(const int&_type) :
-        type_(detector::__DELIM__), is_init_(false), is_line_(false), is_limited_(false), keypoints_limit_(-1), detect_time_(0.0)
+CFeature_Detector::CFeature_Detector(const int& _type, const CDetector_Params& _params) :
+        is_line_(false), is_limited_(false), keypoints_limit_(-1)
 {
-	intToType(_type,type_);
-	is_init_ = init(type_);
+    is_init_ = initFromInt(_type, _params);
 
     if (!is_init_)
     {
@@ -26,7 +25,7 @@ CFeature_Detector::CFeature_Detector(const int&_type) :
 }
 
 CFeature_Detector::CFeature_Detector(void) :
-        type_(detector::__DELIM__), is_init_(false), is_line_(false), is_limited_(false), keypoints_limit_(-1), detect_time_(0.0)
+        is_line_(false), is_limited_(false), keypoints_limit_(-1)
 {
 }
 
@@ -34,35 +33,303 @@ CFeature_Detector::~CFeature_Detector()
 {
 }
 
-std::vector<detector::Type> CFeature_Detector::list(void)
+//CFeature_Detector::CFeature_Detector(const detector::Type& _type) :
+//        type_(detector::__DELIM__), is_line_(false), is_limited_(false), keypoints_limit_(-1)
+//{
+//    is_init_ = init(_type);
+//
+//    if (!is_init_)
+//    {
+//        std::cerr << "[Feature Detector]: Something went wrong during initialization! Feature Detector not initialized."
+//                << std::endl;
+//    }
+//}
+
+//CFeature_Detector::CFeature_Detector(const int&_type) :
+//        type_(detector::__DELIM__), is_line_(false), is_limited_(false), keypoints_limit_(-1)
+//{
+//	intToType(_type,type_);
+//	is_init_ = init(type_);
+//
+//    if (!is_init_)
+//    {
+//        std::cerr << "[Feature Detector]: Something went wrong during initialization! Feature Detector not initialized."
+//                << std::endl;
+//    }
+//}
+
+//CFeature_Detector::CFeature_Detector(void) :
+//        type_(detector::__DELIM__), is_line_(false), is_limited_(false), keypoints_limit_(-1)
+//{
+//}
+
+//CFeature_Detector::~CFeature_Detector()
+//{
+//}
+
+//std::vector<detector::Type> CFeature_Detector::list(void)
+//{
+//    std::vector<detector::Type> list;
+//
+//    for (int ii = 0; ii < detector::__DELIM__; ii++)
+//    {
+//        list.push_back(static_cast<detector::Type>(ii));
+//    }
+//
+//    return list;
+//}
+//
+//bool CFeature_Detector::setType(const detector::Type& _type)
+//{
+//    is_init_ = init(_type);
+//    return is_init_;
+//}
+//
+//bool CFeature_Detector::setType(const int& _type)
+//{
+//	detector::Type type;
+//	intToType(_type, type);
+//	is_init_ = init(type);
+//    return is_init_;
+//}
+//
+//bool CFeature_Detector::isLine(void)
+//{
+//    return is_line_;
+//}
+//
+//bool CFeature_Detector::isLimited(void)
+//{
+//    return is_limited_;
+//}
+//
+//int CFeature_Detector::getKeyPointsLimit(void)
+//{
+//    return keypoints_limit_;
+//}
+
+//void CFeature_Detector::intToType(const unsigned int _i, detector::Type& _type)
+//{
+//    for (unsigned int ii = 0; ii < detector::__DELIM__; ii++)
+//    {
+//        if (ii == _i)
+//            _type = static_cast<detector::Type>(ii);
+//    }
+//}
+//
+//bool CFeature_Detector::init(detector::Type _type)
+//{
+//    if (is_init_)
+//        std::cerr << "[CFeature_Detector::init]: Detector already initialized." << std::endl;
+//
+//    bool success = false;
+//
+//    // TODO: Set parameters for each detector type
+//    switch (_type)
+//    {
+//        case detector::FAST:
+//            feature_detector_ = cv::FastFeatureDetector::create();
+//            success = true;
+//            break;
+//        case detector::SIFT:
+//            feature_detector_ = cv::xfeatures2d::SIFT::create();
+//            success = true;
+//            break;
+//        case detector::SURF:
+//            feature_detector_ = cv::xfeatures2d::SURF::create();
+//            success = true;
+//            break;
+//        case detector::ORB:
+//            feature_detector_ = cv::ORB::create();
+//            success = true;
+//            break;
+//        case detector::BRISK:
+//            feature_detector_ = cv::BRISK::create();
+//            success = true;
+//            break;
+//        case detector::MSER:
+//            feature_detector_ = cv::MSER::create();
+//            success = true;
+//            break;
+//        case detector::GFTT:
+//            feature_detector_ = cv::GFTTDetector::create(1000, 0.01, 1.0, 3, false, 0.04);
+//            success = true;
+//            break;
+//        case detector::HARRIS:
+//            feature_detector_ = cv::GFTTDetector::create(1000, 0.01, 1.0, 3, true, 0.04);
+//            success = true;
+//            break;
+//        case detector::SBD:
+//            feature_detector_ = cv::SimpleBlobDetector::create();
+//            success = true;
+//            break;
+//        case detector::KAZE:
+//            feature_detector_ = cv::KAZE::create();
+//            success = true;
+//            break;
+//        case detector::AKAZE:
+//            feature_detector_ = cv::AKAZE::create();
+//            success = true;
+//            break;
+//        case detector::AGAST:
+//            feature_detector_ = cv::AgastFeatureDetector::create();
+//            success = true;
+//            break;
+//        case detector::LSD:
+//            lsd_detector_ = cv::line_descriptor::LSDDetector::createLSDDetector();
+//            is_line_ = true;
+//            success = true;
+//            break;
+//        case detector::ED:
+//            ed_detector_ = cv::line_descriptor::BinaryDescriptor::createBinaryDescriptor();
+//            is_line_ = true;
+//            success = true;
+//            break;
+//        case detector::__DELIM__:
+//            success = false;
+//            break;
+//    }
+//
+//    if (success)
+//        type_ = _type;
+//    else
+//        std::cerr << "[Feature Detector]: detector_type " << _type << " doesn't exist !" << std::endl;
+//
+//    return success;
+//}
+
+//CFeature_Detector::KeyPointVector CFeature_Detector::detectKeyPoints(const cv::Mat& _image)
+//{
+//	cv::Mat mask = cv::Mat::ones(_image.size(), CV_8U);
+//	return detectKeyPoints(_image, mask);
+//}
+//
+//CFeature_Detector::KeyPointVector CFeature_Detector::detectKeyPoints(const cv::Mat& _image, const cv::Mat& _mask)
+//{
+//    if (!is_init_)
+//        std::cerr << "[CFeature_Detector::detectKeyPoints]: Detector non initialized." << std::endl;
+//
+//    KeyPointVector kpts;
+//
+//    clock_t tStart = clock();
+//    feature_detector_->detect(_image, kpts, _mask);
+//    comp_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
+//
+//    if (isLimited())
+//    {
+//        cv::KeyPointsFilter filter;
+//        filter.retainBest(kpts, this->getKeyPointsLimit());
+//    }
+//
+//    return kpts;
+//}
+//
+//CFeature_Detector::KeyLineVector CFeature_Detector::detectKeyLines(const cv::Mat& _image)
+//{
+//	cv::Mat mask = cv::Mat::ones(_image.size(), CV_8U);
+//	return detectKeyLines(_image, mask);
+//}
+//
+//CFeature_Detector::KeyLineVector CFeature_Detector::detectKeyLines(const cv::Mat& _image, const cv::Mat& _mask)
+//{
+//    if (!is_init_)
+//        std::cerr << "[CFeature_Detector::detectKeyLines]: Detector non initialized." << std::endl;
+//
+//    KeyLineVector kls;
+//    KeyLineVector kls2;
+//
+//    clock_t tStart = clock();
+//    if (type_ == detector::LSD)
+//        lsd_detector_->detect(_image, kls, SCALE_FACTOR_LINE_DETECTOR, NUM_OCTAVE_LINE_DETECTOR, _mask);
+//    else
+//        ed_detector_->detect(_image, kls2, _mask);
+//    comp_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
+//    kls.insert(kls.end(), kls2.begin(), kls2.end());
+//
+//    return kls;
+//}
+//
+//bool CFeature_Detector::setLimitKeypts(unsigned int _nFeatures)
+//{
+//    if (_nFeatures > 0)
+//    {
+//        keypoints_limit_ = _nFeatures;
+//        return is_limited_ = true;
+//    }
+//
+//    return false;
+//}
+//
+//cv::Mat CFeature_Detector::drawKeyFeatures(const cv::Mat& _image, const KeyPointVector& _kp_vec)
+//{
+//    cv::Mat img_out(_image);
+//
+//    for (unsigned int ii = 0; ii < _kp_vec.size(); ++ii)
+//        cv::circle(img_out, _kp_vec[ii].pt, 5, cv::Scalar(128, 128, 255), -1);
+//
+//    return img_out;
+//}
+//
+//cv::Mat CFeature_Detector::drawKeyFeatures(const cv::Mat& _image, const KeyLineVector& _kl_vec)
+//{
+//    cv::Mat img_out(_image);
+//
+//    for (unsigned int ii = 0; ii < _kl_vec.size(); ++ii)
+//        cv::line(img_out, _kl_vec[ii].getStartPoint(), _kl_vec[ii].getEndPoint(), cv::Scalar(128, 128, 255), 3);
+//
+//    return img_out;
+//}
+
+
+bool CFeature_Detector::init(const std::string& _type, const CDetector_Params& _params)
 {
-    std::vector<detector::Type> list;
+	// Define detector types
+	std::vector<std::string> det_types;
+	det_types += "FAST", "SIFT", "SURF", "ORB", "BRISK", "MSER", "GFTT", "HARRIS", "SBD", "KAZE", "AKAZE", "AGAST", "LSD", "ED";
+	types_.set(det_types);
 
-    for (int ii = 0; ii < detector::__DELIM__; ii++)
+	if (is_init_)
     {
-        list.push_back(static_cast<detector::Type>(ii));
+        std::cerr << "[CFeature_Detector::init]: Detector already initialized." << std::endl;
+        return false;
     }
 
-    return list;
-}
-
-bool CFeature_Detector::setType(const detector::Type& _type)
-{
-    is_init_ = init(_type);
-    return is_init_;
-}
-
-bool CFeature_Detector::setType(const int& _type)
-{
-	detector::Type type;
-	intToType(_type, type);
-	is_init_ = init(type);
-    return is_init_;
-}
+    // TODO: Set parameters for each detector type
+    if (_type.compare(det_types[0])==0)
+    	feature_detector_ = cv::FastFeatureDetector::create();
+    else if (_type.compare(det_types[1])==0)
+    	feature_detector_ = cv::xfeatures2d::SIFT::create();
+    else if (_type.compare(det_types[2])==0)
+    	feature_detector_ = cv::xfeatures2d::SURF::create();
+    else if (_type.compare(det_types[3])==0)
+    	feature_detector_ = cv::ORB::create();
+    else if (_type.compare(det_types[4])==0)
+    	feature_detector_ = cv::BRISK::create();
+    else if (_type.compare(det_types[5])==0)
+    	feature_detector_ = cv::MSER::create();
+    else if (_type.compare(det_types[6])==0)
+    	feature_detector_ = cv::GFTTDetector::create(1000, 0.01, 1.0, 3, false, 0.04);
+    else if (_type.compare(det_types[7])==0)
+    	feature_detector_ = cv::GFTTDetector::create(1000, 0.01, 1.0, 3, true, 0.04);
+    else if (_type.compare(det_types[8])==0)
+    	feature_detector_ = cv::SimpleBlobDetector::create();
+    else if (_type.compare(det_types[9])==0)
+    	feature_detector_ = cv::KAZE::create();
+    else if (_type.compare(det_types[10])==0)
+    	feature_detector_ = cv::AKAZE::create();
+    else if (_type.compare(det_types[11])==0)
+    	feature_detector_ = cv::AgastFeatureDetector::create();
+    else if (_type.compare(det_types[12])==0)
+        lsd_detector_ = cv::line_descriptor::LSDDetector::createLSDDetector();
+    else if (_type.compare(det_types[13])==0)
+    	ed_detector_ = cv::line_descriptor::BinaryDescriptor::createBinaryDescriptor();
+    else
+    {
+    	std::cerr << "[Feature Detector]: detector_type " << _type << " doesn't exist !" << std::endl;
+    	return false;
+    }
 
-double CFeature_Detector::getTime(void)
-{
-    return detect_time_;
+    return true;
 }
 
 bool CFeature_Detector::isLine(void)
@@ -95,7 +362,7 @@ CFeature_Detector::KeyPointVector CFeature_Detector::detectKeyPoints(const cv::M
 
     clock_t tStart = clock();
     feature_detector_->detect(_image, kpts, _mask);
-    detect_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
+    comp_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
 
     if (isLimited())
     {
@@ -121,11 +388,11 @@ CFeature_Detector::KeyLineVector CFeature_Detector::detectKeyLines(const cv::Mat
     KeyLineVector kls2;
 
     clock_t tStart = clock();
-    if (type_ == detector::LSD)
+    if (type_.compare("LSD")==0)
         lsd_detector_->detect(_image, kls, SCALE_FACTOR_LINE_DETECTOR, NUM_OCTAVE_LINE_DETECTOR, _mask);
     else
         ed_detector_->detect(_image, kls2, _mask);
-    detect_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
+    comp_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
     kls.insert(kls.end(), kls2.begin(), kls2.end());
 
     return kls;
@@ -162,92 +429,4 @@ cv::Mat CFeature_Detector::drawKeyFeatures(const cv::Mat& _image, const KeyLineV
     return img_out;
 }
 
-void CFeature_Detector::intToType(const unsigned int _i, detector::Type& _type)
-{
-    for (unsigned int ii = 0; ii < detector::__DELIM__; ii++)
-    {
-        if (ii == _i)
-            _type = static_cast<detector::Type>(ii);
-    }
-}
-
-bool CFeature_Detector::init(detector::Type _type)
-{
-    if (is_init_)
-        std::cerr << "[CFeature_Detector::init]: Detector already initialized." << std::endl;
-
-    bool success = false;
 
-    // TODO: Set parameters for each detector type
-    switch (_type)
-    {
-        case detector::FAST:
-            feature_detector_ = cv::FastFeatureDetector::create();
-            success = true;
-            break;
-        case detector::SIFT:
-            feature_detector_ = cv::xfeatures2d::SIFT::create();
-            success = true;
-            break;
-        case detector::SURF:
-            feature_detector_ = cv::xfeatures2d::SURF::create();
-            success = true;
-            break;
-        case detector::ORB:
-            feature_detector_ = cv::ORB::create();
-            success = true;
-            break;
-        case detector::BRISK:
-            feature_detector_ = cv::BRISK::create();
-            success = true;
-            break;
-        case detector::MSER:
-            feature_detector_ = cv::MSER::create();
-            success = true;
-            break;
-        case detector::GFTT:
-            feature_detector_ = cv::GFTTDetector::create(1000, 0.01, 1.0, 3, false, 0.04);
-            success = true;
-            break;
-        case detector::HARRIS:
-            feature_detector_ = cv::GFTTDetector::create(1000, 0.01, 1.0, 3, true, 0.04);
-            success = true;
-            break;
-        case detector::SBD:
-            feature_detector_ = cv::SimpleBlobDetector::create();
-            success = true;
-            break;
-        case detector::KAZE:
-            feature_detector_ = cv::KAZE::create();
-            success = true;
-            break;
-        case detector::AKAZE:
-            feature_detector_ = cv::AKAZE::create();
-            success = true;
-            break;
-        case detector::AGAST:
-            feature_detector_ = cv::AgastFeatureDetector::create();
-            success = true;
-            break;
-        case detector::LSD:
-            lsd_detector_ = cv::line_descriptor::LSDDetector::createLSDDetector();
-            is_line_ = true;
-            success = true;
-            break;
-        case detector::ED:
-            ed_detector_ = cv::line_descriptor::BinaryDescriptor::createBinaryDescriptor();
-            is_line_ = true;
-            success = true;
-            break;
-        case detector::__DELIM__:
-            success = false;
-            break;
-    }
-
-    if (success)
-        type_ = _type;
-    else
-        std::cerr << "[Feature Detector]: detector_type " << _type << " doesn't exist !" << std::endl;
-
-    return success;
-}
diff --git a/src/feature_detector/feature_detector.h b/src/feature_detector/feature_detector.h
index 6400c96804a9e276236d3e92bf4ee819ef230ba5..3bd8c04f4eb51106a2b633c089ec85438c5b9d71 100644
--- a/src/feature_detector/feature_detector.h
+++ b/src/feature_detector/feature_detector.h
@@ -3,10 +3,10 @@
 
 #include <time.h>
 
-// Own stuff
-#include "vision_utils.h"
+// Own
+#include <vu_base/vu_base.h>
 
-// OpenCV stuff
+// OpenCV
 #include <opencv2/core/core.hpp>
 #include <opencv2/core/types.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
@@ -22,148 +22,160 @@ typedef cv::Ptr<cv::FeatureDetector> FeatureDetectorPtr;
 typedef cv::Ptr<cv::line_descriptor::LSDDetector> LSDDetector;
 typedef cv::Ptr<cv::line_descriptor::BinaryDescriptor> EDDetector;
 
-namespace detector
-{
+//namespace detector {
+//
+///**
+// * \brief MACROS to generate all detector types and their corresponding strings
+// */
+//#define FOREACH_DETECTOR(DETECTOR) \
+//        DETECTOR(FAST)   \
+//        DETECTOR(SIFT)  \
+//        DETECTOR(SURF)   \
+//        DETECTOR(ORB)  \
+//        DETECTOR(BRISK)  \
+//        DETECTOR(MSER)  \
+//        DETECTOR(GFTT)  \
+//        DETECTOR(HARRIS)  \
+//        DETECTOR(SBD)  \
+//        DETECTOR(KAZE)  \
+//        DETECTOR(AKAZE)  \
+//        DETECTOR(AGAST)  \
+//        DETECTOR(LSD)  \
+//        DETECTOR(ED)  \
+//        DETECTOR(__DELIM__)  \
+//
+//#define GENERATE_ENUM(ENUM) ENUM,
+//#define GENERATE_STRING(STRING) #STRING,
+//enum Type {
+//	FOREACH_DETECTOR(GENERATE_ENUM)
+//};
+//static const char *DETECTOR_TYPE_STRING[] =
+//		{ FOREACH_DETECTOR(GENERATE_STRING) };
+//
+///**
+// * \brief Stream operator for the detector flags.
+// */
+//inline std::ostream& operator<<(std::ostream& _os, Type _f) {
+//	_os << DETECTOR_TYPE_STRING[_f];
+//	return _os;
+//}
+//
+//} // End of namespace
 
 /**
- * \brief MACROS to generate all detector types and their corresponding strings
+ * \brief Feature detector parameters class
  */
-#define FOREACH_DETECTOR(DETECTOR) \
-        DETECTOR(FAST)   \
-        DETECTOR(SIFT)  \
-        DETECTOR(SURF)   \
-        DETECTOR(ORB)  \
-        DETECTOR(BRISK)  \
-        DETECTOR(MSER)  \
-        DETECTOR(GFTT)  \
-        DETECTOR(HARRIS)  \
-        DETECTOR(SBD)  \
-        DETECTOR(KAZE)  \
-        DETECTOR(AKAZE)  \
-        DETECTOR(AGAST)  \
-        DETECTOR(LSD)  \
-        DETECTOR(ED)  \
-        DETECTOR(__DELIM__)  \
-
-#define GENERATE_ENUM(ENUM) ENUM,
-#define GENERATE_STRING(STRING) #STRING,
-enum Type
-{
-    FOREACH_DETECTOR(GENERATE_ENUM)
+class CDetector_Params: public CParams {
+public:
+	CDetector_Params(void) {
+	}
+	;
+	~CDetector_Params(void) {
+	}
+	;
 };
-static const char *DETECTOR_TYPE_STRING[] = {FOREACH_DETECTOR(GENERATE_STRING)};
-
-/**
- * \brief Stream operator for the detector flags.
- */
-inline std::ostream& operator<<(std::ostream& _os, Type _f)
-{
-    _os << DETECTOR_TYPE_STRING[_f];
-    return _os;
-}
-
-} // End of namespace
 
 /**
  * \brief Main feature detector class
  */
-class CFeature_Detector
-{
-    public:
-
-        typedef std::vector<cv::KeyPoint> KeyPointVector;
-        typedef std::vector<cv::line_descriptor::KeyLine> KeyLineVector;
-
-        /**
-         * \brief Constructor
-         */
-        CFeature_Detector(const detector::Type& _type);
-        CFeature_Detector(const int& _type);
-        CFeature_Detector(void);
-
-        /**
-         * \brief Destructor
-         */
-        ~CFeature_Detector();
-
-        /**
-         * \brief List the defined detector types
-         */
-        std::vector<detector::Type> list(void);
-
-        /**
-         * \brief Set detector type
-         */
-        bool setType(const detector::Type& _type);
-        bool setType(const int& _type);
-
-        /**
-         * \brief Get detection duration
-         */
-        double getTime(void);
-
-        /**
-         * \brief Inform if the detector searches points or lines
-         */
-        bool isLine(void);
-
-        /**
-         * \brief Inform if there is a maximum number of features to be detected
-         */
-        bool isLimited(void);
-
-        /**
-         * \brief Get number of maximum keypoints allowed
-         */
-        int getKeyPointsLimit(void);
-
-        /**
-         * \brief Set number of maximum keypoints allowed
-         */
-        bool setLimitKeypts(unsigned int _nFeatures);
-
-        /**
-         * \brief Detect features (points or lines)
-         */
-        KeyPointVector detectKeyPoints(const cv::Mat& _image);
-        KeyPointVector detectKeyPoints(const cv::Mat& _image, const cv::Mat& _mask);
-        KeyLineVector detectKeyLines(const cv::Mat& _image);
-        KeyLineVector detectKeyLines(const cv::Mat& _image, const cv::Mat& _mask);
-
-        /**
-         * \brief Draw detected features
-         */
-        cv::Mat drawKeyFeatures(const cv::Mat& _image, const KeyPointVector& _kp_vec);
-        cv::Mat drawKeyFeatures(const cv::Mat& _image, const KeyLineVector& _kl_vec);
-
-    private:
-
-        detector::Type type_;
-
-        // Flags
-        bool is_init_;
-        bool is_line_;
-        bool is_limited_;
-
-        unsigned int keypoints_limit_; // Max. number of keypoints (saturation)
-
-        double detect_time_; // Detection time
-
-        FeatureDetectorPtr feature_detector_; // Feature point detectors
-        LSDDetector lsd_detector_; // Feature line detector
-        EDDetector ed_detector_; // Feature line detector
-
-        /**
-         * \brief Initialize detector
-         */
-        bool init(detector::Type _type);
-
-        /**
-         * \brief Convert an integer to its corresponding detector flag.
-         *
-         * By default return ORB.
-         */
-        void intToType(const unsigned int _i, detector::Type& _type);
+class CFeature_Detector: public CVu_Base {
+public:
+
+	CTypes det_type_;
+
+	typedef std::vector<cv::KeyPoint> KeyPointVector;
+	typedef std::vector<cv::line_descriptor::KeyLine> KeyLineVector;
+
+	/**
+	 * \brief Constructor
+	 */
+//	CFeature_Detector(const detector::Type& _type);
+//	CFeature_Detector(const int& _type);
+//	CFeature_Detector(void);
+
+	CFeature_Detector(const std::string& _type, const CDetector_Params& _params);
+	CFeature_Detector(const int& _type, const CDetector_Params& _params);
+	CFeature_Detector(void);
+
+	/**
+	 * \brief Destructor
+	 */
+	~CFeature_Detector();
+
+	/**
+	 * \brief List the defined detector types
+	 */
+//	std::vector<detector::Type> list(void);
+
+	/**
+	 * \brief Set detector type
+	 */
+//	bool setType(const detector::Type& _type);
+//	bool setType(const int& _type);
+
+	/**
+	 * \brief Inform if the detector searches points or lines
+	 */
+	bool isLine(void);
+
+	/**
+	 * \brief Inform if there is a maximum number of features to be detected
+	 */
+	bool isLimited(void);
+
+	/**
+	 * \brief Get number of maximum keypoints allowed
+	 */
+	int getKeyPointsLimit(void);
+
+	/**
+	 * \brief Set number of maximum keypoints allowed
+	 */
+	bool setLimitKeypts(unsigned int _nFeatures);
+
+	/**
+	 * \brief Detect features (points or lines)
+	 */
+	KeyPointVector detectKeyPoints(const cv::Mat& _image);
+	KeyPointVector detectKeyPoints(const cv::Mat& _image, const cv::Mat& _mask);
+	KeyLineVector detectKeyLines(const cv::Mat& _image);
+	KeyLineVector detectKeyLines(const cv::Mat& _image, const cv::Mat& _mask);
+
+	/**
+	 * \brief Draw detected features
+	 */
+	cv::Mat drawKeyFeatures(const cv::Mat& _image,
+			const KeyPointVector& _kp_vec);
+	cv::Mat drawKeyFeatures(const cv::Mat& _image,
+			const KeyLineVector& _kl_vec);
+
+private:
+
+//	detector::Type type_;
+
+	// Flags
+	bool is_line_;
+	bool is_limited_;
+
+	unsigned int keypoints_limit_; // Max. number of keypoints (saturation)
+
+	FeatureDetectorPtr feature_detector_; // Feature point detectors
+	LSDDetector lsd_detector_; // Feature line detector
+	EDDetector ed_detector_; // Feature line detector
+
+	/**
+	 * \brief Initialize detector
+	 */
+//	bool init(detector::Type _type);
+
+	bool init(const std::string &_type, const CDetector_Params &_params);
+
+	/**
+	 * \brief Convert an integer to its corresponding detector flag.
+	 *
+	 * By default return ORB.
+	 */
+//	void intToType(const unsigned int _i, detector::Type& _type);
 
 };
 
diff --git a/src/feature_matcher/feature_matcher.cpp b/src/feature_matcher/feature_matcher.cpp
index 205cb68ee7d96b410534c8f3244203cb2a4313b4..989af848e44fb3f41777f2ae6ae9ce1076bc791d 100644
--- a/src/feature_matcher/feature_matcher.cpp
+++ b/src/feature_matcher/feature_matcher.cpp
@@ -1,7 +1,7 @@
 #include "feature_matcher.h"
 
 CFeature_Matcher::CFeature_Matcher(const matcher::Type& _type) :
-        type_(matcher::__DELIM__), is_init_(false), match_time_(0.0)
+        type_(matcher::__DELIM__)
 {
 
     is_init_ = init(_type);
@@ -14,7 +14,7 @@ CFeature_Matcher::CFeature_Matcher(const matcher::Type& _type) :
 }
 
 CFeature_Matcher::CFeature_Matcher(const int& _type) :
-        type_(matcher::__DELIM__), is_init_(false), match_time_(0.0)
+        type_(matcher::__DELIM__)
 {
 
     is_init_ = init(intToType(_type));
@@ -27,7 +27,7 @@ CFeature_Matcher::CFeature_Matcher(const int& _type) :
 }
 
 CFeature_Matcher::CFeature_Matcher(void) :
-        type_(matcher::__DELIM__), is_init_(false), match_time_(0.0)
+        type_(matcher::__DELIM__)
 {
 }
 
@@ -59,11 +59,6 @@ bool CFeature_Matcher::setType(const int& _type)
     return is_init_;
 }
 
-double CFeature_Matcher::getTime(void)
-{
-    return match_time_;
-}
-
 bool CFeature_Matcher::init(matcher::Type _type) {
     if (is_init_)
         std::cerr
@@ -120,7 +115,7 @@ bool CFeature_Matcher::init(matcher::Type _type) {
 //
 //    clock_t tStart = clock();
 //    feature_matcher_->compute(_image, _kpts, descriptors);
-//    match_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
+//    comp_time_ = (double)(clock() - tStart) / CLOCKS_PER_SEC;
 //
 //    return descriptors;
 //}
diff --git a/src/feature_matcher/feature_matcher.h b/src/feature_matcher/feature_matcher.h
index ac956ea4d9e71b3b4de5e2a16e0aa666061170f8..d6c2eec0eac79f679595a54c4d558ba39d11ec95 100644
--- a/src/feature_matcher/feature_matcher.h
+++ b/src/feature_matcher/feature_matcher.h
@@ -3,7 +3,10 @@
 
 #include <time.h>
 
-// OpenCV stuff
+// own
+#include "vu_base/vu_base.h"
+
+// OpenCV
 #include <opencv2/core/core.hpp>
 #include <opencv2/core/types.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
@@ -46,7 +49,7 @@ inline std::ostream& operator<<(std::ostream& _os, Type _f) {
 
 } // end of namespace
 
-class CFeature_Matcher
+class CFeature_Matcher: public CVu_Base
 {
     public:
 
@@ -67,11 +70,6 @@ class CFeature_Matcher
         bool setType(const matcher::Type& _type);
         bool setType(const int& _type);
 
-        /**
-         * \brief Get match duration
-         */
-        double getTime(void);
-
         /**
          * \brief Match
          */
@@ -82,11 +80,6 @@ class CFeature_Matcher
 
         matcher::Type type_;
 
-        // Flags
-        bool is_init_;
-
-        double match_time_; // Match time
-
         FeatureMatcherPtr feature_matcher_; // Feature matcher
 
         /**
diff --git a/src/vu_base/vu_base.cpp b/src/vu_base/vu_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb7967afd2bee59fe2558963d79acb0a2661b6ac
--- /dev/null
+++ b/src/vu_base/vu_base.cpp
@@ -0,0 +1,48 @@
+#include "vu_base.h"
+
+CVu_Base::CVu_Base(void): is_init_(false), comp_time_(0.0)
+{
+}
+
+CVu_Base::~CVu_Base(void) {
+}
+
+double CVu_Base::getTime(void)
+{
+    return comp_time_;
+}
+
+bool CVu_Base::init(const std::string &_type, const CParams &_params)
+{
+	return false;
+}
+
+bool CVu_Base::initFromInt(const int &_type, const CParams &_params)
+{
+	std::string name = types_(_type);
+	return init(name,_params);
+}
+
+std::vector<std::string> CVu_Base::list(void)
+{
+		std::vector<std::string> list;
+		list.reserve(types_.size());
+		for (unsigned int ii = 0; ii < types_.size(); ii++)
+		{
+			std::string name = types_(ii);
+			list.push_back(name);
+		}
+		return list;
+}
+
+bool CVu_Base::set(const std::string& _type, const CParams &_params)
+{
+    is_init_ = init(_type, _params);
+    return is_init_;
+}
+
+bool CVu_Base::set(const int& _type, const CParams &_params)
+{
+    is_init_ = initFromInt(_type, _params);
+    return is_init_;
+}
diff --git a/src/vu_base/vu_base.h b/src/vu_base/vu_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..135bdd127a623d642149f1a360b61aab573b513c
--- /dev/null
+++ b/src/vu_base/vu_base.h
@@ -0,0 +1,125 @@
+#ifndef _VU_BASE_H
+#define _VU_BASE_H
+
+#include <functional>
+#include <set>
+#include <iostream>
+
+#include <map>
+#include <vector>
+#include <string>
+#include <iostream>
+
+#include <boost/assign/std/vector.hpp> // for 'operator+=()'
+using namespace boost::assign; // bring 'operator+=()' into scope
+
+/**
+ * \brief Class to set object types
+ */
+class CTypes {
+
+public:
+
+	CTypes(void): init_(false) {};
+
+	~CTypes(void) {};
+
+	void set(std::vector<std::string> &_types)
+	{
+		for (unsigned int ii = 0; ii < _types.size(); ii++)
+		{ types_[_types[ii]] = ii; }
+		init_= true;
+	};
+
+	int operator()(const std::string &name) {
+		if (init_)
+		{
+			std::map<std::string, int>::const_iterator it = types_.find(name);
+			return it->second;
+		}
+		else
+		{
+			std::cerr << "[Vision Utils]: Wrong object initialization" << std::cout;
+		}
+		return 0;
+	};
+
+	std::string operator()(const int &num) {
+		if (init_)
+		{
+			for (std::map<std::string, int>::const_iterator it = types_.begin();it != types_.end(); ++it)
+			{
+				if (it->second == num)
+					return it->first;
+			}
+		}
+		else
+			std::cerr << "[Vision Utils]: Wrong object initialization" << std::cout;
+		return 0;
+	};
+
+	unsigned int size(void)
+	{ return types_.size(); }
+
+protected:
+
+	std::map<std::string, int> types_;
+	bool init_;
+};
+
+/**
+ * \brief Class to set object parameters
+ */
+class CParams {
+public:
+	CParams(void) {
+	}
+	;
+	~CParams(void) {
+	}
+	;
+};
+
+/**
+ * \brief base Class
+ */
+class CVu_Base {
+
+public:
+
+	CVu_Base(void);
+
+	~CVu_Base(void);
+
+	/**
+	 * \brief Get detection duration
+	 */
+	double getTime(void);
+
+	/**
+	 * \brief list types
+	 */
+	std::vector<std::string> list(void);
+
+	/**
+	 * \brief Set object without constructor
+	 */
+	bool set(const std::string& _type, const CParams &_params);
+	bool set(const int& _type, const CParams &_params);
+
+protected:
+
+	// Flags
+	bool is_init_;
+
+	double comp_time_; // Detection time
+
+	CTypes types_;
+
+	std::string type_;
+
+	virtual bool init(const std::string &_type, const CParams &_params);
+	bool initFromInt(const int &_type, const CParams &_params);
+};
+
+#endif