ProbMultiRegCamStr.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



#ifndef __PROB_MULTI_REG_CAM_STR_H
#define __PROB_MULTI_REG_CAM_STR_H

#include <MIPMatrix.h>
#include "time.h"
#include <fstream>
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include <iostream>
#include <R2.h>
#include <S1.h>
#include <SE2.h>
#include <map>
#include <MultiRegCamStr.h>

namespace MipAlgorithms {

    class ProbPolFusion {
    private:
        vector<Triangle*>   _triangles;
        vector<PosId>       _vertex;
        vector<Angle>       _ori;
        InterPoints         _intThree;
        vector<Triangle*>   _triangleQueue;
        vector<MIPMatrix>   _rotoTrasl;
        vector<Decimal>     _scaleF;
        int                 _ratingVertex;
        int                 _ratingInThree;
        vector<int>         _numIntFour;
        int                 _expandMethod;

    public:
        ProbPolFusion();

        ProbPolFusion(Triangle* tria, int expMth);

        ~ProbPolFusion();

        Triangle* getTriangle(int pos);

        void setTriangle(int pos,Triangle* tria);

        void deleteTriangle(int pos);

        void deleteLastTriangle();

        void deleteBifConflicts(int pos,int posAt, int idNew);

        void deleteBifConflictsOpt(int pos, int idNew);


        //void setMatrix(int id1, int id2, int pos);


        int getSize();

        int getQueueSize();

        void getIds(vector<int> &ids);

        void insertVertex(PosId vertex);

        PosId getVertex(int pos);

        void setVertex(int pos,PosId vertex);

        void setQueue(Triangle* queue);

        int queueSize();

        void deleteQueueTriangle(int pos);

        void deleteQueueLastTriangle();

        void setScale(int i, Decimal scale);

        void setScale(Decimal scale);

        Decimal getScale(int i);

        void deleteScaleF(int pos);

        void deleteLastScaleF();

        void setRotoTrasl(int pos, MIPMatrix rt);

        void deleteRotoTrasl(int pos);

        void deleteLastRotoTrasl();

        void insertOri(Decimal ori);

        Decimal getOri(int pos);

        void setOri(int pos,Angle ori);

        void deleteOri(int pos);

        void deleteLastOri();

        void insertTriangle(Triangle *tria, int myId, int id1, int id2);

        PosId* searchVertex(int id);

        PosId* searchVertex(int id,int &posAt);

        void deleteVertex(int pos);

        void deleteLastVertex();

        int searchBif(PosId vertex,int &posAt,Decimal thr);

        void insertPoints(Triangle* tria, int &numInt4);

        void insertPointsNoIn(Triangle* tria, int &numInt4, MIPMatrix* &matrixPointer, Decimal actualScale, vector<Position> &intToInsert, int &incrRatInThree);

        int getNInThree(int pos);

        Position getIntThree(int pos);

        Position getLastIntThree();

        void deleteIntThree(int pos);

        void deleteLastIntThree();

        void insertPointIntThree(Position ip,int pos);

        bool expandPol(int myId, vector<ProbPolFusion*> actualSol, vector<ProbPolFusion*> &bifProbPolFusion,Decimal linThr, map <int, vector<Pose> > *likelihood, vector <int> activeLikelihoods,Pose &myPose);

        bool expandPolOpt(int myId, vector<ProbPolFusion*> actualSol, vector<ProbPolFusion*> &bifProbPolFusion,Decimal linThr, map <int, vector<Pose> > *likelihood, vector <int> activeLikelihoods,Pose &myPose,int &maxBifSize);

        bool expandPolNoIn(int myId, vector<ProbPolFusion*> actualSol, vector<ProbPolFusion*> &bifProbPolFusion,Decimal linThr, map <int, vector<Pose> > *likelihood, vector <int> activeLikelihoods,Pose &myPose,int &maxBifSize);

        //bool checkBif(ProbMultiRegCamSol* &mrcsols,PosId vertex,Decimal thr,int myId){
        bool checkBif(PosId vertex,Decimal thr,int myId);

        string print(int opt=0);

        ProbPolFusion& operator=(ProbPolFusion &A);

        Decimal computeProbability(Pose measure, int id, map <int, vector<Pose> > * &likelihood);

        void setRatingVertex(int rating);

        int getRatingVertex();

        void growRatingVertex();

        void decreaseRatingVertex();

        void setRatingInThree(int rating);

        int getRatingInThree();

        void growRatingInThree();

        void decreaseRatingInThree();

        void setIntFourNum(int pos, int val);

        int getIntFourNum(int pos);

        int getLastIntFourNum();

        void deleteLastIntFourNum();


        void selectScale(Decimal &bestScale, Decimal &bestProb, map <int, vector<Pose> > * &likelihood, vector <int> &activeLikelihoods,vector<int> &idsV,Pose &myPose);

        void setExpandMethod(int expMth);
    };

}

#endif