Util.h

Go to the documentation of this file.

/*
 * This file is part of ALVAR, A Library for Virtual and Augmented Reality.
 *
 * Copyright 2007-2012 VTT Technical Research Centre of Finland
 *
 * Contact: VTT Augmented Reality Team <alvar.info@vtt.fi>
 *          <http://www.vtt.fi/multimedia/alvar.html>
 *
 * ALVAR is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library 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 Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with ALVAR; if not, see
 * <http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html>.
 */

#ifndef UTIL_H
#define UTIL_H

#include "Alvar.h"
#include "AlvarException.h"
#include <vector>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cxcore.h>
#include <cv.h>
#include <cmath> //for abs
#include <map>
#include <opencv2/calib3d/calib3d_c.h> //Compatibility with OpenCV 3.x

namespace alvar {

const double PI = 3.14159265;

template<class C> inline
int ALVAR_EXPORT Sign(const C& v)
{
        return (v<0?-1:1);
}

template<class C> inline
double ALVAR_EXPORT Rad2Deg(const C& v)
{
        return v*(180/PI);
}

template<class C> inline
double ALVAR_EXPORT Deg2Rad(const C& v)
{
        return v*(PI/180);
}

template<class C, class D = int> 
struct ALVAR_EXPORT Point : public C
{
        D val;

        Point(int vx=0, int vy=0)
        {
                C::x = vx;
                C::y = vy;
        }
        Point(double vx, double vy)
        {
                C::x = vx;
                C::y = vy;
        }
};

typedef ALVAR_EXPORT Point<CvPoint> PointInt;

typedef ALVAR_EXPORT Point<CvPoint2D64f> PointDouble;

template<class PointType>
double PointSquaredDistance(PointType p1, PointType p2) {
        return ((p1.x-p2.x)*(p1.x-p2.x)) +
                ((p1.y-p2.y)*(p1.y-p2.y));
}


//ttesis start


int ALVAR_EXPORT dot(CvPoint *A, CvPoint *B, CvPoint *C);

int ALVAR_EXPORT cross(CvPoint *A,CvPoint *B, CvPoint *C);


double ALVAR_EXPORT distance(CvPoint *A,CvPoint *B);

double ALVAR_EXPORT linePointDist(CvPoint *A,CvPoint *B,CvPoint *C, bool isSegment);


double ALVAR_EXPORT angle(CvPoint *A,CvPoint *B, CvPoint *C,CvPoint *D, int isDirectionDependent);


double ALVAR_EXPORT polyLinePointDist(CvPoint *PointList, int nPnts,CvPoint *C, int *index, int isClosedPolygon);

//ttesis end


void ALVAR_EXPORT FitCVEllipse(const std::vector<PointDouble> &points, CvBox2D& ellipse_box);

int ALVAR_EXPORT exp_filt2(std::vector<double> &v,std:: vector<double> &ret, bool clamp);

template<class C> inline
int ALVAR_EXPORT diff(const std::vector<C> &v, std::vector<C> &ret)
{       
        ret.clear();
        if (v.size() == 1) {
                ret.push_back(0);
        } else if (v.size() > 1) {
                ret.push_back(v.at(1)-v.at(0));
                for(size_t i = 1; i < v.size(); ++i)
                {
                        ret.push_back(v.at(i)-v.at(i-1));
                }
        }
        return int(ret.size());
}

int ALVAR_EXPORT find_zero_crossings(const std::vector<double>& v, std::vector<int> &corners, int offs = 20);

void ALVAR_EXPORT out_matrix(const CvMat *m, const char *name);

double ALVAR_EXPORT Limit(double val, double min_val, double max_val);

struct ALVAR_EXPORT Index {
        std::vector<int> val;
        Index(int a);
        Index(int a, int b);
        Index(int a, int b, int c);
        bool operator<(const Index &index) const;
};

class ALVAR_EXPORT Histogram {
protected:
        std::map<Index, int> bins;
        std::vector<int> dim_binsize;
        int DimIndex(int dim, double val);
        double DimVal(int dim, int index);
public:
        void AddDimension(int binsize);
        void Clear();
        void Inc(double dim0, double dim1=0, double dim2=0);
        int GetMax(double *dim0, double *dim1=0, double *dim2=0);
};

class ALVAR_EXPORT HistogramSubpixel : public Histogram {
protected:
        std::map<Index, double> acc_dim0;
        std::map<Index, double> acc_dim1;
        std::map<Index, double> acc_dim2;
public:
        void Clear();
        void Inc(double dim0, double dim1=0, double dim2=0);
        int GetMax(double *dim0, double *dim1=0, double *dim2=0);
};

#if (_MSC_VER >= 1400)
        inline void STRCPY(char *to, rsize_t size, const char *src) {
                strcpy_s(to,size,src);
        }
#else
        inline void STRCPY(char *to, size_t size, const char *src) {
                strncpy(to,src,size-1);
        }
#endif

#ifdef min
#undef min
#endif

#ifdef max
#undef max
#endif

class ALVAR_EXPORT Serialization {
protected:
        bool input;
        std::string filename;
        //std::iostream *stream;
        std::ios *stream;
        void *formatter_handle;
        bool Output();
        bool Input();
        bool Descend(const char *id);
        bool Ascend();
public:
        Serialization(std::string _filename);
        Serialization(std::basic_iostream<char> &_stream);
        Serialization(std::basic_istream<char> &_stream);
        Serialization(std::basic_ostream<char> &_stream);
        ~Serialization();
        template <class C>
        Serialization& operator<<(C &serializable) {
                input=false;
                if (!SerializeClass(serializable) || !Output()) {
                        throw(AlvarException("Serialization failure"));
                }
                return *this;
        }
        template <class C>
        Serialization& operator>>(C &serializable) {
                input=true;
                if (!Input() || !SerializeClass(serializable)) {
                        throw(AlvarException("Serialization failure"));
                }
                return *this;
        }
        template <class C>
        bool SerializeClass(C &serializable) {
                std::string s = serializable.SerializeId();
                if (!Descend(s.c_str()) || !serializable.Serialize(this) || !Ascend()) {
                        return false;
                }
                return true;
        }
        bool Serialize(int &data, const std::string &name);
        bool Serialize(unsigned short &data, const std::string &name);
        bool Serialize(unsigned long &data, const std::string &name);
        bool Serialize(double &data, const std::string &name);
        bool Serialize(std::string &data, const std::string &name);
        bool Serialize(CvMat &data, const std::string &name);
        bool IsInput() { return input; }
};

} // namespace alvar

#endif