shapeModel.h

#ifndef SHAPEMODEL_H
#define SHAPEMODEL_H

#include <QDomNode>
#include <QImage>
#include <vector>
#include <QSharedPointer>

#include "reliabilitysinglemodelinterface.h"
#include "src/blob.h"
#include "Blob2DFromBGSubstractionModel.h"

#include "src/hullmodel.h"

//#include "opencv/cv.h";

class Datapool;

class ShapeModel: public ReliabilitySingleModelInterface {
public:
    ShapeModel(int buffer_size);

    virtual ~ShapeModel();

    //IMPLEMENT!! Initializes the model attributes for the interface.
    //The function is called by the interface constructor
    virtual void initInstanceAttributes();

    //IMPLEMENT!! Initializes the dynamics model attributes for the interface.
    //The function is called by the interface constructor
    virtual void initDynamicsAttributes();

    //IMPLEMENT!! Copy function for specific data from the instance (general_copy calls it after copying base info)
    virtual void copy(SpReliabilitySingleModelInterface);

    //IMPLEMENT!! Copy general structures and parameters of specific model, without considering instance specific data
    virtual void copy_structure(SpReliabilitySingleModelInterface);

    //IMPLEMENT!! sets parameters from xml file
    virtual void setParameters(QDomNode &i_parameters);

    //IMPLEMENT!! sets activation criteria for each model: reliability on input (distance, bad data),
    //   needs (occlusion, priority),
    //sets priority of models (hierarchy).
    //Checked before update phase
    virtual void activate(BoundingBox &);

    //IMPLEMENT!! initializes every activated model, according to their own input (region-blob-segments schema)
    //Executed only once at the begginning of single model creation (after 'copy_structure' and 'copy' methods
    //are used to copy the information).
    virtual void init();

    //IMPLEMENT!! updates activated model instance attributes for current frame, and returns the set of detected/enriched objects.
    //            It notifies if roi (bounding box, or segmentation) changes compared to the input, for reprocessing.
    virtual bool updateInstance(BoundingBox &, std::set<SpRMMHypothesis, hypothesesOrderedByBestProbabilityOperator> &);

    //IMPLEMENT!! updates activated model instance attributes for current frame and object, and returns the detected/enriched object.
    //            It notifies if roi (bounding box, or segmentation) changes compared to the input, for reprocessing.
    //            This function does NOT generate mobiles or hypotheses. It processes attributes for the current object.
    //            This function could be used by updateInstance to generate mobile information, for the generated mobiles.
    //            IT MUST INSERT A NEW ModelInstanceDataPack IN instances buffer and update ginfo attribute of the ModelInstanceDataPack
    //            properly (see ModelInstanceGeneralPack).
    //            IF CALLED INSIDE ONE METHOD OF THIS CLASS, IT MUST INCLUDE A CALL TO METHOD: updateCurrentGeneralInfo();
    //              ALSO WHEN CREATING NEW OBJECTS (IT MUST BE CALLED FOR THE CREATED OBJECT).
    virtual void updateSingleInstance(BoundingBox &);

    //IMPLEMENT!! updates model dynamics, based on instances information: work on post_dynamics structure
    virtual void updateModelDynamics();

    //Visualization

    virtual bool draw(QPainter &painter, int r, int g, int b);

    //Starts dynamics in multimodel and calls specific model dynamics with updateModelDynamics();
    void updateDynamics();

    //sets global probability P for the model (how good is the model)
    //sets global reliability R for the model (how good is the data used in the model)
    virtual void setProbabilityAndReliability();

    //sets data pack general information of the model in forward process (update)
    virtual void setForwardInterface();

    //Get 2D central bounding box point from the model
    //virtual void setTrajectory2D(double &, double &, double &);

    //Estimates the bounding box size and position for next
    //frame according to its own dynamics model
    //It also sets Reliability R of the model estimation.
    //The function defaults to the 'binterface' bounding box.
    //Nevertheless, a better implementation really depending on the
    //specific dynamics model is expected.
    //virtual BoundingBox getEstimator(double &R);



    // -----------------FUNCIONES DEGU

    bool shapeAnalysis(float &headX, float &headY, float &dirX, float &dirY, float &bodyX, float &bodyY,BoundingBox &ro);


    SpHullModel deguShape;
    QImage muestra;
    bool todoListo;



    static bool movementFound(cv::Mat f, int wsize, int i0, int j0);
    static bool movementFound(cv::Mat f, int wsize, int i0, int j0, cv::Rect roi);
    static double histogramDistance(cv::MatND h1, cv::MatND h2);
    static double distanceToSegment(int i1, int i2, std::vector<cv::Point> &contour);
    static bool lineSegmentIntersection(cv::Point3f &line,
                                 cv::Point2f &p1, cv::Point2f &p2, cv::Point2f &r);
    static bool getGeneralLineForm(cv::Point2f p1, cv::Point2f p2,
                                        cv::Point3f &rline);
    static bool getGeneralLineForm(float x, float y, float dx, float dy,
                                   cv::Point3f &rline);


