egs_projectors.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ projectors headers
#  Copyright (C) 2015 National Research Council Canada
#
#  This file is part of EGSnrc.
#
#  EGSnrc is free software: you can redistribute it and/or modify it under
#  the terms of the GNU Affero General Public License as published by the
#  Free Software Foundation, either version 3 of the License, or (at your
#  option) any later version.
#
#  EGSnrc 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 Affero General Public License for
#  more details.
#
#  You should have received a copy of the GNU Affero General Public License
#  along with EGSnrc. If not, see <http://www.gnu.org/licenses/>.
#
###############################################################################
#
#  Author:          Iwan Kawrakow, 2005
#
#  Contributors:    Reid Townson
#
###############################################################################
*/


#ifndef EGS_PROJECTORS_
#define EGS_PROJECTORS_

#include "egs_vector.h"
#include "egs_math.h"

#include <string>
using namespace std;

class EGS_EXPORT EGS_2DVector {
public:
    EGS_Float x, y;
    EGS_2DVector() : x(0), y(0) {};
    EGS_2DVector(EGS_Float X, EGS_Float Y) : x(X), y(Y) {};
    EGS_2DVector(const EGS_2DVector &v) : x(v.x), y(v.y) {};
    EGS_2DVector &operator=(const EGS_Vector &v) {
        x = v.x;
        y = v.y;
        return *this;
    };
    EGS_2DVector operator+(const EGS_2DVector &v) const {
        return EGS_2DVector(x+v.x, y+v.y);
    };
    EGS_2DVector &operator+=(const EGS_2DVector &v) {
        x += v.x;
        y += v.y;
        return *this;
    };
    EGS_2DVector operator-(const EGS_2DVector &v) const {
        return EGS_2DVector(x-v.x, y-v.y);
    };
    EGS_2DVector &operator-=(const EGS_2DVector &v) {
        x -= v.x;
        y -= v.y;
        return *this;
    };
    EGS_2DVector operator*(const EGS_Float f) const {
        return EGS_2DVector(x*f,y*f);
    };
    EGS_2DVector &operator*=(const EGS_Float f) {
        x*=f;
        y*=f;
        return *this;
    };
    EGS_Float operator*(const EGS_2DVector &v) const {
        return x*v.x + y*v.y;
    };
    EGS_Float operator%(const EGS_2DVector &v) const {
        return x*v.y - y*v.x;
    };
    EGS_Vector crossProduct(const EGS_2DVector &v) const {
        return EGS_Vector(0,0,x*v.y - y*v.x);
    };
    EGS_Float length() const {
        return sqrt(x*x+y*y);
    };
    EGS_Float length2() const {
        return x*x+y*y;
    };
    void normalize() {
        EGS_Float tmp=1./length();
        x*=tmp;
        y*=tmp;
    };
};


class EGS_EXPORT EGS_XProjector {
public:
    EGS_XProjector(const string &Type) : type(Type) {};
    EGS_Float operator*(const EGS_Vector &x) const {
        return x.x;
    };
    EGS_Vector operator*(EGS_Float t) const {
        return EGS_Vector(t,0,0);
    };
    EGS_Float length() const {
        return 1;
    };
    EGS_2DVector getProjection(const EGS_Vector &x) const {
        return EGS_2DVector(x.y,x.z);
    };
    EGS_Float distance(const EGS_Vector &x) const {
        return x.x;
    }
    const string &getType() const {
        return type;
    };
    void printInfo() const {};
    EGS_Vector normal() const {
        return EGS_Vector(1,0,0);
    };
    EGS_Vector normal(const EGS_2DVector &x) const {
        return EGS_Vector(0,x.x,x.y);
    };
    EGS_Vector getPoint(const EGS_2DVector &x) const {
        return normal(x);
    };
private:
    string type;
};

class EGS_EXPORT EGS_YProjector {
public:
    EGS_YProjector(const string &Type) : type(Type) {};
    EGS_Float operator*(const EGS_Vector &x) const {
        return x.y;
    };
    EGS_Vector operator*(EGS_Float t) const {
        return EGS_Vector(0,t,0);
    };
    EGS_Float length() const {
        return 1;
    };
    EGS_2DVector getProjection(const EGS_Vector &x) const {
        return EGS_2DVector(x.x,x.z);
    };
    EGS_Float distance(const EGS_Vector &x) const {
        return x.y;
    }
    const string &getType() const {
        return type;
    };
    void printInfo() const {};
    EGS_Vector normal() const {
        return EGS_Vector(0,1,0);
    };
    EGS_Vector normal(const EGS_2DVector &x) const {
        return EGS_Vector(x.x,0,x.y);
    };
    EGS_Vector getPoint(const EGS_2DVector &x) const {
        return normal(x);
    };
private:
    string type;
};

class EGS_EXPORT EGS_ZProjector {
public:
    EGS_ZProjector(const string &Type) : type(Type) {};
    EGS_Float operator*(const EGS_Vector &x) const {
        return x.z;
    };
    EGS_Vector operator*(EGS_Float t) const {
        return EGS_Vector(0,0,t);
    };
    EGS_Float length() const {
        return 1;
    };
    EGS_2DVector getProjection(const EGS_Vector &x) const {
        return EGS_2DVector(x.x,x.y);
    };
    EGS_Float distance(const EGS_Vector &x) const {
        return x.z;
    }
    const string &getType() const {
        return type;
    };
    void printInfo() const {};
    EGS_Vector normal() const {
        return EGS_Vector(0,0,1);
    };
    EGS_Vector normal(const EGS_2DVector &x) const {
        return EGS_Vector(x.x,x.y,0);
    };
    EGS_Vector getPoint(const EGS_2DVector &x) const {
        return normal(x);
    };
private:
    string type;
};

class EGS_EXPORT EGS_Projector {
public:
    EGS_Projector(const EGS_Vector &A, const string &Type);

    EGS_Projector(const EGS_Vector &x1, const EGS_Vector &x2,
                  const EGS_Vector &x3, const string &Type);

    EGS_Float operator*(const EGS_Vector &x) const {
        return a*x;
    };

    EGS_Vector operator*(EGS_Float t) const {
        return a*t;
    };

    EGS_Float length() const {
        return norm;
    };

    EGS_2DVector getProjection(const EGS_Vector &x) const {
        EGS_Vector proj = x-distance(x)*normal();
        return EGS_2DVector(proj.x, proj.y);
    };

    EGS_Float distance(const EGS_Vector &x) const {
        return x*a-d;
    }

    const string &getType() const {
        return type;
    };

    void printInfo() const;

    EGS_Vector normal() const {
        return a;
    };

    EGS_Vector normal(const EGS_2DVector &x) const {
        return v1*x.x + v2*x.y;
    };

    EGS_Vector getPoint(const EGS_2DVector &x) const {
        return xo + v1*x.x + v2*x.y;
    };
private:
    EGS_Vector a;         
    EGS_Vector xo;        
    EGS_Vector v1,v2;     
    EGS_Float  norm;      
    EGS_Float  d;         
    string type;          
};

#endif