diff --git a/.gitignore b/.gitignore
index 904e1836f4a185aeefde21b9d34a89bb90fb208a..4cc0755c7177520f43fb4e488cad6d8d6dfa8ace 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,3 +28,6 @@ CMakeLists.txt.user
 *.exe
 *.out
 *.app
+
+# Build dir
+Build
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
deleted file mode 100644
index 763c12835049872d624c1326c38e447f545de30d..0000000000000000000000000000000000000000
--- a/CMakeLists.txt
+++ /dev/null
@@ -1,62 +0,0 @@
-cmake_minimum_required(VERSION 2.8.7 FATAL_ERROR)
-project(sampletracker)
-
-#------------------------------------------------------------------------------
-# Required CPM Setup - no need to modify - See: https://github.com/iauns/cpm
-#------------------------------------------------------------------------------
-
-set(CPM_DIR "${CMAKE_CURRENT_BINARY_DIR}/cpm_packages" CACHE TYPE STRING)
-find_package(Git)
-if(NOT GIT_FOUND)
-  message(FATAL_ERROR "CPM requires Git.")
-endif()
-if (NOT EXISTS ${CPM_DIR}/CPM.cmake)
-  message(STATUS "Cloning repo (https://github.com/iauns/cpm)")
-  execute_process(
-    COMMAND "${GIT_EXECUTABLE}" clone https://github.com/iauns/cpm ${CPM_DIR}
-    RESULT_VARIABLE error_code
-    OUTPUT_QUIET ERROR_QUIET)
-  if(error_code)
-    message(FATAL_ERROR "CPM failed to get the hash for HEAD")
-  endif()
-endif()
-include(${CPM_DIR}/CPM.cmake)
-
-#------------------------------------------------------------------------------
-# CPM Modules
-#------------------------------------------------------------------------------
-
-if(NOT DEFINED CMAKECONFIG_PATH)
-    CPM_AddModule("cmakeconfig"
-        GIT_REPOSITORY "https://github.com/BioroboticsLab/cmakeconfig.git"
-        GIT_TAG "master")
-else()
-    CPM_AddModule("cmakeconfig"
-        SOURCE_DIR "${CMAKECONFIG_PATH}")
-endif()
-
-include_biotracker_core("master")
-
-CPM_Finish()
-
-biorobotics_config()
-
-find_package(Qt5Widgets REQUIRED)
-find_package(Qt5OpenGL REQUIRED)
-
-include_directories(
-    ${PROJECT_SOURCE_DIR}
-    SYSTEM ${Qt5Widgets_INCLUDE_DIRS}
-    SYSTEM ${Qt5OpenGL_INCLUDE_DIRS}
-)
-
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
-set(CMAKE_AUTOMOC ON)
-
-add_definitions(${Qt5Widgets_DEFINITIONS})
-add_definitions(-DQT_NO_KEYWORDS)
-
-add_library(sampletracker.tracker SHARED
-    SampleTracker.cpp
-    SampleObject.cpp
-)
diff --git a/SampleObject.cpp b/SampleObject.cpp
deleted file mode 100644
index 621a4a52b4884c55878b4480609b08be136df5c6..0000000000000000000000000000000000000000
--- a/SampleObject.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "SampleObject.h"
-
-SampleObject::SampleObject(void)
-    : ObjectModel() {
-}
-
-
-SampleObject::~SampleObject(void) {
-}
-
-void SampleObject::setPosition(cv::Point) {}
-cv::Point SampleObject::getPosition() {
-    return _position;
-}
-
-
diff --git a/SampleObject.h b/SampleObject.h
deleted file mode 100644
index 91510f67730fe3edfab93618ebb7bc02b414191a..0000000000000000000000000000000000000000
--- a/SampleObject.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <opencv2/opencv.hpp>
-
-#include <biotracker/serialization/ObjectModel.h>
-
-class SampleObject :
-    public BioTracker::Core::ObjectModel {
-  public:
-    SampleObject(void);
-    virtual ~SampleObject(void);
-    void setPosition(cv::Point pos);
-    cv::Point getPosition();
-
-  private:
-    cv::Point _position;
-};
diff --git a/SampleTracker.cpp b/SampleTracker.cpp
deleted file mode 100644
index 9fce2b705714c7ed87d88b3ed0782100014e7e25..0000000000000000000000000000000000000000
--- a/SampleTracker.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#include "SampleTracker.h"
-
-#include <QApplication>
-#include <QIntValidator>
-#include <QPushButton>
-#include <QPainter>
-
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/highgui/highgui.hpp>
-
-#include <biotracker/settings/Settings.h>
-#include <biotracker/TrackingAlgorithm.h>
-#include <biotracker/Registry.h>
-
-extern "C" {
-    void registerTracker() {
-        bc::Registry::getInstance().registerTrackerType<SampleTracker>("SampleTracker");
-    }
-}
-
-SampleTracker::SampleTracker(bc::Settings &settings)
-    : bc::TrackingAlgorithm(settings)
-    , _showSelectorRec(false)
-    , _showOriginal(false)
-    , _lowH(0)
-    , _highH(255)
-    , _lowS(0)
-    , _highS(255)
-    , _lowV(0)
-    , _highV(255) {
-    initToolsFrame();
-    _currentView="";
-    _imageChanged=false;
-}
-
-void SampleTracker::track(size_t, const cv::Mat &imgOriginal) {
-    //dont do nothing if we ain't got an image
-    if (imgOriginal.empty()) {
-        return;
-    }
-    using namespace cv;
-
-    Mat imgHSV;
-
-    cvtColor(imgOriginal, imgHSV,
-             COLOR_BGR2HSV); //Convert the captured frame from BGR to HSV
-
-
-    inRange(imgHSV, Scalar(_lowH, _lowS, _lowV), Scalar(_highH, _highS, _highV),
-            _imgTracked); //Threshold the image
-
-    //morphological opening (remove small objects from the foreground)
-    erode(_imgTracked, _imgTracked, getStructuringElement(MORPH_ELLIPSE, Size(5,
-            5)));
-    dilate(_imgTracked, _imgTracked, getStructuringElement(MORPH_ELLIPSE, Size(5,
-            5)));
-
-    //morphological closing (fill small holes in the foreground)
-    cv::dilate(_imgTracked, _imgTracked,
-               cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5)));
-    cv::erode(_imgTracked, _imgTracked, cv::getStructuringElement(cv::MORPH_ELLIPSE,
-              cv::Size(5, 5)));
-    _imageChanged = true;
-}
-
-void SampleTracker::paint(size_t, bc::ProxyMat &image, const TrackingAlgorithm::View &view) {
- if (view.name != _currentView || _imageChanged) {
-        _currentView = view.name;
-
-        if (!_imgTracked.empty() && _currentView == "Filter") {
-            //since gui is expecting a BGR image we have to convert our grayscale image
-            cv::cvtColor(_imgTracked, image.getMat(), CV_GRAY2BGR);
-        }
-        _imageChanged=false;
-    }
-}
-
-void SampleTracker::paintOverlay(size_t, QPainter *painter, View const &) {
-    painter->drawRoundRect(QRectF(QPointF(100, 100), QPointF(1000, 1000)));
-    if (_showSelectorRec) {
-        drawRectangle(painter);
-    }
-}
-
-//this will draw a basic rectangle
-void SampleTracker::drawRectangle(QPainter *painter) {
-    QColor color(Qt::cyan);
-    color.setAlpha(150);
-    QBrush brush(color);
-    painter->fillRect(QRectF(_selectorRecStart, _selectorRecEnd),brush);
-
-}
-
-void SampleTracker::mouseMoveEvent(QMouseEvent *e) {
-    if (_showSelectorRec) {
-        _selectorRecEnd.setX(e->x());
-        _selectorRecEnd.setY(e->y());
-        //draw rectangle!
-        Q_EMIT update();
-    }
-}
-void SampleTracker::mousePressEvent(QMouseEvent *e) {
-    //check if left button is clicked
-    if (e->button() == Qt::LeftButton) {
-        int x = e->x();
-        int y = e->y();
-        std::string note = "shift + left button press on: x="
-                           + QString::number(x).toStdString() + " y=" + QString::number(y).toStdString();
-        //initialize coordinates for selection tool
-        _selectorRecStart.setX(e->x());
-        _selectorRecStart.setY(e->y());
-        _selectorRecEnd.setX(e->x());
-        _selectorRecEnd.setY(e->y());
-        _showSelectorRec = true;
-    }
-}
-void SampleTracker::mouseReleaseEvent(QMouseEvent *e) {
-    if (e->button() == Qt::LeftButton) {
-        if (_showSelectorRec) {
-            _selectorRecEnd.setX(e->x());
-            _selectorRecEnd.setY(e->y());
-            _showSelectorRec = false;
-            //next draw will delete rectangle!
-            Q_EMIT update();
-            std::string note = "selected area from " + QString::number(
-                                   _selectorRecStart.x()).toStdString() + ":"+
-                               QString::number(_selectorRecStart.y()).toStdString()
-                               + " to " +  QString::number(_selectorRecEnd.x()).toStdString() + ":"+
-                               QString::number(_selectorRecEnd.y()).toStdString();
-            Q_EMIT notifyGUI(note, bc::MessageType::NOTIFICATION);
-        }
-    }
-}
-
-void SampleTracker::mouseWheelEvent(QWheelEvent *) {}
-
-
-/*std::shared_ptr<QWidget> SampleTracker::getParamsWidget() {
-    return _toolsFrame;
-}*/
-
-void SampleTracker::initToolsFrame() {
-    _lowHEdit  = new QLineEdit(getToolsWidget());
-    _highHEdit = new QLineEdit(getToolsWidget());
-    _lowSEdit  = new QLineEdit(getToolsWidget());
-    _highSEdit = new QLineEdit(getToolsWidget());
-    _lowVEdit  = new QLineEdit(getToolsWidget());
-    _highVEdit = new QLineEdit(getToolsWidget());
-
-    _colorBut = new QPushButton("change color!", getToolsWidget());
-
-    _lowHEdit->setValidator(new QIntValidator(0, 255, getToolsWidget()));
-    _highHEdit->setValidator(new QIntValidator(0, 255, getToolsWidget()));
-    _lowSEdit->setValidator(new QIntValidator(0, 255, getToolsWidget()));
-    _highSEdit->setValidator(new QIntValidator(0, 255, getToolsWidget()));
-    _lowVEdit->setValidator(new QIntValidator(0, 255, getToolsWidget()));
-    _highVEdit->setValidator(new QIntValidator(0, 255, getToolsWidget()));
-
-    _lowHEdit->setText(QString::number(_lowH));
-    _highHEdit->setText(QString::number(_highH));
-    _lowSEdit->setText(QString::number(_lowS));
-    _highSEdit->setText(QString::number(_highS));
-    _lowVEdit->setText(QString::number(_lowV));
-    _highVEdit->setText(QString::number(_highV));
-
-    QFormLayout *layout = new QFormLayout(getToolsWidget());
-    layout->addRow(_colorBut);
-    layout->addRow("H-low",  _lowHEdit);
-    layout->addRow("H-high", _highHEdit);
-    layout->addRow("S-low",  _lowSEdit);
-    layout->addRow("S-high", _highSEdit);
-    layout->addRow("V-low",  _lowVEdit);
-    layout->addRow("V-high", _highVEdit);
-
-    getToolsWidget()->setLayout(layout);
-
-    QObject::connect(this->_colorBut, SIGNAL(clicked()), this,
-                     SLOT(changeFilterColor()));
-}
-
-void SampleTracker::changeFilterColor() {
-    _lowH  =    _lowHEdit->text().toInt();
-    _highH =    _highHEdit->text().toInt();
-    _lowS  =    _lowSEdit->text().toInt();
-    _highS =    _highSEdit->text().toInt();
-    _lowV  =    _lowVEdit->text().toInt();
-    _highV =    _highVEdit->text().toInt();
-    Q_EMIT forceTracking();
-}
-
-void SampleTracker::postConnect() {
-    Q_EMIT registerViews({ { "Filter" } });
-}
diff --git a/SampleTracker.h b/SampleTracker.h
deleted file mode 100644
index d4c5914fc996fcb83446dd284da8a4572c6a48b5..0000000000000000000000000000000000000000
--- a/SampleTracker.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef SampleTracker_H
-#define SampleTracker_H
-
-#include <QGroupBox>
-#include <QFormLayout>
-#include <QLineEdit>
-#include <QPushButton>
-
-#include <biotracker/TrackingAlgorithm.h>
-#include <biotracker/settings/Settings.h>
-
-namespace bc = BioTracker::Core;
-
-class SampleTracker : public bc::TrackingAlgorithm {
-    Q_OBJECT
-  public:
-    SampleTracker(bc::Settings &settings);
-
-    void track(size_t frameNumber, const cv::Mat &frame) override;
-    void paint(size_t frameNumber, bc::ProxyMat &m, View const &view = OriginalView) override;
-    void paintOverlay(size_t frameNumber, QPainter *, View const &) override;
-
-    void postConnect() override;
-
-  public Q_SLOTS:
-    void changeFilterColor();
-
-  private:
-    QPointF _selectorRecStart;
-    QPointF _selectorRecEnd;
-
-    bool _showSelectorRec;
-    bool _showOriginal;
-
-    // values for filtering a color (HSV format)
-    int _lowH;
-    int _highH;
-    int _lowS;
-    int _highS;
-    int _lowV;
-    int _highV;
-
-    cv::Mat _imgTracked;
-
-    // gui elements to set those values
-    QLineEdit *_lowHEdit;
-    QLineEdit *_highHEdit;
-    QLineEdit *_lowSEdit;
-    QLineEdit *_highSEdit;
-    QLineEdit *_lowVEdit;
-    QLineEdit *_highVEdit;
-
-    QPushButton *_colorBut;
-    std::string _currentView;
-    bool _imageChanged;
-
-    std::vector<bc::TrackedObject> _trackedObjects;
-
-    void drawRectangle(QPainter *painter);
-    void initToolsFrame();
-
-  private:
-    //mouse click and move events
-    void mouseMoveEvent(QMouseEvent *e) override;
-    void mousePressEvent(QMouseEvent *e) override;
-    void mouseReleaseEvent(QMouseEvent *e) override;
-    void mouseWheelEvent(QWheelEvent *e) override;
-};
-
-#endif
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..27c3edf5a02bc41fe8c6c283b0c8c894b03ac111
--- /dev/null
+++ b/Source/CMakeLists.txt
@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 2.6)
+#(Minimal benötigte CMake-Version wenn z.B. bestimmte CMake-Kommandos benutzt werden)
+
+cmake_policy (SET CMP0020 NEW)
+
+# Der Projektname
+project(Sampletracker)
+set(CMAKE_CXX_FLAGS "-std=c++11" CACHE STRING "compile flags" FORCE)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+#Building for x64
+IF(CMAKE_CL_64)
+	find_package(Qt5 REQUIRED Core Gui Xml Network Widgets OpenGL Multimedia MultimediaWidgets PATHS $ENV{QT_DIR_CMAKE64})
+	find_package(OpenCV REQUIRED PATHS $ENV{CV_DIR_CMAKE64})
+	set (QT_DIR_CMAKE $ENV{QT_DIR_CMAKE64})
+ELSE()
+#Building for x86
+	find_package(Qt5 REQUIRED Core Gui Xml Network Widgets OpenGL Multimedia MultimediaWidgets PATHS $ENV{QT_DIR_CMAKE32})
+	find_package(OpenCV REQUIRED PATHS $ENV{CV_DIR_CMAKE32})
+	set (QT_DIR_CMAKE $ENV{QT_DIR_CMAKE32})
+ENDIF()
+
+set(BTLibrary "Not Found" CACHE FILEPATH "")
+
+if(CMAKE_SYSTEM MATCHES "Windows")
+	set(Boost_USE_STATIC_LIBS   ON)
+	set(Boost_USE_MULTITHREADED ON)
+endif()
+find_package(Boost REQUIRED system filesystem chrono thread timer program_options)
+
+
+add_subdirectory(Sample)
+
+
diff --git a/Source/Sample/BioTrackerPlugin.cpp b/Source/Sample/BioTrackerPlugin.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90b69485109ff3f686740b2f99873ff457f403ca
--- /dev/null
+++ b/Source/Sample/BioTrackerPlugin.cpp
@@ -0,0 +1,134 @@
+#include "BioTrackerPlugin.h"
+#include "PluginContext.h"
+
+#include "Controller/ControllerTrackingAlgorithm.h"
+#include "Controller/ControllerTrackedComponent.h"
+
+#include "util/singleton.h"
+#include "settings/Settings.h"
+
+#include "View/TrackedElementView.h"
+#include "TrackedComponents/TrackedComponentFactory.h"
+
+BioTrackerPlugin::BioTrackerPlugin() {
+}
+
+IView* BioTrackerPlugin::getTrackerParameterWidget() {
+	return qobject_cast<ControllerTrackingAlgorithm*> (m_TrackerController)->getTrackingParameterWidget();
+}
+IView *BioTrackerPlugin::getTrackerElementsWidget()
+{
+	return qobject_cast<ControllerTrackedComponent *> (m_ComponentController)->getTrackingElementsWidget();
+}
+
+// forwards tracked component model to coreApp
+IModel* BioTrackerPlugin::getTrackerComponentModel() {
+	return qobject_cast<ControllerTrackedComponent *> (m_ComponentController)->getModel();
+}
+
+IModelTrackedComponentFactory *BioTrackerPlugin::getComponentFactory() {
+    return new TrackedComponentFactory();
+}
+
+#if QT_VERSION < 0x050000
+Q_EXPORT_PLUGIN2(BioTrackerPlugin, BioTrackerPlugin)
+#endif // QT_VERSION < 0x050000
+
+
+void BioTrackerPlugin::createPlugin() {
+	m_PluginContext = new PluginContext();
+	m_PluginContext->createApplication();
+
+	IController * ctr = m_PluginContext->requestController(ENUMS::CONTROLLERTYPE::COMPONENT);
+	m_ComponentController = qobject_cast<ControllerTrackedComponent *>(ctr);
+
+	IController * ctr2 = m_PluginContext->requestController(ENUMS::CONTROLLERTYPE::TRACKING);
+	m_TrackerController = qobject_cast<ControllerTrackingAlgorithm *>(ctr2);
+
+	connectInterfaces();
+}
+
+void BioTrackerPlugin::connectInterfaces() {
+	ControllerTrackingAlgorithm* ctrAlg = qobject_cast<ControllerTrackingAlgorithm*> (m_TrackerController);
+	ControllerTrackedComponent* ctrTrC = qobject_cast<ControllerTrackedComponent*> (m_ComponentController);
+
+	//controllertrackingalgorithm
+	QObject::connect(ctrAlg, &ControllerTrackingAlgorithm::emitCvMat, this, &BioTrackerPlugin::receiveCvMatFromController);
+	QObject::connect(ctrAlg, &ControllerTrackingAlgorithm::emitTrackingDone, this, &BioTrackerPlugin::receiveTrackingDone);
+	QObject::connect(ctrAlg, &ControllerTrackingAlgorithm::emitChangeDisplayImage, this, &BioTrackerPlugin::receiveChangeDisplayImage);
+	QObject::connect(this, &BioTrackerPlugin::emitAreaDescriptorUpdate, ctrAlg, &ControllerTrackingAlgorithm::receiveAreaDescriptorUpdate);
+	//tracking algorithm
+	QObject::connect(static_cast<BioTrackerTrackingAlgorithm*>(ctrAlg->getModel()), SIGNAL(emitDimensionUpdate(int, int)), this, SIGNAL(emitDimensionUpdate(int, int)));
+	//controllertrackedcomponents
+	QObject::connect(this, &BioTrackerPlugin::emitAddTrajectory, ctrTrC, &ControllerTrackedComponent::receiveAddTrajectory, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitRemoveTrajectory, ctrTrC, &ControllerTrackedComponent::receiveRemoveTrajectory, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitRemoveTrajectoryId, ctrTrC, &ControllerTrackedComponent::receiveRemoveTrajectoryId, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitRemoveTrackEntity, ctrTrC, &ControllerTrackedComponent::receiveRemoveTrackEntity, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitValidateTrajectory, ctrTrC, &ControllerTrackedComponent::receiveValidateTrajectory, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitValidateEntity, ctrTrC, &ControllerTrackedComponent::receiveValidateEntity, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitEntityRotation, ctrTrC, &ControllerTrackedComponent::receiveEntityRotation, Qt::DirectConnection);
+	//connect this to enable moving of elements -> we need pxtocm() to create new poses
+	QObject::connect(this, &BioTrackerPlugin::emitMoveElement, ctrTrC, &ControllerTrackedComponent::receiveMoveElement, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitSwapIds, ctrTrC, &ControllerTrackedComponent::receiveSwapIds, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitToggleFixTrack, ctrTrC, &ControllerTrackedComponent::receiveToggleFixTrack, Qt::DirectConnection);
+	QObject::connect(this, &BioTrackerPlugin::emitCurrentFrameNumber, ctrTrC, &ControllerTrackedComponent::receiveCurrentFrameNumber, Qt::DirectConnection);
+}
+
+
+void BioTrackerPlugin::receiveAreaDescriptor(IModelAreaDescriptor *areaDescr) {
+	Q_EMIT emitAreaDescriptorUpdate(areaDescr);
+}
+
+void BioTrackerPlugin::receiveCurrentFrameFromMainApp(std::shared_ptr<cv::Mat> mat, uint frameNumber) {
+	qobject_cast<ControllerTrackingAlgorithm*> (m_TrackerController)->doTracking(mat, frameNumber);
+
+	Q_EMIT emitCurrentFrameNumber(frameNumber);
+}
+
+void BioTrackerPlugin::receiveCurrentFrameNumberFromMainApp(uint frameNumber) {
+	Q_EMIT emitCurrentFrameNumber(frameNumber);
+}
+
+void BioTrackerPlugin::receiveCvMatFromController(std::shared_ptr<cv::Mat> mat, QString name) {
+	Q_EMIT emitCvMat(mat, name);
+}
+
+void BioTrackerPlugin::receiveTrackingDone(uint framenumber) {
+	Q_EMIT emitTrackingDone(framenumber);
+}
+
+void BioTrackerPlugin::receiveChangeDisplayImage(QString str) {
+	Q_EMIT emitChangeDisplayImage(str);
+}
+
+void BioTrackerPlugin::receiveRemoveTrajectory(IModelTrackedTrajectory* trajectory) {
+	Q_EMIT emitRemoveTrajectory(trajectory);
+}
+
+void BioTrackerPlugin::receiveAddTrajectory(QPoint pos) {
+	Q_EMIT emitAddTrajectory(pos);
+}
+
+void BioTrackerPlugin::receiveSwapIds(IModelTrackedTrajectory * trajectory0, IModelTrackedTrajectory * trajectory1) {
+	Q_EMIT emitSwapIds(trajectory0, trajectory1);
+}
+
+void BioTrackerPlugin::sendCorePermissions() {
+	// get plugin settings
+	BioTracker::Core::Settings *pluginSettings = BioTracker::Util::TypedSingleton<BioTracker::Core::Settings>::getInstance(LUKASKANADE::CONFIGPARAM::CONFIG_INI_FILE);
+
+	// signal permissions
+	bool enableView = pluginSettings->getValueOrDefault(LUKASKANADE::GUIPARAM::ENABLE_CORE_COMPONENT_VIEW, true);
+	Q_EMIT emitCorePermission(std::pair<ENUMS::COREPERMISSIONS, bool>(ENUMS::COREPERMISSIONS::COMPONENTVIEW, enableView));
+	bool enableMove = pluginSettings->getValueOrDefault(LUKASKANADE::GUIPARAM::ENABLE_CORE_COMPONENT_MOVE, true);
+	Q_EMIT emitCorePermission(std::pair<ENUMS::COREPERMISSIONS, bool>(ENUMS::COREPERMISSIONS::COMPONENTMOVE, enableMove));
+	bool enableRemove = pluginSettings->getValueOrDefault(LUKASKANADE::GUIPARAM::ENABLE_CORE_COMPONENT_REMOVE, true);
+	Q_EMIT emitCorePermission(std::pair<ENUMS::COREPERMISSIONS, bool>(ENUMS::COREPERMISSIONS::COMPONENTREMOVE, enableRemove));
+	bool enableSwap = pluginSettings->getValueOrDefault(LUKASKANADE::GUIPARAM::ENABLE_CORE_COMPONENT_ID_SWAP, true);
+	Q_EMIT emitCorePermission(std::pair<ENUMS::COREPERMISSIONS, bool>(ENUMS::COREPERMISSIONS::COMPONENTSWAP, enableSwap));
+	bool enableAdd = pluginSettings->getValueOrDefault(LUKASKANADE::GUIPARAM::ENABLE_CORE_COMPONENT_ADD, true);
+	Q_EMIT emitCorePermission(std::pair<ENUMS::COREPERMISSIONS, bool>(ENUMS::COREPERMISSIONS::COMPONENTADD, enableAdd));
+	//bool enableRotate = pluginSettings->getValueOrDefault(LUKASKANADE::GUIPARAM::ENABLE_CORE_COMPONENT_ROTATE, false);
+	//Q_EMIT emitCorePermission(std::pair<ENUMS::COREPERMISSIONS, bool>(ENUMS::COREPERMISSIONS::COMPONENTROTATE, enableRotate));
+}
+
diff --git a/Source/Sample/BioTrackerPlugin.h b/Source/Sample/BioTrackerPlugin.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ffb12612d5e582e1e6ce8c8aa7df660de2c27b4
--- /dev/null
+++ b/Source/Sample/BioTrackerPlugin.h
@@ -0,0 +1,81 @@
+#ifndef BIOTRACKERPLUGIN_H
+#define BIOTRACKERPLUGIN_H
+
+#include "biotrackerplugin_global.h"
+#include "opencv2/core/core.hpp"
+#include "Interfaces/IBioTrackerContext.h"
+
+#include "Interfaces/IBioTrackerPlugin.h"
+#include "TrackedComponents/TrackedComponentFactory.h"
+
+#include "QPointer"
+#include "memory"
+#include "QPoint"
+
+class BIOTRACKERPLUGINSHARED_EXPORT BioTrackerPlugin : public IBioTrackerPlugin {
+	Q_OBJECT
+	Q_PLUGIN_METADATA(IID "de.fu-berlin.mi.biorobotics.BioTrackerPlugin" FILE "BioTrackerPlugin.json")
+	Q_INTERFACES(IBioTrackerPlugin)
+
+  public:
+	BioTrackerPlugin();
+
+	// IBioTrackerPlugin interface
+	IView* getTrackerParameterWidget();
+	IView *getTrackerElementsWidget();
+	IModel* getTrackerComponentModel();
+    IModelTrackedComponentFactory *getComponentFactory();
+
+  public:
+	void createPlugin();
+	void receiveCurrentFrameFromMainApp(std::shared_ptr<cv::Mat> mat, uint frameNumber);
+	void sendCorePermissions();
+
+  private:
+	void connectInterfaces();
+signals:
+	void emitCvMat(std::shared_ptr<cv::Mat> mat, QString name);
+	void emitTrackingDone(uint framenumber);
+	void emitChangeDisplayImage(QString str);
+	void emitAreaDescriptorUpdate(IModelAreaDescriptor *areaDescr);
+	void emitCorePermission(std::pair<ENUMS::COREPERMISSIONS, bool> permission);
+	void emitRemoveTrajectory(IModelTrackedTrajectory* trajectory);
+	void emitAddTrajectory(QPoint pos);
+	void emitRemoveTrajectoryId(int id);
+	void emitValidateTrajectory(int id);
+	void emitValidateEntity(IModelTrackedTrajectory* trajectory, uint frameNumber);
+	void emitRemoveTrackEntity(IModelTrackedTrajectory* trajectory, uint frameNumber);
+	void emitMoveElement(IModelTrackedTrajectory* trajectory, uint frameNumber, QPoint pos);
+	void emitSwapIds(IModelTrackedTrajectory* trajectory0, IModelTrackedTrajectory* trajectory1);
+	void emitCurrentFrameNumber(uint frameNumber);
+	void emitToggleFixTrack(IModelTrackedTrajectory* trajectory, bool toggle);
+	void emitEntityRotation(IModelTrackedTrajectory* trajectory, double angle, uint frameNumber);
+
+	void emitDimensionUpdate(int x, int y);
+
+public slots:
+	void receiveRemoveTrajectory(IModelTrackedTrajectory* trajectory);
+	void receiveAddTrajectory(QPoint pos);
+	void receiveSwapIds(IModelTrackedTrajectory* trajectory0, IModelTrackedTrajectory* trajectory1);
+	void receiveCurrentFrameNumberFromMainApp(uint frameNumber);
+
+private slots:
+	void receiveCvMatFromController(std::shared_ptr<cv::Mat> mat, QString name);
+	void receiveTrackingDone(uint framenumber);
+	void receiveChangeDisplayImage(QString str);
+	void receiveAreaDescriptor(IModelAreaDescriptor *areaDescr);
+
+private:
+	IController *m_TrackerController;
+	IController *m_ComponentController;
+	IController *m_AreaDescrController;
+
+	IBioTrackerContext *m_PluginContext;
+
+public:
+	QList<ENUMS::COREPERMISSIONS> m_CorePermissions;
+
+
+};
+
+#endif // BIOTRACKERPLUGIN_H
diff --git a/Source/Sample/BioTrackerPlugin.json b/Source/Sample/BioTrackerPlugin.json
new file mode 100644
index 0000000000000000000000000000000000000000..9be4eb37c868a0d294950bae757825683adb23ac
--- /dev/null
+++ b/Source/Sample/BioTrackerPlugin.json
@@ -0,0 +1,6 @@
+{   "type" :            "TrackingPlugin",
+    "name" :            "Sample Tracker",
+    "longname" :        "some long name",
+    "version" :         "1.1",
+    "dependencies" :    []
+}
diff --git a/Source/Sample/CMakeLists.txt b/Source/Sample/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..af02a0599b720402e6810d15a6a3456f58328b20
--- /dev/null
+++ b/Source/Sample/CMakeLists.txt
@@ -0,0 +1,69 @@
+##############################################################
+#### Biotracker: Sampletracker
+##############################################################
+
+set(INCLUDE_DIRS
+	${INCLUDE_DIRS}
+	${BTLibrary}/include/
+	${BTLibrary}/include/Utils/
+	${CMAKE_SOURCE_DIR}/Plugin/Sample/
+	${PROJECT_BINARY_DIR}/Plugin/Sample/
+	${Boost_INCLUDE_DIRS}
+	${OpenCV_INCLUDE_DIRS} 
+	${Qt5Core_INCLUDE_DIRS}
+	${Qt5Gui_INCLUDE_DIRS}
+	${Qt5Xml_INCLUDE_DIRS}
+	${Qt5Network_INCLUDE_DIRS}
+	${Qt5Widgets_INCLUDE_DIRS}
+	${Qt5Opengl_INCLUDE_DIRS}
+	${CMAKE_CURRENT_SOURCE_DIR}
+	)
+
+set(QTLIBS 
+    Qt5::Core
+    Qt5::Gui
+    Qt5::Xml
+    Qt5::Network
+    Qt5::Widgets
+	)
+	
+message(${BTLibrary})
+set(LIBS 
+    ${BTLibrary}/bin/Biotracker_interfaces
+    ${BTLibrary}/bin/Biotracker_utility
+    ${OpenCV_LIBRARIES}
+    ${Boost_LIBRARIES}
+    ${QTLIBS} 
+	)
+	
+	
+add_definitions( -DBIOTRACKERPLUGIN_LIBRARY=1 )
+
+# Visual studio out-of-source friendly source groups
+set(_plugin_src_root_path ${CMAKE_CURRENT_SOURCE_DIR})
+file(
+    GLOB_RECURSE _plugin_source_list 
+    LIST_DIRECTORIES false
+    "${_plugin_src_root_path}/*.c*"
+    "${_plugin_src_root_path}/*.h*"
+    "${_plugin_src_root_path}/*.ui*"
+)
+foreach(_plugin_source IN ITEMS ${_plugin_source_list})
+    get_filename_component(_plugin_source_path "${_plugin_source}" PATH)
+    file(RELATIVE_PATH _plugin_source_path_rel "${_plugin_src_root_path}" "${_plugin_source_path}")
+    string(REPLACE "/" "\\" _plugin_group_path "${_plugin_source_path_rel}")
+    source_group("${_plugin_group_path}" FILES "${_plugin_source}")
+endforeach()
+
+set(CMAKE_INCLUDE_CURRENT_DIR OFF)
+
+include_directories(${INCLUDE_DIRS} ${CMAKE_CURRENT_SOURCE_DIR})
+
+message("Configuring Sample...")
+set(EXE_NAME Sample.tracker)
+add_library(${EXE_NAME} SHARED ${_plugin_source_list} )
+target_link_libraries(${EXE_NAME} ${LIBS})
+add_dependencies(${EXE_NAME} Biotracker_interfaces Biotracker_utility)
+
+
+
diff --git a/Source/Sample/Controller/ControllerTrackedComponent.cpp b/Source/Sample/Controller/ControllerTrackedComponent.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8ae2b89f0cd4a3c178c976e3b8c754bfdbdfec90
--- /dev/null
+++ b/Source/Sample/Controller/ControllerTrackedComponent.cpp
@@ -0,0 +1,164 @@
+#include "ControllerTrackedComponent.h"
+#include "TrackedComponents/TrackedElement.h"
+#include "TrackedComponents/TrackedTrajectory.h"
+#include "View/TrackedElementView.h"
+#include "qdebug.h"
+#include "qmath.h"
+
+ControllerTrackedComponent::ControllerTrackedComponent(QObject *parent, IBioTrackerContext *context, ENUMS::CONTROLLERTYPE ctr) :
+	IController(parent, context, ctr)
+{
+	m_currentFrameNumber = 0;
+}
+
+void ControllerTrackedComponent::createView()
+{
+	m_View = new TrackedElementView(0, this, m_Model);
+}
+
+void ControllerTrackedComponent::connectModelToController()
+{
+
+}
+
+void ControllerTrackedComponent::connectControllerToController()
+{
+}
+
+void createTrajectories(int count, TrackedTrajectory* all) {
+	//This should be done using a factory, right?
+	for (int i = 0; i < count; i++) {
+		TrackedTrajectory *t = new TrackedTrajectory();
+		t->setValid(true);
+		TrackedElement *e = new TrackedElement(t, "n.a.", t->getId());
+		t->add(e);
+		all->add(t, i);
+	}
+}
+
+void ControllerTrackedComponent::createModel()
+{
+	TrackedTrajectory *t = new TrackedTrajectory(this, "All");
+
+	m_Model = t;
+}
+
+
+IView *ControllerTrackedComponent::getTrackingElementsWidget()
+{
+	return m_View;
+}
+
+void ControllerTrackedComponent::receiveRemoveTrajectory(IModelTrackedTrajectory * trajectory)
+{
+	trajectory->setValid(false);
+	qDebug() << "trajectory" << trajectory->getId() << "set invalid";
+}
+
+void ControllerTrackedComponent::receiveRemoveTrajectoryId(int id)
+{
+	TrackedTrajectory* allTraj = qobject_cast<TrackedTrajectory*>(m_Model);
+	if (allTraj) {
+		IModelTrackedComponent* traj = allTraj->getChild(id - 1);
+		traj->setValid(false);
+		qDebug() << "track" << id << "set invalid";
+	}
+}
+
+void ControllerTrackedComponent::receiveValidateTrajectory(int id)
+{
+	TrackedTrajectory* allTraj = qobject_cast<TrackedTrajectory*>(m_Model);
+	if (allTraj) {
+		IModelTrackedComponent* traj = allTraj->getChild(id - 1);
+		traj->setValid(true);
+		qDebug() << "track" << id << "validated";
+	}
+}
+
+void ControllerTrackedComponent::receiveValidateEntity(IModelTrackedTrajectory * trajectory, uint frameNumber)
+{
+	trajectory->getChild(frameNumber)->setValid(true);
+	qDebug() << "track " << trajectory->getId() << " entity #" << frameNumber << "set valid";
+}
+
+void ControllerTrackedComponent::receiveRemoveTrackEntity(IModelTrackedTrajectory * trajectory, uint frameNumber)
+{
+	trajectory->getChild(frameNumber)->setValid(false);
+	qDebug() << "track " << trajectory->getId() << " entity #" << frameNumber << "set invalid";
+}
+
+void ControllerTrackedComponent::receiveAddTrajectory(QPoint position)
+{
+	std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
+
+	TrackedTrajectory* newTraj = new TrackedTrajectory();
+	TrackedElement* firstElem = new TrackedElement(newTraj, "n.a.", newTraj->getId());
+	firstElem->setX(position.x());
+	firstElem->setY(position.y());
+	firstElem->setTime(start);
+	firstElem->setValid(true);
+	newTraj->add(firstElem, m_currentFrameNumber);
+	TrackedTrajectory* allTraj = qobject_cast<TrackedTrajectory*>(m_Model);
+	if (allTraj) {
+		allTraj->add(newTraj);
+		qDebug() << "trajectory added at" << firstElem->getX() << "," << firstElem->getY();
+	}
+}
+
+void ControllerTrackedComponent::receiveMoveElement(IModelTrackedTrajectory* trajectory, uint frameNumber, QPoint position)
+{
+	TrackedTrajectory* traj = dynamic_cast<TrackedTrajectory*>(trajectory);
+	// dont't move starter dummies and main trajectory (id's: 0,1,2)!!
+    if (!(traj->getId() == 0) && frameNumber >= 0) {
+		TrackedElement* element = dynamic_cast<TrackedElement*>(traj->getChild(frameNumber));
+		//TODO setX, setY do not work correctly as pose not yet accessible
+        if (element) {
+            element->setX(position.x());
+            element->setY(position.y());
+            qDebug() << "plugin-pos:" << position;
+        }
+        else {
+            qDebug() << "Not found (moved and deleted?):" << position;
+        }
+	}
+}
+
+void ControllerTrackedComponent::receiveSwapIds(IModelTrackedTrajectory * trajectory0, IModelTrackedTrajectory * trajectory1)
+{
+	//TODO do this, not just nothing
+	TrackedTrajectory* traj0 = dynamic_cast<TrackedTrajectory*>(trajectory0);
+	TrackedTrajectory* traj1 = dynamic_cast<TrackedTrajectory*>(trajectory1);
+
+	// dont't move main trajectory (id's: 0)!!
+	if (!(traj0->getId() == 0) && !(traj1->getId() == 0)) {
+		int traj0Id = traj0->getId();
+		int traj1Id = traj1->getId();
+
+		traj0->setId(traj1Id);
+		traj1->setId(traj0Id);
+
+		qDebug() << "Swap IDs " << traj0Id << "and " << traj1Id;
+	}
+}
+
+void ControllerTrackedComponent::receiveToggleFixTrack(IModelTrackedTrajectory * trajectory, bool toggle)
+{
+	trajectory->setFixed(toggle);
+}
+
+void ControllerTrackedComponent::receiveEntityRotation(IModelTrackedTrajectory * trajectory, double angle, uint frameNumber)
+{
+	TrackedTrajectory* traj = dynamic_cast<TrackedTrajectory*>(trajectory);
+	if (traj) {
+		IModelTrackedPoint* pointLike = dynamic_cast<IModelTrackedPoint*>(traj->getChild(frameNumber));
+		if (pointLike) {
+			pointLike->setDeg(float(angle));
+			pointLike->setRad(float(qDegreesToRadians(angle)));
+		}
+	}
+}
+
+void ControllerTrackedComponent::receiveCurrentFrameNumber(uint framenumber)
+{
+	m_currentFrameNumber = (int)framenumber;
+}
diff --git a/Source/Sample/Controller/ControllerTrackedComponent.h b/Source/Sample/Controller/ControllerTrackedComponent.h
new file mode 100644
index 0000000000000000000000000000000000000000..5424e95cc1a22fcee5b332dcc95928eff51a730b
--- /dev/null
+++ b/Source/Sample/Controller/ControllerTrackedComponent.h
@@ -0,0 +1,41 @@
+#ifndef CONTROLLERTRACKEDCOMPONENT_H
+#define CONTROLLERTRACKEDCOMPONENT_H
+
+#include "Interfaces/IController/IController.h"
+#include "QPoint"
+#include "Interfaces/IModel/IModelTrackedTrajectory.h"
+
+class ControllerTrackedComponent : public IController
+{
+	Q_OBJECT
+public:
+	ControllerTrackedComponent(QObject *parent = 0, IBioTrackerContext *context = 0, ENUMS::CONTROLLERTYPE ctr = ENUMS::CONTROLLERTYPE::COMPONENT);
+
+	IView *getTrackingElementsWidget();
+public Q_SLOTS:
+		void receiveAddTrajectory(QPoint position);
+		void receiveRemoveTrajectory(IModelTrackedTrajectory* trajectory);
+		void receiveRemoveTrajectoryId(int id);
+		void receiveRemoveTrackEntity(IModelTrackedTrajectory* trajectory, uint frameNumber);
+		void receiveValidateTrajectory(int id);
+		void receiveValidateEntity(IModelTrackedTrajectory* trajectory, uint frameNumber);
+		void receiveMoveElement(IModelTrackedTrajectory* trajectory, uint frameNumber, QPoint position);
+		/* TODO Swaps ID's of last elements (-> swap elements) or swap ID's of trajectories and all of its elements?
+		*/
+		void receiveSwapIds(IModelTrackedTrajectory* trajectory0, IModelTrackedTrajectory* trajectory1);
+		void receiveToggleFixTrack(IModelTrackedTrajectory* trajectory, bool toggle);
+		void receiveEntityRotation(IModelTrackedTrajectory* trajectory, double angle, uint frameNumber);
+		void receiveCurrentFrameNumber(uint framenumber);
+
+	// IController interface
+protected:
+	void createModel() override;
+	void createView() override;
+	void connectModelToController() override;
+	void connectControllerToController() override;
+
+	//members
+	int m_currentFrameNumber;
+};
+
+#endif // CONTROLLERTRACKEDCOMPONENT_H
diff --git a/Source/Sample/Controller/ControllerTrackingAlgorithm.cpp b/Source/Sample/Controller/ControllerTrackingAlgorithm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..81cd59c80f56451727d051262c21e7075756425b
--- /dev/null
+++ b/Source/Sample/Controller/ControllerTrackingAlgorithm.cpp
@@ -0,0 +1,80 @@
+#include "ControllerTrackingAlgorithm.h"
+#include "ControllerTrackedComponent.h"
+
+#include "Model/TrackerParameter.h"
+#include "View/TrackerParameterView.h"
+#include "View/TrackedElementView.h"
+
+ControllerTrackingAlgorithm::ControllerTrackingAlgorithm(QObject *parent, IBioTrackerContext *context, ENUMS::CONTROLLERTYPE ctr) :
+    IController(parent, context, ctr)
+{
+	m_BioTrackerContext = context;
+}
+
+void ControllerTrackingAlgorithm::connectControllerToController()
+{
+	IController * ctr = m_BioTrackerContext->requestController(ENUMS::CONTROLLERTYPE::COMPONENT);
+	QPointer< ControllerTrackedComponent > ctrComponent = qobject_cast<ControllerTrackedComponent *>(ctr);
+
+	m_TrackedTrajectoryMajor = ctrComponent->getModel();
+}
+
+void ControllerTrackingAlgorithm::doTracking(std::shared_ptr<cv::Mat> mat, uint number)
+{
+    qobject_cast<BioTrackerTrackingAlgorithm *>(m_Model)->doTracking(mat, number);
+}
+
+IView *ControllerTrackingAlgorithm::getTrackingParameterWidget()
+{
+    return m_View;
+}
+
+void ControllerTrackingAlgorithm::createModel()
+{
+	connectControllerToController();
+
+	m_TrackingParameter = new TrackerParameter(this);
+
+	m_Model = new BioTrackerTrackingAlgorithm(m_TrackingParameter, m_TrackedTrajectoryMajor);
+}
+
+void ControllerTrackingAlgorithm::createView()
+{
+    m_View = new TrackerParameterView(0, this, m_TrackingParameter);
+}
+
+void ControllerTrackingAlgorithm::connectModelToController()
+{
+    BioTrackerTrackingAlgorithm *trackingAlg = qobject_cast<BioTrackerTrackingAlgorithm *>(m_Model);
+    QObject::connect(trackingAlg, &BioTrackerTrackingAlgorithm::emitCvMatA, this, &ControllerTrackingAlgorithm::receiveCvMatFromTrackingAlgorithm);
+    QObject::connect(trackingAlg, &BioTrackerTrackingAlgorithm::emitTrackingDone, this, &ControllerTrackingAlgorithm::receiveTrackingDone);
+	QObject::connect(trackingAlg, &BioTrackerTrackingAlgorithm::emitChangeDisplayImage, this, &ControllerTrackingAlgorithm::receiveChangeDisplayImage);
+	QObject::connect(this, &ControllerTrackingAlgorithm::emitAreaDescriptorUpdate, trackingAlg, &BioTrackerTrackingAlgorithm::receiveAreaDescriptorUpdate);
+
+    //QObject::connect(static_cast<TrackerParameterView*>(m_View), &TrackerParameterView::parametersChanged, 
+     //   trackingAlg, &BioTrackerTrackingAlgorithm::receiveParametersChanged);
+
+	//enable the tracker to send video dimension updates to the view via signal
+	IController* ctr = m_BioTrackerContext->requestController(ENUMS::CONTROLLERTYPE::COMPONENT);
+	IView *v = qobject_cast<ControllerTrackedComponent*>(ctr)->getView();
+	TrackedElementView *v2 = dynamic_cast<TrackedElementView *>(v);
+	QObject::connect(trackingAlg, SIGNAL(emitDimensionUpdate(int, int)), v2, SLOT(rcvDimensionUpdate(int, int)));
+}
+
+void ControllerTrackingAlgorithm::receiveCvMatFromTrackingAlgorithm(std::shared_ptr<cv::Mat> mat, QString name)
+{
+    Q_EMIT emitCvMat(mat, name);
+}
+
+void ControllerTrackingAlgorithm::receiveTrackingDone(uint framenumber)
+{
+    Q_EMIT emitTrackingDone(framenumber);
+}
+
+void ControllerTrackingAlgorithm::receiveChangeDisplayImage(QString str) {
+	Q_EMIT emitChangeDisplayImage(str);
+}
+
+void ControllerTrackingAlgorithm::receiveAreaDescriptorUpdate(IModelAreaDescriptor *areaDescr) {
+	Q_EMIT emitAreaDescriptorUpdate(areaDescr);
+}
diff --git a/Source/Sample/Controller/ControllerTrackingAlgorithm.h b/Source/Sample/Controller/ControllerTrackingAlgorithm.h
new file mode 100644
index 0000000000000000000000000000000000000000..75e565a4be22fc4c82beeefb0d02d2e918410cd3
--- /dev/null
+++ b/Source/Sample/Controller/ControllerTrackingAlgorithm.h
@@ -0,0 +1,48 @@
+#ifndef CONTROLLERTRACKINGALGORITHM_H
+#define CONTROLLERTRACKINGALGORITHM_H
+
+#include "Interfaces/IController/IController.h"
+#include "Model/BioTrackerTrackingAlgorithm.h"
+#include "Interfaces/IBioTrackerContext.h"
+#include "Interfaces/IModel/IModelDataExporter.h"
+
+
+class ControllerTrackingAlgorithm : public IController
+{
+    Q_OBJECT
+public:
+    ControllerTrackingAlgorithm(QObject *parent = 0, IBioTrackerContext *context = 0, ENUMS::CONTROLLERTYPE ctr = ENUMS::CONTROLLERTYPE::NO_CTR);
+
+    // IController interface
+public:
+    void connectControllerToController() override;
+
+    void doTracking(std::shared_ptr<cv::Mat> mat, uint number);
+
+    IView *getTrackingParameterWidget();
+
+public Q_SLOTS:
+	void receiveAreaDescriptorUpdate(IModelAreaDescriptor *areaDescr);
+
+protected:
+    void createModel() override;
+    void createView() override;
+    void connectModelToController() override;
+
+Q_SIGNALS:
+    void emitCvMat(std::shared_ptr<cv::Mat> mat, QString name);
+    void emitTrackingDone(uint framenumber);
+	void emitChangeDisplayImage(QString str);
+	void emitAreaDescriptorUpdate(IModelAreaDescriptor *areaDescr);
+
+private Q_SLOTS:
+    void receiveCvMatFromTrackingAlgorithm(std::shared_ptr<cv::Mat> mat, QString name);
+    void receiveTrackingDone(uint framenumber);
+	void receiveChangeDisplayImage(QString str);
+
+private:
+    IModel* m_TrackingParameter;
+	IModel *m_TrackedTrajectoryMajor;
+};
+
+#endif // CONTROLLERTRACKINGALGORITHM_H
diff --git a/Source/Sample/Controller/null_Controller.cpp b/Source/Sample/Controller/null_Controller.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..612c02f3a220bdb5dac5ee38c26e2a7f9d7e4d61
--- /dev/null
+++ b/Source/Sample/Controller/null_Controller.cpp
@@ -0,0 +1,26 @@
+#include "null_Controller.h"
+
+null_Controller::null_Controller()
+{
+
+}
+
+void null_Controller::createModel()
+{
+
+}
+
+void null_Controller::createView()
+{
+
+}
+
+void null_Controller::connectModelToController()
+{
+
+}
+
+void null_Controller::connectControllerToController()
+{
+
+}
diff --git a/Source/Sample/Controller/null_Controller.h b/Source/Sample/Controller/null_Controller.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0fcc211f6da112ab9ff01c8c535c9c29ebf1762
--- /dev/null
+++ b/Source/Sample/Controller/null_Controller.h
@@ -0,0 +1,18 @@
+#ifndef NULL_CONTROLLER_H
+#define NULL_CONTROLLER_H
+
+#include "Interfaces/IController/IController.h"
+class null_Controller : public IController
+{
+public:
+    null_Controller();
+
+    // IController interface
+protected:
+    void createModel() override;
+    void createView() override;
+    void connectModelToController() override;
+    void connectControllerToController() override;
+};
+
+#endif // NULL_CONTROLLER_H
diff --git a/Source/Sample/Model/BioTrackerTrackingAlgorithm.cpp b/Source/Sample/Model/BioTrackerTrackingAlgorithm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa5170716655d06376bc0b2ba6470ba0b7337d33
--- /dev/null
+++ b/Source/Sample/Model/BioTrackerTrackingAlgorithm.cpp
@@ -0,0 +1,60 @@
+#include "BioTrackerTrackingAlgorithm.h"
+#include <future>
+#include "TrackedComponents/TrackedComponentFactory.h"
+#include <chrono>
+
+#include "settings/Settings.h"
+BioTrackerTrackingAlgorithm::BioTrackerTrackingAlgorithm(IModel *parameter, IModel *trajectory)
+{
+    _TrackingParameter = (TrackerParameter*)parameter;
+    _TrackedTrajectoryMajor = (TrackedTrajectory*)trajectory;
+    _imageX = 100;
+    _imageY = 100;
+}
+
+void BioTrackerTrackingAlgorithm::doTracking(std::shared_ptr<cv::Mat> p_image, uint framenumber)
+{
+    auto start = std::chrono::high_resolution_clock::now();
+
+    //dont do nothing if we ain't got an image
+    if (p_image->empty()) {
+        return;
+    }
+
+    if (_imageX != p_image->size().width || _imageY != p_image->size().height) {
+        _imageX = p_image->size().width;
+        _imageY = p_image->size().height;
+        Q_EMIT emitDimensionUpdate(_imageX, _imageY);
+    }
+
+    using namespace cv;
+
+    cv::Mat imgHSV;
+    std::shared_ptr<cv::Mat> _imgTracked = std::make_shared<cv::Mat>();
+
+    cvtColor(*p_image, imgHSV,
+        COLOR_BGR2HSV); //Convert the captured frame from BGR to HSV
+
+
+    inRange(imgHSV, Scalar(_TrackingParameter->_lowH, _TrackingParameter->_lowS, _TrackingParameter->_lowV),
+        Scalar(_TrackingParameter->_highH, _TrackingParameter->_highS, _TrackingParameter->_highV),
+        *_imgTracked); //Threshold the image
+
+    //morphological opening (remove small objects from the foreground)
+    erode(*_imgTracked, *_imgTracked, getStructuringElement(MORPH_ELLIPSE, Size(5,
+        5)));
+    dilate(*_imgTracked, *_imgTracked, getStructuringElement(MORPH_ELLIPSE, Size(5,
+        5)));
+
+    //morphological closing (fill small holes in the foreground)
+    cv::dilate(*_imgTracked, *_imgTracked,
+        cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5)));
+    cv::erode(*_imgTracked, *_imgTracked, cv::getStructuringElement(cv::MORPH_ELLIPSE,
+        cv::Size(5, 5)));
+
+    Q_EMIT emitCvMatA(_imgTracked, QString("Tracked"));
+    Q_EMIT emitChangeDisplayImage("Tracked");
+
+
+    Q_EMIT emitTrackingDone(framenumber);
+}
diff --git a/Source/Sample/Model/BioTrackerTrackingAlgorithm.h b/Source/Sample/Model/BioTrackerTrackingAlgorithm.h
new file mode 100644
index 0000000000000000000000000000000000000000..360f6d4dc96eb8bbe88b9c1cd18bdd87fc9d47fb
--- /dev/null
+++ b/Source/Sample/Model/BioTrackerTrackingAlgorithm.h
@@ -0,0 +1,45 @@
+#ifndef BIOTRACKERTRACKINGALGORITHM_H
+#define BIOTRACKERTRACKINGALGORITHM_H
+
+
+#include "Interfaces/IModel/IModel.h"
+
+#include "TrackerParameter.h"
+
+#include <opencv2/opencv.hpp>
+#include "Interfaces/IModel/IModelTrackingAlgorithm.h"
+#include "Interfaces/IModel/IModelDataExporter.h"
+#include "TrackedComponents/TrackedElement.h"
+#include "TrackedComponents/TrackedTrajectory.h"
+#include "Interfaces/IModel/IModelAreaDescriptor.h"
+#include <iostream>
+
+class BioTrackerTrackingAlgorithm : public IModelTrackingAlgorithm
+{
+    Q_OBJECT
+public:
+    BioTrackerTrackingAlgorithm(IModel* parameter, IModel* trajectory);
+
+    int _imageX;
+    int _imageY;
+
+Q_SIGNALS:
+    void emitCvMatA(std::shared_ptr<cv::Mat> image, QString name);
+    void emitDimensionUpdate(int x, int y);
+    void emitTrackingDone(uint framenumber);
+
+    // ITrackingAlgorithm interface
+    public Q_SLOTS:
+    void doTracking(std::shared_ptr<cv::Mat> image, uint framenumber) override;
+    void receiveAreaDescriptorUpdate(IModelAreaDescriptor *areaDescr) {};
+    void receiveParametersChanged() {};
+
+private:
+
+    TrackedTrajectory* _TrackedTrajectoryMajor;
+
+    TrackerParameter* _TrackingParameter;
+
+};
+
+#endif // BIOTRACKERTRACKINGALGORITHM_H
diff --git a/Source/Sample/Model/ParamNames.h b/Source/Sample/Model/ParamNames.h
new file mode 100644
index 0000000000000000000000000000000000000000..102b4752b7a883dacac521321925508b1cfd7904
--- /dev/null
+++ b/Source/Sample/Model/ParamNames.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <iostream>
+#include <vector>
+
+namespace LUKASKANADE {
+
+    namespace CONFIGPARAM
+    {
+        // System config
+        const std::string CONFIG_INI_FILE = "./LKTrackerConfig.ini";
+    }
+
+    namespace APPLICATIONPARAM
+    {
+        // System config
+        const std::string APP_VERSION = "APPLICATIONPARAM/APP_VERSION";
+    }
+
+    namespace TRACKERPARAM
+    {
+        const std::string WNDSIZE = "TRACKERPARAM/WNDSIZE";
+
+    }
+
+    namespace GUIPARAM
+    {
+        // FPS label
+        const std::string ENABLE_LABEL_FPS = "GUIPARAM/ENABLE_LABEL_FPS";
+        // Fish id label
+        const std::string ENABLE_LABEL_FISH_ID = "GUIPARAM/ENABLE_LABEL_FISH_ID";
+        // Replica marker
+        const std::string ENABLE_LABEL_REPLICA = "GUIPARAM/ENABLE_LABEL_REPLICA";
+        // Fish position
+        const std::string ENABLE_LABEL_FISH_POS = "GUIPARAM/ENABLE_LABEL_FISH_POS";
+        // Fish orientation
+        const std::string ENABLE_LABEL_FISH_ORI = "GUIPARAM/ENABLE_LABEL_FISH_ORI";
+        // Fish history
+        const std::string ENABLE_LABEL_FISH_HISTORY = "GUIPARAM/ENABLE_LABEL_FISH_HISTORY";
+        // Blobs
+        const std::string ENABLE_SHOW_BLOBS = "GUIPARAM/ENABLE_SHOW_BLOBS";
+        // Swap fish id
+        const std::string ENABLE_SWAP_FISH_ID = "GUIPARAM/ENABLE_SWAP_FISH_ID";
+
+        // Core view of tracked components
+        const std::string ENABLE_CORE_COMPONENT_VIEW = "GUIPARAM/ENABLE_CORE_COMPONENT_VIEW";
+        // Move components in core view
+        const std::string ENABLE_CORE_COMPONENT_MOVE = "GUIPARAM/ENABLE_CORE_COMPONENT_MOVE";
+        // Remove components in core view
+        const std::string ENABLE_CORE_COMPONENT_REMOVE = "GUIPARAM/ENABLE_CORE_COMPONENT_REMOVE";
+        // Swap component id in core view
+        const std::string ENABLE_CORE_COMPONENT_ID_SWAP = "GUIPARAM/ENABLE_CORE_COMPONENT_ID_SWAP";
+        // Add component in core view
+        const std::string ENABLE_CORE_COMPONENT_ADD = "GUIPARAM/ENABLE_CORE_COMPONENT_ADD";
+		// Rotate component in core view
+		const std::string ENABLE_CORE_COMPONENT_ROTATE = "GUIPARAM/ENABLE_CORE_COMPONENT_ROTATE";
+    }
+
+}
+
diff --git a/Source/Sample/Model/TrackerParameter.cpp b/Source/Sample/Model/TrackerParameter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36aed7c4cea7080fe1590a558034788f5ce2229c
--- /dev/null
+++ b/Source/Sample/Model/TrackerParameter.cpp
@@ -0,0 +1,30 @@
+#include "TrackerParameter.h"
+#include "util/singleton.h"
+#include "Model/ParamNames.h"
+
+
+TrackerParameter::TrackerParameter(QObject *parent) :
+    IModel(parent)
+{
+    m_Threshold = 12345;
+
+    _lowH = 0;
+    _highH = 125;
+    _lowS = 0;
+    _highS = 125;
+    _lowV = 0;
+    _highV = 125;
+    Q_EMIT notifyView();
+}
+
+void TrackerParameter::setThreshold(int x)
+{
+    m_Threshold = x;
+
+    Q_EMIT notifyView();
+}
+
+int TrackerParameter::getThreshold()
+{
+    return m_Threshold;
+}
diff --git a/Source/Sample/Model/TrackerParameter.h b/Source/Sample/Model/TrackerParameter.h
new file mode 100644
index 0000000000000000000000000000000000000000..2042ba8823d3c058e30ac50f96a32ebc38f5ba71
--- /dev/null
+++ b/Source/Sample/Model/TrackerParameter.h
@@ -0,0 +1,47 @@
+#ifndef TRACKERPARAMETER_H
+#define TRACKERPARAMETER_H
+
+
+#include "Interfaces/IModel/IModel.h"
+#include "settings/Settings.h"
+#include "Model/ParamNames.h"
+
+class TrackerParameter : public IModel
+{
+    Q_OBJECT
+public:
+    TrackerParameter(QObject *parent = 0);
+
+    void setThreshold(int x);
+
+    int getThreshold();
+
+    void setAll(int a, int b, int c, int d, int e, int f)
+    {
+        _lowH = a;
+        _highH = b;
+        _lowS = c;
+        _highS = d;
+        _lowV = e;
+        _highV = f;
+
+        Q_EMIT notifyView();
+    }
+
+
+    // values for filtering a color (HSV format)
+    int _lowH;
+    int _highH;
+    int _lowS;
+    int _highS;
+    int _lowV;
+    int _highV;
+
+private:
+    BioTracker::Core::Settings *_settings;
+
+    int m_Threshold;
+
+};
+
+#endif // TRACKERPARAMETER_H
diff --git a/Source/Sample/Model/null_Model.cpp b/Source/Sample/Model/null_Model.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db2793d0195a5d1ce8905db2a5496bf564288d16
--- /dev/null
+++ b/Source/Sample/Model/null_Model.cpp
@@ -0,0 +1,6 @@
+#include "null_Model.h"
+
+null_Model::null_Model()
+{
+
+}
diff --git a/Source/Sample/Model/null_Model.h b/Source/Sample/Model/null_Model.h
new file mode 100644
index 0000000000000000000000000000000000000000..8dabf466f4c10b71b0238727e7871da44dfda0f2
--- /dev/null
+++ b/Source/Sample/Model/null_Model.h
@@ -0,0 +1,13 @@
+#ifndef NULL_MODEL_H
+#define NULL_MODEL_H
+
+#include "Interfaces/IModel/IModel.h"
+
+class null_Model : public IModel
+{
+    Q_OBJECT
+public:
+    null_Model();
+};
+
+#endif // NULL_MODEL_H
diff --git a/Source/Sample/PluginContext.cpp b/Source/Sample/PluginContext.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52fea1ffe827bc4e788568dd840aebf9b9336ba6
--- /dev/null
+++ b/Source/Sample/PluginContext.cpp
@@ -0,0 +1,34 @@
+#include "PluginContext.h"
+
+#include "Controller/ControllerTrackingAlgorithm.h"
+#include "Controller/ControllerTrackedComponent.h"
+
+PluginContext::PluginContext(QObject *parent) :
+	IBioTrackerContext(parent)
+{
+	QPointer< IController > ComponentController = new ControllerTrackedComponent(this, this, ENUMS::CONTROLLERTYPE::COMPONENT);
+	QPointer< IController > TrackingController = new ControllerTrackingAlgorithm(this, this, ENUMS::CONTROLLERTYPE::TRACKING);
+
+	m_ControllersMap.insert(ENUMS::CONTROLLERTYPE::COMPONENT, ComponentController);
+	m_ControllersMap.insert(ENUMS::CONTROLLERTYPE::TRACKING, TrackingController);
+}
+
+void PluginContext::createAppController()
+{
+	QMap<ENUMS::CONTROLLERTYPE, IController *>::iterator i;
+	for (i = m_ControllersMap.begin(); i != m_ControllersMap.end(); ++i)
+	{
+		i.value()->createComponents();
+	}
+}
+
+void PluginContext::connectController()
+{
+	QMap<ENUMS::CONTROLLERTYPE, IController *>::iterator i;
+	for (i = m_ControllersMap.begin(); i != m_ControllersMap.end(); ++i)
+	{
+		i.value()->connectComponents();
+	}
+}
+
+
diff --git a/Source/Sample/PluginContext.h b/Source/Sample/PluginContext.h
new file mode 100644
index 0000000000000000000000000000000000000000..aab040e7317fa0783600dc044ff940d003b02613
--- /dev/null
+++ b/Source/Sample/PluginContext.h
@@ -0,0 +1,17 @@
+#pragma once
+#include "Interfaces/IBioTrackerContext.h"
+#include "Interfaces/IController/IController.h"
+
+class PluginContext : public IBioTrackerContext
+{
+	Q_OBJECT
+
+public:
+	PluginContext(QObject *parent = 0);
+
+	// IBioTrackerContext interface
+protected:
+	void createAppController() override;
+	void connectController() override;
+};
+
diff --git a/Source/Sample/View/TrackedElementView.cpp b/Source/Sample/View/TrackedElementView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..486d7a13564b508ae5ea6623c70004f6aeb47af3
--- /dev/null
+++ b/Source/Sample/View/TrackedElementView.cpp
@@ -0,0 +1,133 @@
+#include "TrackedElementView.h"
+#include "QBrush"
+#include "QPainter"
+#include <QGraphicsSceneHoverEvent>
+#include <QMouseEvent>
+
+
+class QGraphicsSceneHoverEvent;
+TrackedElementView::TrackedElementView(QGraphicsItem *parent, IController *controller, IModel *model) :
+	IViewTrackedComponent(parent, controller, model)
+{
+	
+	m_boundingRect = QRectF(0, 0, 100, 100);
+
+	setAcceptHoverEvents(true);
+	setAcceptedMouseButtons(Qt::MouseButtons::enum_type::LeftButton);
+
+	_showSelectorRec = false;
+	this->installEventFilter(this);
+}
+
+
+void TrackedElementView::rcvDimensionUpdate(int x, int y) {
+	m_boundingRect = QRectF(0, 0, x, y);
+	update();
+}
+
+QRectF TrackedElementView::boundingRect() const
+{
+
+	return m_boundingRect;
+}
+
+
+void TrackedElementView::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+
+	//painter->drawRoundRect(&*ri);
+	if (_showSelectorRec) {
+		QColor color(Qt::cyan);
+		color.setAlpha(150);
+		QBrush brush(color);
+		painter->fillRect(QRectF(_selectorRecStart, _selectorRecEnd), brush);
+	}
+}
+
+void TrackedElementView::getNotified()
+{
+	update();
+}
+
+bool TrackedElementView::sceneEventFilter(QGraphicsItem *watched, QEvent *event) {
+	if (event->type() == QEvent::GraphicsSceneMousePress) {
+		QGraphicsSceneMouseEvent *e = (QGraphicsSceneMouseEvent *)event;
+		int x = e->pos().x();
+		int y = e->pos().y();
+		std::string note = "shift + left button press on: x="
+			+ QString::number(x).toStdString() + " y=" + QString::number(y).toStdString();
+		//initialize coordinates for selection tool
+		_selectorRecStart.setX(e->pos().x());
+		_selectorRecStart.setY(e->pos().y());
+		_selectorRecEnd.setX(e->pos().x());
+		_selectorRecEnd.setY(e->pos().y());
+		_showSelectorRec = true;
+		Q_EMIT update();
+	}
+	if (event->type() == QEvent::GraphicsSceneMouseMove) {
+		QGraphicsSceneMouseEvent *e;
+		if (_showSelectorRec && (e = dynamic_cast<QGraphicsSceneMouseEvent *>(event))) {
+			_selectorRecEnd.setX(e->pos().x());
+			_selectorRecEnd.setY(e->pos().y());
+			Q_EMIT update();
+		}
+	}
+	if (event->type() == QEvent::GraphicsSceneMouseRelease) {
+		if (_showSelectorRec) {
+			QGraphicsSceneMouseEvent *e = (QGraphicsSceneMouseEvent*)event;
+			_selectorRecEnd.setX(e->pos().x());
+			_selectorRecEnd.setY(e->pos().y());
+			_showSelectorRec = false;
+			//next draw will delete rectangle!
+			Q_EMIT update();
+			std::string note = "selected area from " + QString::number(
+				_selectorRecStart.x()).toStdString() + ":" +
+				QString::number(_selectorRecStart.y()).toStdString()
+				+ " to " + QString::number(_selectorRecEnd.x()).toStdString() + ":" +
+				QString::number(_selectorRecEnd.y()).toStdString();
+		}
+	}
+	return true;
+}
+
+bool TrackedElementView::eventFilter(QObject *target, QEvent *event)
+{
+	if (event->type() == QEvent::GraphicsSceneMousePress) {
+		QGraphicsSceneMouseEvent *e = (QGraphicsSceneMouseEvent *)event;
+		int x = e->pos().x();
+		int y = e->pos().y();
+		std::string note = "shift + left button press on: x="
+			+ QString::number(x).toStdString() + " y=" + QString::number(y).toStdString();
+		//initialize coordinates for selection tool
+		_selectorRecStart.setX(e->pos().x());
+		_selectorRecStart.setY(e->pos().y());
+		_selectorRecEnd.setX(e->pos().x());
+		_selectorRecEnd.setY(e->pos().y());
+		_showSelectorRec = true;
+		Q_EMIT update();
+	}
+	if (event->type() == QEvent::GraphicsSceneMouseMove) {
+		QGraphicsSceneMouseEvent *e;
+		if (_showSelectorRec && (e = dynamic_cast<QGraphicsSceneMouseEvent *>(event))) {
+			_selectorRecEnd.setX(e->pos().x());
+			_selectorRecEnd.setY(e->pos().y());
+			Q_EMIT update();
+		}
+	}
+	if (event->type() == QEvent::GraphicsSceneMouseRelease) {
+		if (_showSelectorRec) {
+			QGraphicsSceneMouseEvent *e = (QGraphicsSceneMouseEvent*)event;
+			_selectorRecEnd.setX(e->pos().x());
+			_selectorRecEnd.setY(e->pos().y());
+			_showSelectorRec = false;
+			//next draw will delete rectangle!
+			Q_EMIT update();
+			std::string note = "selected area from " + QString::number(
+				_selectorRecStart.x()).toStdString() + ":" +
+				QString::number(_selectorRecStart.y()).toStdString()
+				+ " to " + QString::number(_selectorRecEnd.x()).toStdString() + ":" +
+				QString::number(_selectorRecEnd.y()).toStdString();
+		}
+	}
+	return true;// TrackedElementView::eventFilter(target, event);
+}
diff --git a/Source/Sample/View/TrackedElementView.h b/Source/Sample/View/TrackedElementView.h
new file mode 100644
index 0000000000000000000000000000000000000000..6af03c9fb165ba1f6a253ed97d8cbc36e823839a
--- /dev/null
+++ b/Source/Sample/View/TrackedElementView.h
@@ -0,0 +1,47 @@
+#ifndef TRACKEDELEMENTVIEW_H
+#define TRACKEDELEMENTVIEW_H
+
+#include "Interfaces/IView/IViewTrackedComponent.h"
+
+/**
+	* This class is an example of how a TrackedElementView could be visualized.
+	* This class inherits from the IViewTrackedComponent class and is therefor part of the Composite Pattern.
+	*/
+class TrackedElementView : public IViewTrackedComponent
+{
+	Q_OBJECT
+public:
+	TrackedElementView(QGraphicsItem *parent = 0, IController *controller = 0, IModel *model = 0);
+
+	// QGraphicsItem interface
+public:
+	QRectF boundingRect() const override;
+	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+
+	// IViewTrackedComponent interface
+	public Q_SLOTS:
+	void getNotified() override;
+	void rcvDimensionUpdate(int x, int y);
+
+	public Q_SIGNAL:
+	void emitUpdateCornersChanged(int id, int relX, int relY);
+
+private:
+	QRectF m_boundingRect;
+	QGraphicsItem *_selectorBase;
+
+
+
+	QPointF _selectorRecStart;
+	QPointF _selectorRecEnd;
+	bool _showSelectorRec;
+	std::shared_ptr<QGraphicsRectItem> ri;
+
+	// QGraphicsItem interface
+protected:
+	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) override;
+	bool eventFilter(QObject * target, QEvent * event) override;
+
+};
+
+#endif // TRACKEDELEMENTVIEW_H
diff --git a/Source/Sample/View/TrackerParameterView.cpp b/Source/Sample/View/TrackerParameterView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fad6273163027933976c2a612a65570ab71e14c0
--- /dev/null
+++ b/Source/Sample/View/TrackerParameterView.cpp
@@ -0,0 +1,66 @@
+#include "TrackerParameterView.h"
+#include "ui_TrackerParameterView.h"
+#include "Model/TrackerParameter.h"
+
+#include <iostream>
+
+TrackerParameterView::TrackerParameterView(QWidget *parent, IController *controller, IModel *model) :
+	IViewWidget(parent, controller, model),
+	ui(new Ui::TrackerParameterView)
+{
+	ui->setupUi(this);
+		
+	ui->lineEdit_2_lowH->setValidator(new QIntValidator(this));
+	ui->lineEdit_3_highH->setValidator(new QIntValidator(this));
+	ui->lineEdit_4_lowS->setValidator(new QIntValidator(this));
+	ui->lineEdit_5_HighS->setValidator(new QIntValidator(this));
+	ui->lineEdit_6_LowV->setValidator(new QIntValidator(this));
+	ui->lineEdit_7_HighV->setValidator(new QIntValidator(this));
+
+	getNotified();
+}
+
+TrackerParameterView::~TrackerParameterView()
+{
+	delete ui;
+}
+
+
+void TrackerParameterView::on_pushButton_clicked()
+{
+	TrackerParameter *parameter = qobject_cast<TrackerParameter *>(getModel());
+		
+	int lowh = ui->lineEdit_2_lowH->text().toInt();
+	int highh = ui->lineEdit_3_highH->text().toInt();
+	int lows = ui->lineEdit_4_lowS->text().toInt();
+	int highs = ui->lineEdit_5_HighS->text().toInt();
+	int lowv = ui->lineEdit_6_LowV->text().toInt();
+	int highv = ui->lineEdit_7_HighV->text().toInt();
+
+	parameter->setAll(lowh, highh, lows, highs, lowv, highv);
+}
+
+void TrackerParameterView::getNotified()
+{
+	TrackerParameter *parameter = qobject_cast<TrackerParameter *>(getModel());
+	//int threshold = parameter->getThreshold();
+	//ui->lineEdit->setText(QString::number(threshold));
+		
+	int val = parameter->_lowH;
+	ui->lineEdit_2_lowH->setText(QString::number(val));
+
+	val = parameter->_highH;
+	ui->lineEdit_3_highH->setText(QString::number(val));
+
+	val = parameter->_lowS;
+	ui->lineEdit_4_lowS->setText(QString::number(val));
+
+	val = parameter->_highS;
+	ui->lineEdit_5_HighS->setText(QString::number(val));
+
+	val = parameter->_lowV;
+	ui->lineEdit_6_LowV->setText(QString::number(val));
+
+	val = parameter->_highV;
+	ui->lineEdit_7_HighV->setText(QString::number(val));
+}
diff --git a/Source/Sample/View/TrackerParameterView.h b/Source/Sample/View/TrackerParameterView.h
new file mode 100644
index 0000000000000000000000000000000000000000..80fe6d89bed2c0cd574f14768ba77af2f6381e9e
--- /dev/null
+++ b/Source/Sample/View/TrackerParameterView.h
@@ -0,0 +1,31 @@
+#ifndef TRACKERPARAMETERVIEW_H
+#define TRACKERPARAMETERVIEW_H
+
+#include "Interfaces/IView/IViewWidget.h"
+#include "Model/TrackerParameter.h"
+
+namespace Ui {
+	class TrackerParameterView;
+}
+
+class TrackerParameterView : public IViewWidget
+{
+	Q_OBJECT
+
+public:
+	explicit TrackerParameterView(QWidget *parent = 0, IController *controller = 0, IModel *model = 0);
+	~TrackerParameterView();
+
+	private slots:
+	void on_pushButton_clicked();
+
+private:
+	Ui::TrackerParameterView *ui;
+
+	// IViewWidget interface
+	public slots:
+
+	void getNotified();
+};
+
+#endif // TRACKERPARAMETERVIEW_H
diff --git a/Source/Sample/View/TrackerParameterView.ui b/Source/Sample/View/TrackerParameterView.ui
new file mode 100644
index 0000000000000000000000000000000000000000..eefda9106aad6e43fc69750b00f8e5de53fd82aa
--- /dev/null
+++ b/Source/Sample/View/TrackerParameterView.ui
@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>TrackerParameterView</class>
+ <widget class="QWidget" name="TrackerParameterView">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>304</width>
+    <height>489</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_2">
+       <item>
+        <widget class="QLabel" name="label_2">
+         <property name="text">
+          <string>LowH</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLineEdit" name="lineEdit_2_lowH"/>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_6">
+       <item>
+        <widget class="QLabel" name="label_3">
+         <property name="text">
+          <string>HighH</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLineEdit" name="lineEdit_3_highH"/>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_7">
+       <item>
+        <widget class="QLabel" name="label_4">
+         <property name="text">
+          <string>LowS</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLineEdit" name="lineEdit_4_lowS"/>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_5">
+       <item>
+        <widget class="QLabel" name="label_5">
+         <property name="text">
+          <string>HighS</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLineEdit" name="lineEdit_5_HighS"/>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_4">
+       <item>
+        <widget class="QLabel" name="label_6">
+         <property name="text">
+          <string>LowV</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLineEdit" name="lineEdit_6_LowV"/>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <layout class="QHBoxLayout" name="horizontalLayout_8">
+       <item>
+        <widget class="QLabel" name="label_7">
+         <property name="text">
+          <string>HighV</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLineEdit" name="lineEdit_7_HighV"/>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton">
+       <property name="text">
+        <string>Set Values</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Source/Sample/biotrackerplugin_global.h b/Source/Sample/biotrackerplugin_global.h
new file mode 100644
index 0000000000000000000000000000000000000000..770f7d2152af7436d9f2c4b302215cd42baa3df7
--- /dev/null
+++ b/Source/Sample/biotrackerplugin_global.h
@@ -0,0 +1,12 @@
+#ifndef BIOTRACKERPLUGIN_GLOBAL_H
+#define BIOTRACKERPLUGIN_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+#if defined(BIOTRACKERPLUGIN_LIBRARY)
+#  define BIOTRACKERPLUGINSHARED_EXPORT Q_DECL_EXPORT
+#else
+#  define BIOTRACKERPLUGINSHARED_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // BIOTRACKERPLUGIN_GLOBAL_H