Skip to content

Instantly share code, notes, and snippets.

@MishkaRogachev

MishkaRogachev/target_model.cpp

Last active August 29, 2015 14:21
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save MishkaRogachev/31c52edfef84888b44cf to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save MishkaRogachev/31c52edfef84888b44cf to your computer and use it in GitHub Desktop.
Download ZIP
Raw
target_model.cpp
#include "target_model.h"
using namespace domain;
TargetModel::TargetModel(TargetType type, const QRect& rect, QObject* parent):
QObject(parent),
m_type(type),
m_rect(rect)
{}
TargetType TargetModel::type() const
{
return m_type;
}
QRect TargetModel::rect() const
{
return m_rect;
}
void TargetModel::setType(TargetType type)
{
if (m_type == type) return;
m_type = type;
emit typeChanged(type);
}
void TargetModel::setRect(const QRect& rect)
{
if (m_rect == rect) return;
m_rect = rect;
emit rectChanged(rect);
}
Raw
target_model.h
#ifndef TARGET_MODEL_H
#define TARGET_MODEL_H
// Qt
#include <QObject>
#include <QRect>
#include <QList>
#include <QPointer>
namespace domain
{
enum class TargetType
{
Unknown,
Engaged,
Detected,
Pin
};
class TargetModel: public QObject
{
Q_OBJECT
public:
TargetModel(TargetType type, const QRect& rect,
QObject* parent = nullptr);
TargetType type() const;
QRect rect() const;
public slots:
void setType(TargetType type);
void setRect(const QRect& rect);
signals:
void typeChanged(TargetType type);
void rectChanged(const QRect& rect);
private:
TargetType m_type;
QRect m_rect;
};
using TargetPtr = QPointer< TargetModel >;
using TargetPtrList = QList< TargetPtr >;
}
Raw
video_analytics_model.cpp
#include "video_analytics_model_private.h"
using namespace domain;
VideoAnalyticsModel::VideoAnalyticsModel(QObject* parent):
QObject(parent),
d(new VideoAnalyticsModelPrivate())
{}
VideoAnalyticsModel::~VideoAnalyticsModel()
{
delete d;
}
TargetPtrList VideoAnalyticsModel::detectedTargets() const
{
return d->detectedTargets;
}
TargetPtr VideoAnalyticsModel::autotrackingTarget() const
{
return d->engagedTarget;
}
TargetPtr VideoAnalyticsModel::pinTarget() const
{
return d->pinTarget;
}
void VideoAnalyticsModel::updateDetectedTargets(const TargetPtrList& targets)
{
// Удаляем старые
for (const TargetPtr& target: d->detectedTargets)
{
if (targets.contains(target)) continue;
this->removeDetectedTarget(target);
}
// Добавляем новые
for (const TargetPtr& target: targets)
{
if (d->detectedTargets.contains(target)) continue;
this->addDetectedTarget(target);
}
}
void VideoAnalyticsModel::addDetectedTarget(const TargetPtr& target)
{
target->setParent(this);
d->detectedTargets.append(target);
emit targetAdded(target);
}
void VideoAnalyticsModel::removeDetectedTarget(const TargetPtr& target)
{
emit targetIsGoingToBeRemoved(target);
d->detectedTargets.removeOne(target);
target->deleteLater();
}
void VideoAnalyticsModel::setAutotrackingTarget(const TargetPtr& target)
{
if (d->engagedTarget == target) return;
if (d->engagedTarget)
{
emit targetIsGoingToBeRemoved(d->engagedTarget);
d->engagedTarget->deleteLater();
emit autotrackingStopped();
}
d->engagedTarget = target;
if (target)
{
emit targetAdded(target);
emit autotrackingStarted(target);
}
}
void VideoAnalyticsModel::setPinTarget(const TargetPtr& target)
{
if (d->pinTarget == target) return;
if (d->pinTarget)
{
emit targetIsGoingToBeRemoved(d->pinTarget);
d->pinTarget->deleteLater();
emit pinStopped();
}
d->pinTarget = target;
if (target)
{
emit targetAdded(target);
emit pinStarted(target);
}
}
void VideoAnalyticsModel::orderStartAutotracking(const QRect& rect)
{
TargetPtr target(new TargetModel(TargetType::Engaged, rect));
this->setAutotrackingTarget(target);
}
void VideoAnalyticsModel::orderStopAutotracking()
{
this->setAutotrackingTarget(TargetPtr());
}
void VideoAnalyticsModel::orderStartPin(const QRect& rect)
{
TargetPtr target(new TargetModel(TargetType::Pin, rect));
this->setPinTarget(target);
}
void VideoAnalyticsModel::orderStopPin()
{
this->setPinTarget(TargetPtr());
}
Raw
video_analytics_model.h
#ifndef VIDEO_ANALYTICS_MODEL_H
#define VIDEO_ANALYTICS_MODEL_H
#include "target_model.h"
namespace domain
{
class VideoAnalyticsModel: public QObject
{
Q_OBJECT
public:
explicit VideoAnalyticsModel(QObject* parent = nullptr);
~VideoAnalyticsModel() override;
TargetPtrList detectedTargets() const;
TargetPtr autotrackingTarget() const;
TargetPtr pinTarget() const;
public slots:
void updateDetectedTargets(const TargetPtrList& targets);
void addDetectedTarget(const TargetPtr& target);
void removeDetectedTarget(const TargetPtr& target);
void setAutotrackingTarget(const TargetPtr& target);
void setPinTarget(const TargetPtr& target);
void orderStartAutotracking(const QRect& rect);
void orderStopAutotracking();
void orderStartPin(const QRect& rect);
void orderStopPin();
signals:
void targetAdded(const TargetPtr& target);
void targetIsGoingToBeRemoved(const TargetPtr& target);
void autotrackingStarted(const TargetPtr& target);
void autotrackingStopped();
void pinStarted(const TargetPtr& target);
void pinStopped();
private:
class VideoAnalyticsModelPrivate;
VideoAnalyticsModelPrivate* d;
Q_DISABLE_COPY(VideoAnalyticsModel)
};
}
#endif // VIDEO_ANALYTICS_MODEL_H
Raw
video_analytics_model_private.h
#ifndef VIDEO_ANALYTICS_MODEL_PRIVATE_H
#define VIDEO_ANALYTICS_MODEL_PRIVATE_H
#include "video_analytics_model.h"
namespace domain
{
class VideoAnalyticsModel::VideoAnalyticsModelPrivate
{
public:
TargetPtrList detectedTargets;
TargetPtr engagedTarget;
TargetPtr pinTarget;
};
}
#endif // VIDEO_ANALYTICS_MODEL_PRIVATE_H
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment