Pos.h

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

This program 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 2 of the License, or
(at your option) any later version.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#ifndef __POS_H
#define __POS_H

#include <iostream>
#define _USE_MATH_DEFINES
#include <cmath>

#include "DMatrix.h"

template<unsigned int dims, class _t = int>
class Pos {
    _t pos[dims];
public:

    Pos() {
        for (unsigned int i=0;i<dims;i++) pos[i]=0;
    }
    
    explicit Pos(_t x0, _t x1, _t x2) {
        pos[0]=x0;
        pos[1]=x1;
        pos[2]=x2;
    }
    explicit Pos(_t x0, _t x1) {
        pos[0]=x0;
        pos[1]=x1;
    }
    explicit Pos(_t x0) {
        pos[0]=x0;
    }

    Pos(const Pos<dims,_t> &p) {
        for (unsigned int i=0;i<dims;i++) pos[i]=p.pos[i];
    }

    explicit Pos(const DMatrix<dims, 1> &d) {
        for (unsigned int i=0;i<dims;i++) pos[i]=d[i][0];
    }

    void Zero() {
        for (unsigned int i=0;i<dims;i++) {
            pos[i]=static_cast<_t>(0);
        }
    }
    
    _t& operator[] (unsigned int i) {
        return pos[i];
    }

    _t operator[] (unsigned int i) const {
        return pos[i];
    }

    Pos& operator = (const Pos<dims,_t> &p) {
        for (unsigned int i=0;i<dims;i++) pos[i]=p.pos[i];
        return *this;
    }

    Pos& operator += (const Pos<dims,_t> &p) {
        for (unsigned int i=0;i<dims;i++) pos[i]+=p.pos[i];
        return *this;
    }

    Pos& operator -= (const Pos<dims,_t> &p) {
        for (unsigned int i=0;i<dims;i++) pos[i]-=p.pos[i];
        return *this;
    }
    
    Pos& operator /= (const _t &skalar) {
        for (unsigned int i=0;i<dims;i++) pos[i]/=skalar;
        return *this;
    }

    Pos& operator *= (const _t &skalar) {
        for (unsigned int i=0;i<dims;i++) pos[i]*=skalar;
        return *this;
    }

    Pos operator + (const Pos<dims,_t> &p) const {
        Pos result;
        for (unsigned int i=0;i<dims;i++) result[i]=pos[i]+p.pos[i];
        return result;
    }

    Pos operator - (const Pos<dims,_t> &p) const {
        Pos result;
        for (unsigned int i=0;i<dims;i++) result[i]=pos[i]-p.pos[i];
        return result;
    }

    Pos operator * (const _t &skalar) const {
        Pos result;
        for (unsigned int i=0;i<dims;i++) result[i]=pos[i]*skalar;
        return result;
    }

    Pos operator / (const _t &skalar) const {
        Pos result;
        for (unsigned int i=0;i<dims;i++) result[i]=pos[i]/skalar;
        return result;
    }
    
    _t ScalProd (const Pos<dims,_t> &p) const {
        _t result=0;
        for (unsigned int i=0;i<dims;i++) result+=p[i]*pos[i];
        return result;
    }

    operator Pos<dims, double> () const {
        Pos<dims, double> result;
        for (unsigned int i=0;i<dims;i++) result[i]=pos[i];
        return result;
    }

    operator DMatrix<dims, 1> () const {
        DMatrix<dims, 1> result;
        for (unsigned int i=0;i<dims;i++) result[i][0]=pos[i];
        return result;
    }

    Pos& operator = (const DMatrix<dims, 1> &d) {
        for (unsigned int i=0;i<dims;i++) pos[i]=d[i][0];
        return *this;
    }
};



template<unsigned int dims, class _t>
bool operator == (const Pos<dims, _t> &a, const Pos<dims, _t> &b) {
    for (unsigned int i=0;i<dims;i++) if (a[i]!=b[i]) return false;
    return true;
}

template<unsigned int dims>
DMatrix<dims,1> operator * (const DMatrix<dims,dims> &a, const Pos<dims> &b) {
    DMatrix<dims,1> b2=b;
    return a * b2;
}


template<unsigned int dims, class _t>
std::ostream& operator << (std::ostream &o, const Pos<dims, _t> &p) {
    for (unsigned int i=0;i<dims;i++) {
        o << p[i];
        if (i+1<dims) o << " ";
    }
    return o;
}

template<unsigned int dims, class _t>
std::istream& operator >> (std::istream &in, Pos<dims, _t> &p) {
    for (unsigned int i=0;i<dims;i++) {
        in >> p[i];
    }
    return in;
}

template<unsigned int dims>
double Len(const Pos<dims, double> &p) {
    double result=0;
    for (unsigned int i=0;i<dims;i++) {
        result+=p[i]*p[i];
    }
#if MSC_VER<700
    return sqrt(result);
#else
    return std::sqrt(result);
#endif
}

template<unsigned int dims>
float Len(const Pos<dims, float> &p) {
    float result=0;
    for (unsigned int i=0;i<dims;i++) {
        result+=p[i]*p[i];
    }
#if MSC_VER<700
    return sqrt(result);
#else
    return std::sqrt(result);
#endif
}

template<unsigned int dims>
double Len(const Pos<dims, int> &p) {
    double result=0;
    for (unsigned int i=0;i<dims;i++) {
        result+=p[i]*p[i];
    }
    return std::sqrt(result);
}

template<unsigned int dims, typename _t>
_t ScalProd(const Pos<dims, _t> &p1, const Pos<dims, _t> &p2) {
    _t result=0;
    for (unsigned int i=0;i<dims;i++) {
        result+=p1[i]*p2[i];
    }
    return result;
}


template<class _t>
bool Innerhalb(const Pos<4,_t> &rgn, const Pos<2,_t> &pos) {
    return pos[0]>=rgn[0] && pos[0]<=rgn[2] &&
        pos[1]>=rgn[1] && pos[1]<=rgn[3];
}

template<unsigned int dims, class _t>
void InitZero(Pos<dims,_t> &x) {
    x.Zero();
};

#endif