Added "Utility" as a folder/prefix

Src/CMakeLists.txt

@@ -30,17 +30,17 @@ set_target_properties(${TN} PROPERTIES
 
 target_sources(${TN}
 PRIVATE
-    "${CMAKE_CURRENT_LIST_DIR}/TrackedComponents/TrackedComponentFactory.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/TrackedComponents/TrackedElement.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/TrackedComponents/TrackedTrajectory.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/util/misc.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/IConfig.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/TrackedComponents/TrackedComponentFactory.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/TrackedComponents/TrackedElement.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/TrackedComponents/TrackedTrajectory.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/misc.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/IConfig.cpp"
 )
 
 set(${TN}_PUBLIC_HEADERS
-    "${CMAKE_CURRENT_LIST_DIR}/TrackedComponents/TrackedComponentFactory.h"
-    "${CMAKE_CURRENT_LIST_DIR}/TrackedComponents/TrackedElement.h"
-    "${CMAKE_CURRENT_LIST_DIR}/TrackedComponents/TrackedTrajectory.h"
-    "${CMAKE_CURRENT_LIST_DIR}/util/misc.h"
-    "${CMAKE_CURRENT_LIST_DIR}/IConfig.h"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/TrackedComponents/TrackedComponentFactory.h"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/TrackedComponents/TrackedElement.h"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/TrackedComponents/TrackedTrajectory.h"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/misc.h"
+    "${CMAKE_CURRENT_LIST_DIR}/Utility/IConfig.h"
 )
\ No newline at end of file

Src/TrackedComponents/TrackedComponentFactory.h → Src/Utility/TrackedComponents/TrackedComponentFactory.h

-#ifndef TRACKEDCOMPONENTFACTORY_H
-#define TRACKEDCOMPONENTFACTORY_H
+#pragma once
 
 #include "Interfaces/IModel/IModelTrackedComponentFactory.h"
 
@@ -8,14 +7,13 @@ class TrackedComponentFactory : public IModelTrackedComponentFactory
     Q_OBJECT
 public:
     TrackedComponentFactory();
-    ~TrackedComponentFactory();
+    virtual ~TrackedComponentFactory();
 
-    QList<QString> getElementTypes() override;
+    virtual QList<QString> getElementTypes() override;
     // ITrackedComponentFactory interface
 protected:
-    IModelTrackedComponent *createTrackedElement(QString name) override;
-    IModelTrackedComponent *createTrackedObject(QString name) override;
-    IModelTrackedComponent *createTrackedTrajectory(QString name) override;
+    virtual IModelTrackedComponent *createTrackedElement(QString name) override;
+    virtual IModelTrackedComponent *createTrackedObject(QString name) override;
+    virtual IModelTrackedComponent *createTrackedTrajectory(QString name) override;
 };
 
-#endif // TRACKEDOBJECTFACTORY_H

Src/TrackedComponents/TrackedElement.h → Src/Utility/TrackedComponents/TrackedElement.h

-#ifndef TRACKEDELEMENT_H
-#define TRACKEDELEMENT_H
+#pragma once
 
 #include "QGraphicsItem"
 #include "Interfaces/IModel/IModelTrackedComponent.h"
@@ -20,75 +19,75 @@ class TrackedElement : public IModelTrackedPoint
 
 public:
 	TrackedElement(QObject *parent = 0, QString name = "n.a.", int id = 0);
+    virtual ~TrackedElement() {};
 
-	QString getName();
-    QString getCoordinateUnit() override { return "px"; };
+	virtual QString getName();
+    virtual QString getCoordinateUnit() override { return "px"; };
 