    //Get intersection points r1 and r2 between line 'rline' and contour 'hull' (oriented to
    //convex hull). If non NULL n1 and n2 pointers, are used to store indexes of contour segments
    //where intersections were found (to be used later on pixel distance function construction).
    static int getContourToLineIntersection(std::vector<cv::Point> &hull,
                                             cv::Point3f &rline,
                                             cv::Point2f &r1, cv::Point2f &r2,
                                             int *n1 = NULL, int *n2 = NULL);

    //Fills a segments vector with moving pixel bounds for each normal on the axis
    void getNormalIntersections(cv::Mat &f, cv::Rect &roi, std::vector<cv::Point> &hull,
                                cv::Point2f &r1, cv::Point2f &r2, int n1, int n2,
                                float dx, float dy, std::vector< segment2D<float> > &segs,
                                std::vector< segment2D<float> > &hull_segs);

    //Sets the moving segment for one normal
    void setForegroundSegment(cv::Mat &f, cv::Rect &roi, std::vector<cv::Point> &hull,
                              segment2D<float> &seg, segment2D<float> &hseg, float x, float y,
                              float dx, float dy, int &I1, int &I2);


    //Gets the intersection betweel a line and a contour, in current or next contour
    //segment.
    static int getContourToLineIntersectionIndexed(std::vector<cv::Point> &polygon,
                                            cv::Point3f &rline,
                                             cv::Point2f &r1, cv::Point2f &r2,
                                             int &n1, int &n2);

    //Counts foreground pixels on a window
    static int movementCount(cv::Mat f, int wsize, int i0, int j0, cv::Rect roi);

    void findHead(SpHullModel hull);


    cv::Point2f headLocation;


    void displayShowHull(QPainter &painter, SpHullModel hull);
    void displayShowAxis(QPainter &painter, SpHullModel hull);
    void displayShowNormals(QPainter &painter, SpHullModel hull);
    void displayBackBone(QPainter &painter, SpHullModel hull);


    void backBoneAnalysis(SpHullModel hull);

    bool readyBackBone;
    float ay, by, cy, ax, bx, cx;

    bool drawBackBoneCurve(QPainter &painter,SpHullModel hull);
    bool drawHeadDirection(QPainter &painter,SpHullModel hull);

    bool drawHeadRealDirection(QPainter &painter,SpHullModel hull);

    float napeRatio;
    float distance;

    std::vector< segment2D<float> > uncertaintyPoint;
    std::vector< segment2D<float> > uncertaintyDirection;

    bool uncertainMode;
    bool alreadyDirect;
    int axisDirection;

    std::vector< cv::Point2f > headPoint;
    std::vector< cv::Point2f > headDirection;

    int framesToBeUncertain;


    bool analysesDirection(float &dirHeadX,float &dirHeadY,float &dirHipsX,float &dirHipsY,SpHullModel hull);


    bool drawFlagHull;
    bool drawFlagAxis;
    bool drawFlagNormals;
    bool drawFlagBackBone;
    bool drawFlagBoneCurve;
    bool drawFlagHeadDirection;
    bool drawFlagHeadRealDirection;

    float speedThreshold;
    int frameThreshold;

    bool findTail(SpHullModel hull);

    float massThreshold;

    void opticalFlow();
    void stopOpticalFlow();

    cv::Mat lastImage;

    bool opticalFlowRunning;

    BoundingBox actualBlob;

    cv::Rect opticalFlowBox;

    //cv::OutputArray lastPoint;
    //cv::OutputArray currentPoint;

    std::vector<cv::Point2f> lastPoint;
    std::vector<cv::Point2f> currentPoint;

    void drawEntropy(QPainter &painter);

    cv::Point2f surf(std::vector<cv::Point2f> vectors);

    void quickSortAngle(std::vector<cv::Point2f> &vectors, std::vector<float> &angles, int init, int end);


    void drawResultOpticalVector(QPainter &painter, SpHullModel hull);

    void drawHead(QPainter &painter, SpHullModel hull);

    cv::Point2f vectorSums(std::vector<cv::Point2f> vectors, std::vector<cv::Point2f> points,SpHullModel hull);

    cv::Point2f lastHeadPoint;
    cv::Point2f actualHeadPoint;

    bool drawTail(QPainter &painter,SpHullModel hull);

    cv::Point2f vectorSumsPivote(std::vector<cv::Point2f> vectors, std::vector<cv::Point2f> points,SpHullModel hull, cv::Point2f pivote);

    cv::Point2f opticalRotation(std::vector<cv::Point2f> vectors, std::vector<cv::Point2f> points,SpHullModel hull);


    std::vector<cv::Point2f> wannabeSurfResult;
    std::vector<cv::Point2f> sumaResult;
    std::vector<cv::Point2f> sumaPivoteResult;
    std::vector<cv::Point2f> opticalRotationResult;

    cv::Point2f lastMiddlePoint;

    int findTailAlgorithm(SpHullModel hull);


};


#endif // SHAPEMODEL_H