CscEntityDetectionState.h

Go to the documentation of this file.

//
//  CscEntityDetectionState.h
//  ConscienceRobotManager
//
//  Created by Hazar Zaoui on 15/12/2023.
//  Copyright © 2023 IliesZaoui. All rights reserved.
//
 
#ifndef CscEntityDetectionState_h
#define CscEntityDetectionState_h
 
#include <ctime>
#include <numeric>
#include "CscCommon.h"
#include "alerts.h"
#include "CoreObjects/CscWorldObject.h"
#include <DetectorEngine/CscDetectorEngine.h>
 
using namespace conscience_core::ai::alerts;
 
using std::chrono_literals::operator""s, std::chrono_literals::operator""ms, std::chrono_literals::operator""h;
using std::prev, std::recursive_mutex, std::chrono::system_clock, std::chrono::duration, std::remove_if, std::chrono::duration_cast, std::chrono::milliseconds, std::function;
 
namespace cv {
class Tracker;
}
namespace conscience_core::ai {
 
struct CSC_DLL_IMPORTEXPORT TrackHit {
    const unsigned long long timestampMillis;
    const CscRect2d rectangle;
    
    const bool actualDetection;
    
    TrackHit(unsigned long long timestampMillis, const CscRect2d &rectangle, bool actualDetection);
};
 
class CSC_DLL_IMPORTEXPORT TrackedObject {
private:
    
    inline static int counter = 0;
    vector<TrackHit *> trackingHistory;
    float certitude;
    const float motionIouThreshold = 0.35;
    
    vector<const TrackHit *> getRecentHits(long lastMillis) const;
public:
    
    const int uid = counter++;
    CscWorldObject *const worldObject;
    const ptr<cv::Tracker> tracker;
    const system_clock::time_point firstDetectionTime = system_clock::now();
    system_clock::time_point lastDetectionTime = system_clock::now();
    system_clock::time_point lastActualDetectionTime = system_clock::now();
    system_clock::time_point lastMotionTime = system_clock::now();
    
    TrackedObject(CscWorldObject * worldObject, ptr<cv::Tracker> tracker, const CscRect2d & firstDetectionBox, float certitude);
    ~TrackedObject();
    
    void onDetected(const CscRect2d & newDetectionBox, float updatedCertitude, bool actualDetection, const CscPoint3d * position = nullptr, const CscPoint3d * rotation = nullptr);
    
    operator string() const;
    
    const CscRect2d &getLastDetectionBox() const;
    bool isLastHitAnActualDetection() const;
    
    unsigned long long getImmobileSinceMilliseconds() const;
    
    vector<CscRect2d> getLastDetectionBoxes(optional<int> count = {}) const;
    
    CscRect2d getAverageBox(optional<int> count = {}) const;
    
    float getCertitude() const;
    
    int countActualDetections(long lastMillis) const;
    
    float getActualDetectionsRatio(long lastMillis) const;
    
    float getMotionRatio(long lastMillis) const;
    
    bool isOlderThan(long millis) const;
    
    int getHitsCount(long lastMillis) const;
    
    unsigned long long getMaxDurationBetweenHits(long observationPeriodMillis) const;
    
    CscDetectedAlert *toAlert(CscAlertTypeBuiltin alertType, optional<float> forcedCertitude = {}) const;
    
};
 
class CSC_DLL_IMPORTEXPORT CscEntityAlertIdentificationState {
public:
    unsigned long long lastFramesWithPersonRatioCheckMillis = nowMillis();
    vector<float> framesWithPersonRatioPerPeriod;
    vector<bool> framesWithPerson;
};
 
class CSC_DLL_IMPORTEXPORT CscEntityDetectionState {
public:
    operator string() const;
    map<string, double> previousCarePulseValues;
    map<string, double> previousCareRedonValues;
    bool pulseDisconnectedAlertSent = false;
    bool redonDisconnectedAlertSent = false;
    bool hasReceivedCareSureValues = false; 
    bool hasReceivedCarePulseValues = false;
    unsigned long long lastRedonSensorTimestamp = 0;
    unsigned long long lastPulseSensorTimestamp = 0;
 
    vector<ptr<TrackedObject>> updateDetectionState(const cv::Mat &pristineImage, cv::Mat &processedImage, ptr<detector_engine::DetectionResult> detectionResult, bool trackingEnabled);
    
    ptr<TrackedObject> getTrackedObject(int uid) const;
    system_clock::time_point lastUpdateTime = system_clock::now();
    
    const vector<ptr<TrackedObject>> & getTrackedObjects() const;
    
    void trackObject(ptr<TrackedObject> object);
    
    ptr<TrackedObject> untrackObject(const int trackedObjectUid);
    
    vector<ptr<TrackedObject>> clear();
    template <class Rep, class Period>
    vector<ptr<TrackedObject>> untrackObjectsAbsentFor(duration<Rep, Period> maxAbsenceDuration) {
        system_clock::time_point now = system_clock::now();
        
        vector<ptr<TrackedObject>> removedObjects;
        vector<ptr<TrackedObject>> updatedTrackedObjects;
        for (ptr<TrackedObject> trackedObject : trackedObjects) {
            if (now < (trackedObject->lastDetectionTime + maxAbsenceDuration)) {
                updatedTrackedObjects.push_back(trackedObject);
            } else {
                removedObjects.push_back(trackedObject);
            }
        }
        
        trackedObjects = updatedTrackedObjects;
        
        return removedObjects;
    }
    
    template <class Rep, class Period>
    vector<ptr<TrackedObject>> untrackObjectsMissingActualDetectionFor(duration<Rep, Period> maxDuration) {
        system_clock::time_point now = system_clock::now();
        
        vector<ptr<TrackedObject>> removedObjects;
        vector<ptr<TrackedObject>> updatedTrackedObjects;
        
        for (ptr<TrackedObject> trackedObject : trackedObjects) {
            if (now < (trackedObject->lastActualDetectionTime + maxDuration)) {
                updatedTrackedObjects.push_back(trackedObject);
            } else {
                removedObjects.push_back(trackedObject);
            }
        }
        
        trackedObjects = updatedTrackedObjects;
        
        return removedObjects;
    }
    
    
    ptr<TrackedObject> getClosestObject(const CscPoint3d * fromReferencePoint, bool requireActualDetection = false) const;
    static constexpr unsigned long long framesWithPersonRatioPeriodMillis = 60'000;
    
    ptr<TrackedObject> getCurrentPersonFall();
 
    CscEntityAlertIdentificationState &getAlertIdentificationState();
    void resetIdentificationState();
 
private:
    milliseconds trackingMaxActualDetectionMissingDuration = 200ms;
    milliseconds trackingMaxAbsenceDuration = 100ms;
    vector<ptr<TrackedObject>> trackedObjects;
 
    CscEntityAlertIdentificationState alertIdentificationState;
    
    ptr<TrackedObject> currentPersonFall = nullptr;
    ptr<TrackedObject> currentPersonOutsideBed = nullptr;
    std::unique_ptr<CscLogger> logger;
    
    
};
}
#endif /* CscEntityDetectionState_h */