-    void  setX(float val);
-    void  setY(float val);
-    void  setW(float w) {};
-    void  setH(float h) {};
-    void  setXpx(float val) {};
-    void  setYpx(float val) {};
-    void  setWpx(float w) {};
-    void  setHpx(float h) {};
-	void  setRad(float r) {};
-	void  setDeg(float d) {};
-	void  setId(int val) { _id = val; };
-    void  setTime(std::chrono::system_clock::time_point t) {
+    virtual void  setX(float val) override;
+    virtual void  setY(float val) override;
+    virtual void  setW(float w) override {};
+    virtual void  setH(float h) override {};
+    virtual void  setXpx(float val) override {};
+    virtual void  setYpx(float val) override {};
+    virtual void  setWpx(float w) override {};
+    virtual void  setHpx(float h) override {};
+	virtual void  setRad(float r) override {};
+	virtual void  setDeg(float d)  override{};
+	virtual void  setId(int val) override { _id = val; };
+    virtual void  setTime(std::chrono::system_clock::time_point t) {
         _timeSysclck = t;
     };
-    void  setTime(qint64 t) {
-        _time = t;
+    virtual void  setTime(qint64 t) override {
         std::string::size_type sz = 0;
         long long ll = t / 1000;
         std::time_t tm(ll);
         _timeSysclck = std::chrono::system_clock::from_time_t(tm);
     };
-    void  setTimeString(QString t) { _timeString = t; };
-	void  setValid(bool v) { _valid = v; };
-	void  setFixed(bool f) { _fixed = f; };
+    virtual void  setTimeString(QString t) override { _timeString = t; };
+	virtual void  setValid(bool v) override { _valid = v; };
+	virtual void  setFixed(bool f) override { _fixed = f; };
 
-    float getX();
-    float getY();
-    float getXpx();
-    float getYpx();
-    float getW() { return 0; };
-    float getH() { return 0; };
-    float getWpx() { return 0; };
-    float getHpx() { return 0; };
-	float getRad() { return 0; };
-	float getDeg() { return 0; };
-	int   getId() { return _id; };
-    qint64  getTime() {
+    virtual float getX() override;
+    virtual float getY() override;
+    virtual float getXpx() override;
+    virtual float getYpx() override;
+    virtual float getW() override { return 0; };
+    virtual float getH() override { return 0; };
+    virtual float getWpx() override { return 0; };
+    virtual float getHpx() override { return 0; };
+	virtual float getRad() override { return 0; };
+	virtual float getDeg() override { return 0; };
+	virtual int   getId() override { return _id; };
+    virtual qint64  getTime() override {
         qint64 q(std::chrono::duration_cast<std::chrono::milliseconds>(_timeSysclck.time_since_epoch()).count());
         return q;
     };
-    QString getTimeString() {
+    virtual QString getTimeString() override {
         std::time_t t = std::chrono::system_clock::to_time_t(_timeSysclck);
         QDateTime dt;
         dt.setTime_t(t);
         _timeString = dt.toString();
         return _timeString;
     };
-	bool  getValid() { return _valid; };
-	bool  getFixed() { return _fixed; };
+	virtual bool  getValid() override { return _valid; };
+	virtual bool  getFixed() override { return _fixed; };
 
-	bool hasX() { return true; };
-	bool hasY() { return true; };
-	bool hasW() { return false; };
-	bool hasH() { return false; };
-    bool hasXpx() { return false; };
-    bool hasYpx() { return false; };
-    bool hasWpx() { return false; };
-    bool hasHpx() { return false; };
-	bool hasRad() { return false; };
-	bool hasDeg() { return false; };
-	bool hasTime() { return true; };
-    bool hasTimeString() { return true; };
+	virtual bool hasX() override { return true; };
+	virtual bool hasY() override { return true; };
+	virtual bool hasW() override { return false; };
+	virtual bool hasH() override { return false; };
+    virtual bool hasXpx() override { return false; };
+    virtual bool hasYpx() override { return false; };
+    virtual bool hasWpx() override { return false; };
+    virtual bool hasHpx() override { return false; };
+	virtual bool hasRad() override { return false; };
+	virtual bool hasDeg() override { return false; };
+	virtual bool hasTime() override { return true; };
+    virtual bool hasTimeString() override { return true; };
 
-	void setPoint(cv::Point2f p);
-    cv::Point2f getPoint();
+	virtual void setPoint(cv::Point2f p);
+    virtual cv::Point2f getPoint();
 
 	// ITrackedPoint interface
 public:
@@ -97,6 +96,7 @@ public:
 private:
     std::chrono::system_clock::time_point _timeSysclck;
 	QString _name;
+    QString _timeString;                         /**< timestamp a formatted as string */
 	float _x;
 	float _y;
 	int _id;
@@ -104,4 +104,3 @@ private:
 	bool _fixed;
 };
 
-#endif // TRACKEDELEMENT_H

Src/TrackedComponents/TrackedTrajectory.h → Src/Utility/TrackedComponents/TrackedTrajectory.h

-#ifndef TRACKEDOTRAJECTORY_H
-#define TRACKEDOTRAJECTORY_H
+#pragma once
 
 #include "Interfaces/IModel/IModelTrackedTrajectory.h"
 #include "QList"
@@ -18,6 +17,7 @@ class TrackedTrajectory : public IModelTrackedTrajectory {
 
   public:
 	TrackedTrajectory(QObject *parent = 0, QString name = "n.a.");
+    virtual ~TrackedTrajectory() {};
 
 	// ITrackedComponent interface
 public:
@@ -25,20 +25,30 @@ public:
 
 	// ITrackedObject interface
 public:
-	void add(IModelTrackedComponent *comp, int pos = -1) override;
-	bool remove(IModelTrackedComponent *comp) override;
-	void clear() override;
-	IModelTrackedComponent *getChild(int index) override;
-    IModelTrackedComponent *getValidChild(int index) override;
-	IModelTrackedComponent *getLastChild() override;
-
-    int size() override;
-    int validCount();
-
-private:
+	virtual void add(IModelTrackedComponent *comp, int pos = -1) override;
+	virtual bool remove(IModelTrackedComponent *comp) override;
+	virtual void clear() override;
+	virtual IModelTrackedComponent *getChild(int index) override;
+    virtual IModelTrackedComponent *getValidChild(int index) override;
+	virtual IModelTrackedComponent *getLastChild() override;
+
+    virtual int size() override;
+    virtual int validCount() override;
+
+    virtual QList<IModelTrackedComponent*> getChildNodes() override {
+        return _TrackedComponents;
+    }
+    virtual void setChildNodes(QList<IModelTrackedComponent*> n) override {
+        _TrackedComponents = n;
+    }
+   virtual  bool hasChildNodes() override {
+        return !_TrackedComponents.empty();
+    }
+
+
+protected:
 	QList<IModelTrackedComponent*> _TrackedComponents;
 
 	QString name;
 };
 
-#endif // TRACKEDOTRAJECTORY_H

Src/util/misc.cpp → Src/Utility/misc.cpp

-#include "util/misc.h"
+#include "Utility/misc.h"
 
 #include <QPoint>             // QPoint
 #include <QString>