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