diff --git a/app/CalypAppModuleIf.cpp b/app/CalypAppModuleIf.cpp
index d595ca1..d7dadb8 100644
--- a/app/CalypAppModuleIf.cpp
+++ b/app/CalypAppModuleIf.cpp
@@ -214,8 +214,10 @@ bool CalypAppModuleIf::process()
 
 void CalypAppModuleIf::show()
 {
+#ifdef CALYP_THREADED_MODULES
   if( m_canceling )
     return;
+#endif
   switch( m_pcModule->m_iModuleType )
   {
   case ClpModuleType::FrameProcessing: {
diff --git a/app/CalypAppModuleIf.h b/app/CalypAppModuleIf.h
index 3f58b37..6fe7bce 100644
--- a/app/CalypAppModuleIf.h
+++ b/app/CalypAppModuleIf.h
@@ -49,8 +49,6 @@ class QDockWidget;
 class CalypStream;
 class CalypFrame;
 
-#define CLP_MODULE_MAX_NUM_FRAMES 5
-
 class VideoSubWindow;
 class ModuleSubWindow;
 
@@ -60,7 +58,6 @@ class CalypAppModuleIf : std::enable_shared_from_this<CalypAppModuleIf>,
 #else
                          public QObject
 #endif
-
 {
   friend class ModulesHandle;
   friend class ModuleHandleDock;
diff --git a/lib/CalypFrame.cpp b/lib/CalypFrame.cpp
index 95af05c..2d988a3 100644
--- a/lib/CalypFrame.cpp
+++ b/lib/CalypFrame.cpp
@@ -1280,6 +1280,12 @@ bool CalypFrame::toMat( cv::Mat& cvMat, bool convertToGray, bool scale, unsigned
       case CLP_COLOR_YUV:
         cv::cvtColor( tmpMat, cvMat, cv::COLOR_YCrCb2RGB );
         break;
+      case CLP_COLOR_RGB:
+      case CLP_COLOR_RGBA:
+        cvMat = tmpMat;
+        break;
+      default:
+        assert( false );
       }
     }
   }
diff --git a/lib/CalypOptions.cpp b/lib/CalypOptions.cpp
index e820653..6b4e2f9 100644
--- a/lib/CalypOptions.cpp
+++ b/lib/CalypOptions.cpp
@@ -46,8 +46,6 @@
 #include "config.h"
 #include "lib/CalypModuleIf.h"
 
-using namespace std;
-
 struct ParseFailure : public std::exception
 {
   std::string arg;
@@ -189,7 +187,13 @@ private:
  */
 CalypOptions& CalypOptions::operator()( const std::string& name, const std::string& desc )
 {
-  addOption( std::make_unique<boolOption>( name, desc ) );
+  addOptionInternal( std::make_unique<boolOption>( name, desc ) );
+  return *this;
+}
+
+CalypOptions& CalypOptions::addOption( const std::string& name, const std::string& desc )
+{
+  addOptionInternal( std::make_unique<boolOption>( name, desc ) );
   return *this;
 }
 
@@ -201,14 +205,27 @@ CalypOptions& CalypOptions::operator()( const std::string& name, const std::stri
 template <typename T>
 CalypOptions& CalypOptions::operator()( const std::string& name, T& storage, const std::string& desc )
 {
-  addOption( std::make_unique<StandardOption<T>>( name, storage, desc, std::string( "" ) ) );
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc, std::string( "" ) ) );
+  return *this;
+}
+template <typename T>
+CalypOptions& CalypOptions::addOption( const std::string& name, T& storage, const std::string& desc )
+{
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc, std::string( "" ) ) );
   return *this;
 }
 
 template <typename T>
 CalypOptions& CalypOptions::operator()( const std::string& name, T& storage, const std::string& desc, const std::string& defaults )
 {
-  addOption( std::make_unique<StandardOption<T>>( name, storage, desc ) );
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc ) );
+  return *this;
+}
+
+template <typename T>
+CalypOptions& CalypOptions::addOption( const std::string& name, T& storage, const std::string& desc, const std::string& defaults )
+{
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc ) );
   return *this;
 }
 
@@ -270,15 +287,15 @@ CalypOptions& CalypOptions::addOptions()
   return *this;
 }
 
-void CalypOptions::addOption( std::unique_ptr<OptionBase> opt )
+void CalypOptions::addOptionInternal( std::unique_ptr<OptionBase> opt )
 {
   auto names = std::make_unique<Option>();
   names->base_opt = std::move( opt );
   opt = nullptr;
-  string& opt_string = opt->opt_string;
+  const std::string& opt_string = names->base_opt->opt_string;
 
   size_t opt_start = 0;
-  for( size_t opt_end = 0; opt_end != string::npos; )
+  for( size_t opt_end = 0; opt_end != std::string::npos; )
   {
     opt_end = opt_string.find_first_of( ',', opt_start );
     bool force_short = 0;
@@ -287,7 +304,7 @@ void CalypOptions::addOption( std::unique_ptr<OptionBase> opt )
       opt_start++;
       force_short = 1;
     }
-    string opt_name = opt_string.substr( opt_start, opt_end - opt_start );
+    std::string opt_name = opt_string.substr( opt_start, opt_end - opt_start );
     if( force_short || opt_name.size() == 1 )
     {
       names->opt_short.push_back( opt_name );
@@ -303,7 +320,7 @@ void CalypOptions::addOption( std::unique_ptr<OptionBase> opt )
   opt_list.push_back( std::move( names ) );
 }
 
-static void setOptions( std::list<CalypOptions::Option*>& opt_list, const string& value )
+static void setOptions( std::list<CalypOptions::Option*>& opt_list, const std::string& value )
 {
   /* multiple options may be registered for the same name:
    *   allow each to parse value
@@ -314,7 +331,7 @@ static void setOptions( std::list<CalypOptions::Option*>& opt_list, const string
   }
 }
 
-bool CalypOptions::storePair( bool allow_long, bool allow_short, const string& name, const string& value )
+bool CalypOptions::storePair( bool allow_long, bool allow_short, const std::string& name, const std::string& value )
 {
   bool found = false;
   std::map<std::string, std::list<Option*>>::iterator opt_it;
@@ -342,7 +359,7 @@ bool CalypOptions::storePair( bool allow_long, bool allow_short, const string& n
     if( !m_bAllowUnkonw )
     {
       /* not found */
-      cerr << "Unknown option: `" << name << "' (value:`" << value << "')" << endl;
+      std::cerr << "Unknown option: `" << name << "' (value:`" << value << "')" << std::endl;
     }
     return false;
   }
@@ -351,7 +368,7 @@ bool CalypOptions::storePair( bool allow_long, bool allow_short, const string& n
   return true;
 }
 
-bool CalypOptions::storePair( const string& name, const string& value )
+bool CalypOptions::storePair( const std::string& name, const std::string& value )
 {
   return storePair( true, true, name, value );
 }
@@ -365,13 +382,13 @@ unsigned int CalypOptions::parseLONG( unsigned int argc, char* argv[] )  // NOLI
    *  --option=arg
    *  --option arg
    */
-  string arg( argv[0] );
-  size_t arg_opt_start = arg.find_first_not_of( '-' );
-  size_t arg_opt_sep = arg.find_first_of( '=' );
-  string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
+  std::string arg( argv[0] );
+  std::size_t arg_opt_start = arg.find_first_not_of( '-' );
+  std::size_t arg_opt_sep = arg.find_first_of( '=' );
+  std::string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
 
   unsigned int extra_argc_consumed = 0;
-  if( arg_opt_sep == string::npos )
+  if( arg_opt_sep == std::string::npos )
   {
 /* no argument found => argument in argv[1] (maybe) */
 /* xxx, need to handle case where option isn't required */
@@ -391,7 +408,7 @@ unsigned int CalypOptions::parseLONG( unsigned int argc, char* argv[] )  // NOLI
   else
   {
     /* argument occurs after option_sep */
-    string val = arg.substr( arg_opt_sep + 1 );
+    std::string val = arg.substr( arg_opt_sep + 1 );
     storePair( true, false, option, val );
   }
   return extra_argc_consumed;
@@ -400,7 +417,7 @@ unsigned int CalypOptions::parseLONG( unsigned int argc, char* argv[] )  // NOLI
 /**
  * returns number of extra arguments consumed
  */
-unsigned int CalypOptions::parseLONG( string arg )
+unsigned int CalypOptions::parseLONG( const std::string& arg )
 {
   /* gnu style long options can take the forms:
    *  --option=arg
@@ -408,10 +425,10 @@ unsigned int CalypOptions::parseLONG( string arg )
    */
   size_t arg_opt_start = arg.find_first_not_of( '-' );
   size_t arg_opt_sep = arg.find_first_of( '=' );
-  string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
+  std::string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
 
   unsigned int extra_argc_consumed = 0;
-  if( arg_opt_sep == string::npos )
+  if( arg_opt_sep == std::string::npos )
   {
     /* no argument found => argument in argv[1] (maybe) */
     /* xxx, need to handle case where option isn't required */
@@ -423,7 +440,7 @@ unsigned int CalypOptions::parseLONG( string arg )
   else
   {
     /* argument occurs after option_sep */
-    string val = arg.substr( arg_opt_sep + 1 );
+    std::string val = arg.substr( arg_opt_sep + 1 );
     storePair( true, false, option, val );
   }
   return extra_argc_consumed;
@@ -435,19 +452,19 @@ unsigned int CalypOptions::parseSHORT( unsigned int argc, char* argv[] )  // NOL
    *  --option arg
    *  -option arg
    */
-  string arg( argv[0] );
-  size_t arg_opt_start = arg.find_first_not_of( '-' );
-  string option = arg.substr( arg_opt_start );
+  std::string arg( argv[0] );
+  std::size_t arg_opt_start = arg.find_first_not_of( '-' );
+  std::string option = arg.substr( arg_opt_start );
   /* lookup option */
 
   /* argument in argv[1] */
   /* xxx, need to handle case where option isn't required */
   if( argc == 1 )
   {
-    cerr << "Not processing option without argument `" << option << "'" << endl;
+    std::cerr << "Not processing option without argument `" << option << "'" << std::endl;
     return 0; /* run out of argv for argument */
   }
-  storePair( false, true, option, string( argv[1] ) );
+  storePair( false, true, option, std::string( argv[1] ) );
 
   return 1;
 }
@@ -475,10 +492,10 @@ int CalypOptions::parse( unsigned int argc, char* argv[] )  // NOLINT
 }
 
 // NOLINTNEXTLINE(*-avoid-c-arrays)
-list<const char*> CalypOptions::scanArgv( unsigned int argc, char* argv[] )
+std::list<const char*> CalypOptions::scanArgv( unsigned int argc, char* argv[] )
 {
   /* a list for anything that didn't get handled as an option */
-  list<const char*> non_option_arguments;
+  std::list<const char*> non_option_arguments;
 
   for( unsigned int i = 1; i < argc; i++ )
   {
@@ -536,13 +553,13 @@ static const char spaces[41] = "                                        ";
  * using the formatting: "-x, --long",
  * if a short/long option isn't specified, it is not printed
  */
-static void doHelpOpt( ostream& out, const CalypOptions::Option& entry, unsigned int pad_short = 0 )
+static void doHelpOpt( std::ostream& out, const CalypOptions::Option& entry, unsigned int pad_short = 0 )
 {
-  pad_short = min( pad_short, 8u );
+  pad_short = std::min( pad_short, 8u );
 
   if( !entry.opt_short.empty() )
   {
-    unsigned int pad = max( (int)pad_short - (int)entry.opt_short.front().size(), 0 );
+    unsigned int pad = std::max( (int)pad_short - (int)entry.opt_short.front().size(), 0 );
     out << "-" << entry.opt_short.front();
     if( !entry.opt_long.empty() )
     {
@@ -563,19 +580,19 @@ static void doHelpOpt( ostream& out, const CalypOptions::Option& entry, unsigned
 }
 
 /* format the help text */
-void CalypOptions::doHelp( ostream& out, unsigned int columns )
+void CalypOptions::doHelp( std::ostream& out, unsigned int columns )
 {
   const unsigned int pad_short = 3;
   /* first pass: work out the longest option name */
   unsigned int max_width = 0;
   for( auto& opt : opt_list )
   {
-    ostringstream line( ios_base::out );
+    std::ostringstream line( std::ios_base::out );
     doHelpOpt( line, *opt, pad_short );
-    max_width = max( max_width, (unsigned int)line.tellp() );
+    max_width = std::max( max_width, (unsigned int)line.tellp() );
   }
 
-  unsigned int opt_width = min( max_width + 2, 28u + pad_short ) + 2;
+  unsigned int opt_width = std::min( max_width + 2, 28u + pad_short ) + 2;
   unsigned int desc_width = columns - opt_width;
 
   /* second pass: write out formatted option and help text.
@@ -585,15 +602,15 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
    */
   for( auto& opt : opt_list )
   {
-    ostringstream line( ios_base::out );
+    std::ostringstream line( std::ios_base::out );
     line << "  ";
     doHelpOpt( line, *opt, pad_short );
 
-    const string& opt_desc = opt->base_opt->opt_desc;
+    const std::string& opt_desc = opt->base_opt->opt_desc;
     if( opt_desc.empty() )
     {
       /* no help text: output option, skip further processing */
-      cout << line.str() << endl;
+      std::cout << line.str() << std::endl;
       continue;
     }
     size_t currlength = size_t( line.tellp() );
@@ -601,17 +618,17 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
     {
       /* if option text is too long (and would collide with the
        * help text, split onto next line */
-      line << endl;
+      line << std::endl;
       currlength = 0;
     }
     /* split up the help text, taking into account new lines,
      *   (add opt_width of padding to each new line) */
-    for( size_t newline_pos = 0, cur_pos = 0; cur_pos != string::npos; currlength = 0 )
+    for( std::size_t newline_pos = 0, cur_pos = 0; cur_pos != std::string::npos; currlength = 0 )
     {
       /* print any required padding space for vertical alignment */
       line << &( spaces[40 - opt_width + currlength] );
       newline_pos = opt_desc.find_first_of( '\n', newline_pos );
-      if( newline_pos != string::npos )
+      if( newline_pos != std::string::npos )
       {
         /* newline found, print substring (newline needn't be stripped) */
         newline_pos++;
@@ -628,14 +645,14 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
       /* find a suitable point to split text (avoid spliting in middle of word)
        */
       size_t split_pos = opt_desc.find_last_of( ' ', cur_pos + desc_width );
-      if( split_pos != string::npos )
+      if( split_pos != std::string::npos )
       {
         /* eat up multiple space characters */
         split_pos = opt_desc.find_last_not_of( ' ', split_pos ) + 1;
       }
 
       /* bad split if no suitable space to split at.  fall back to width */
-      bool bad_split = split_pos == string::npos || split_pos <= cur_pos;
+      bool bad_split = split_pos == std::string::npos || split_pos <= cur_pos;
       if( bad_split )
       {
         split_pos = cur_pos + desc_width;
@@ -653,10 +670,9 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
       {
         break;
       }
-      line << endl;
+      line << std::endl;
     }
-
-    cout << line.str() << endl;
+    std::cout << line.str() << std::endl;
   }
 }
 
@@ -666,24 +682,24 @@ bool CalypOptions::checkListingOpts()
 
   if( hasOpt( "version" ) )
   {
-    std::cout << "Calyp version " << CALYP_VERSION_STRING << "\n";
+    std::cout << "Calyp version" << CALYP_VERSION_STRING << std::endl;
     bRet |= true;
   }
   if( hasOpt( "pel_fmts" ) )
   {
-    printf( "Calyp supported pixel formats: \n" );
+    std::cout << "Calyp supported pixel formats:" << std::endl;
     for( unsigned int i = 0; i < CalypFrame::supportedPixelFormatListNames().size(); i++ )
     {
-      printf( "   %s\n", CalypFrame::supportedPixelFormatListNames()[i].c_str() );
+      std::cout << "   " << CalypFrame::supportedPixelFormatListNames()[i] << std::endl;
     }
     bRet |= true;
   }
   if( hasOpt( "quality_metrics" ) )
   {
-    printf( "Calyp supported quality metrics: \n" );
+    std::cout << "Calyp supported quality metrics:" << std::endl;
     for( unsigned int i = 0; i < CalypFrame::supportedQualityMetricsList().size(); i++ )
     {
-      printf( "   %s\n", CalypFrame::supportedQualityMetricsList()[i].c_str() );
+      std::cout << "   " << CalypFrame::supportedQualityMetricsList()[i] << std::endl;
     }
     bRet |= true;
   }
diff --git a/lib/CalypOptions.h b/lib/CalypOptions.h
index 93574df..c56fca4 100644
--- a/lib/CalypOptions.h
+++ b/lib/CalypOptions.h
@@ -112,6 +112,7 @@ public:
    *   with desc as an optional help description
    */
   CalypOptions& operator()( const std::string& name, const std::string& desc );
+  CalypOptions& addOption( const std::string& name, const std::string& desc );
 
   /**
    * Add option described by name to the parent Options list,
@@ -121,14 +122,18 @@ public:
    */
   template <typename T>
   CalypOptions& operator()( const std::string& name, T& storage, const std::string& desc );
+  template <typename T>
+  CalypOptions& addOption( const std::string& name, T& storage, const std::string& desc );
 
   template <typename T>
   CalypOptions& operator()( const std::string& name, T& storage, const std::string& desc, const std::string& defaults );
+  template <typename T>
+  CalypOptions& addOption( const std::string& name, T& storage, const std::string& desc, const std::string& defaults );
 
   bool checkListingOpts();
 
 private:
-  void addOption( std::unique_ptr<OptionBase> opt );
+  void addOptionInternal( std::unique_ptr<OptionBase> opt );
 
 private:
   std::map<std::string, std::list<Option*>> opt_long_map;
@@ -143,7 +148,7 @@ private:
   bool storePair( bool allow_long, bool allow_short, const std::string& name, const std::string& value );
   bool storePair( const std::string& name, const std::string& value );
   unsigned int parseLONG( unsigned int argc, char* argv[] );  // NOLINT
-  unsigned int parseLONG( std::string arg );
+  unsigned int parseLONG( const std::string& arg );
   unsigned int parseSHORT( unsigned int argc, char* argv[] );          // NOLINT
   std::list<const char*> scanArgv( unsigned int argc, char* argv[] );  // NOLINT
 };
diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index 9fe2bf1..00f01f6 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -13,7 +13,9 @@ SET(Calyp_Mod_SRCS CalypModulesFactory.cpp)
 #
 # Modules List
 #
-# SET( MODULE_LOCATION  "")
+IF(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  ADD_MODULE_USE_OPENCV(DummyOpencvModule "DummyOpencvModule" VERSION 3.1.0 MODULES core)
+ENDIF()
 
 ADD_MODULE(FilterComponentLuma "FilterComponent")
 ADD_MODULE(FilterComponentChromaU "FilterComponent")
@@ -34,6 +36,8 @@ ADD_MODULE(WeightedPSNR "WeightedPSNR")
 ADD_MODULE(HEVCIntraPrediction "HEVCIntraPrediction")
 ADD_MODULE(OptimiseDisplay "OptimiseDisplay")
 
+ADD_MODULE_USE_OPENCV(ShapeDetection "ShapeDetection" VERSION 3.1.0 MODULES core)
+
 ADD_MODULE_USE_OPENCV(
   MeasureOpticalFlowDualTVL1
   "MeasureOpticalFlowDualTVL1"
@@ -85,15 +89,7 @@ ADD_MODULE_USE_OPENCV(
   imgproc
   photo
 )
-# ADD_MODULE_USE_OPENCV(
-#   ThreeSixtyDynamicDownsampling
-#   "ThreeSixtyDynamicDownsampling"
-#   VERSION
-#   3.1.0
-#   MODULES
-#   core
-#   imgproc
-# )
+# ADD_MODULE_USE_OPENCV( ThreeSixtyDynamicDownsampling "ThreeSixtyDynamicDownsampling" VERSION 3.1.0 MODULES core imgproc )
 ADD_MODULE_USE_OPENCV(
   ThreeSixtyNxN
   "ThreeSixtyNxN"
diff --git a/modules/DummyOpencvModule.cpp b/modules/DummyOpencvModule.cpp
new file mode 100644
index 0000000..46504a7
--- /dev/null
+++ b/modules/DummyOpencvModule.cpp
@@ -0,0 +1,60 @@
+/*    This file is a part of Calyp project
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
+ *                                Luis Lucas      (luisfrlucas@gmail.com)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this program; if not, write to the Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * \file     DummyOpencvModule.cpp
+ */
+
+#include "DummyOpencvModule.h"
+
+#include <cstdlib>
+
+//#include <opencv2/video/video.hpp>
+
+using cv::Mat;
+using cv::Ptr;
+using namespace cv::saliency;
+
+DummyOpencvModule::DummyOpencvModule()
+{
+  /* Module Definition */
+  m_iModuleAPI = CLP_MODULE_API_2;
+  m_iModuleType = ClpModuleType::FrameProcessing;
+  m_pchModuleCategory = "Dummy";
+  m_pchModuleName = "DummyOpencvModule";
+  m_pchModuleLongName = "Shape detection";
+  m_pchModuleTooltip = "Detect shapes in images";
+  m_uiNumberOfFrames = 1;
+  m_uiModuleRequirements = ClpModuleFeature::NewWindow | ClpModuleFeature::Options;
+  m_bConvertToGray = false;
+
+  m_cModuleOptions.addOptions()( "Convert to Gray", m_bConvertToGray, "Measure a binary saliency map [false]" );
+}
+
+cv::Mat* DummyOpencvModule::create_using_opencv( const std::vector<Mat>& apcMatList )
+{
+  m_resultImage = std::make_unique<Mat>( apcMatList[0].rows, apcMatList[0].cols, CV_8UC1 );
+  return m_resultImage.get();
+}
+
+Mat* DummyOpencvModule::process_using_opencv( const std::vector<Mat>& apcMatList )
+{
+  apcMatList[0].copyTo( *m_resultImage );
+  return m_resultImage.get();
+}
diff --git a/modules/DummyOpencvModule.h b/modules/DummyOpencvModule.h
new file mode 100644
index 0000000..44d3f7a
--- /dev/null
+++ b/modules/DummyOpencvModule.h
@@ -0,0 +1,50 @@
+/*    This file is a part of Calyp project
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
+ *                                Luis Lucas      (luisfrlucas@gmail.com)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this program; if not, write to the Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * \file     DummyOpencvModule.h
+ * \brief    Modules to detect curves shape
+ */
+
+#ifndef __DUMMYOPENCVMODULE_H__
+#define __DUMMYOPENCVMODULE_H__
+
+// CalypLib
+#include "lib/CalypModuleIf.h"
+
+// OpenCV
+#include <opencv2/core/core.hpp>
+#include <opencv2/saliency.hpp>
+
+class DummyOpencvModule : public CalypOpenCVModuleIf,
+                          public CalypModuleInstace<DummyOpencvModule>
+{
+  using Mat = cv::Mat;
+
+private:
+  std::unique_ptr<Mat> m_resultImage;
+
+public:
+  DummyOpencvModule();
+  virtual ~DummyOpencvModule() = default;
+  Mat* create_using_opencv( const std::vector<Mat>& apcMatList ) override;
+  Mat* process_using_opencv( const std::vector<Mat>& apcMatList ) override;
+};
+
+#endif  // __DUMMYOPENCVMODULE_H__
diff --git a/modules/ShapeDetection.cpp b/modules/ShapeDetection.cpp
new file mode 100644
index 0000000..d03e5ec
--- /dev/null
+++ b/modules/ShapeDetection.cpp
@@ -0,0 +1,78 @@
+/*    This file is a part of Calyp project
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
+ *                                Luis Lucas      (luisfrlucas@gmail.com)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this program; if not, write to the Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * \file     ShapeDetection.cpp
+ */
+
+#include "ShapeDetection.h"
+
+#include <cstdlib>
+
+//#include <opencv2/video/video.hpp>
+
+using cv::Mat;
+using cv::Ptr;
+using namespace cv::saliency;
+
+ShapeDetection::ShapeDetection()
+    : m_rng( 12345 )
+{
+  /* Module Definition */
+  m_iModuleAPI = CLP_MODULE_API_2;
+  m_iModuleType = ClpModuleType::FrameProcessing;
+  m_pchModuleCategory = "Utilities";
+  m_uiNumberOfFrames = 1;
+  m_uiModuleRequirements = ClpModuleFeature::NewWindow;
+  m_bConvertToGray = false;
+
+  /* Module Definition */
+  m_pchModuleName = "ShapeDetection";
+  m_pchModuleLongName = "Shape detection";
+  m_pchModuleTooltip = "Detect shapes in images";
+}
+
+cv::Mat* ShapeDetection::create_using_opencv( const std::vector<Mat>& apcMatList )
+{
+  m_resultImage = std::make_unique<Mat>( apcMatList[0].rows, apcMatList[0].cols, CV_8UC1 );
+  return m_resultImage.get();
+}
+
+Mat* ShapeDetection::process_using_opencv( const std::vector<Mat>& apcMatList )
+{
+  Mat canny_output;
+  cv::Canny( apcMatList[0], canny_output, 30, 100 );
+
+  std::vector<std::vector<cv::Point> > contours;
+  findContours( canny_output, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE );
+
+  std::vector<std::vector<cv::Point> > hull( contours.size() );
+  for( size_t i = 0; i < contours.size(); i++ )
+  {
+    cv::convexHull( contours[i], hull[i] );
+  }
+  for( size_t i = 0; i < contours.size(); i++ )
+  {
+    cv::Scalar color = cv::Scalar( m_rng.uniform( 0, 256 ), m_rng.uniform( 0, 256 ), m_rng.uniform( 0, 256 ) );
+    cv::drawContours( *m_resultImage, contours, (int)i, color );
+    cv::drawContours( *m_resultImage, hull, (int)i, color );
+  }
+
+  return m_resultImage.get();
+}
diff --git a/modules/ShapeDetection.h b/modules/ShapeDetection.h
new file mode 100644
index 0000000..cdbd375
--- /dev/null
+++ b/modules/ShapeDetection.h
@@ -0,0 +1,52 @@
+/*    This file is a part of Calyp project
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
+ *                                Luis Lucas      (luisfrlucas@gmail.com)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this program; if not, write to the Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * \file     ShapeDetection.h
+ * \brief    Modules to detect curves shape
+ */
+
+#ifndef __SHAPEDETECTION_H__
+#define __SHAPEDETECTION_H__
+
+// CalypLib
+#include "lib/CalypModuleIf.h"
+
+// OpenCV
+#include <opencv2/core/core.hpp>
+#include <opencv2/saliency.hpp>
+
+class ShapeDetection : public CalypOpenCVModuleIf,
+                       public CalypModuleInstace<ShapeDetection>
+{
+  using Mat = cv::Mat;
+
+private:
+  bool m_bBinaryMap;
+  std::unique_ptr<Mat> m_resultImage;
+  cv::RNG m_rng;
+
+public:
+  ShapeDetection();
+  virtual ~ShapeDetection() = default;
+  Mat* create_using_opencv( const std::vector<Mat>& apcMatList ) override;
+  Mat* process_using_opencv( const std::vector<Mat>& apcMatList ) override;
+};
+
+#endif  // __SHAPEDETECTION_H__
diff --git a/tools/main.cpp b/tools/main.cpp
index 4ac72b5..dfe8e3a 100644
--- a/tools/main.cpp
+++ b/tools/main.cpp
@@ -23,6 +23,8 @@
  * \brief    main file
  */
 
+#include <iostream>
+
 #include "CalypTools.h"
 
 int main( int argc, char* argv[] )
@@ -37,19 +39,20 @@ int main( int argc, char* argv[] )
   }
   if( iRet < 0 )
   {
-    printf( "Exiting with error \n" );
+    std::cout << "Exiting with error" << std::endl;
     return 1;
   }
 
   if( CalypToolsApp.Process() < 0 )
   {
-    printf( "Exiting with error \n" );
+    std::cout << "Exiting with error" << std::endl;
     return 1;
   }
 
   if( CalypToolsApp.Close() < 0 )
   {
-    printf( "Exiting with error \n" );
+    std::cout << "Exiting with error" << std::endl;
     return 1;
   }
+  return 0;
 }