egs_dynamic_shape.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ dynamic shape 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:          Reid Townson
#
#  Contributors:
#
###############################################################################
*/
 
 
#ifndef EGS_DYNAMIC_SHAPE_
#define EGS_DYNAMIC_SHAPE_
 
#include "egs_shapes.h"
#include "egs_rndm.h"
#include "egs_application.h"
 
#ifdef WIN32
 
    #ifdef BUILD_DYNAMIC_SHAPE_DLL
        #define EGS_DYNAMIC_SHAPE_EXPORT __declspec(dllexport)
    #else
        #define EGS_DYNAMIC_SHAPE_EXPORT __declspec(dllimport)
    #endif
    #define EGS_DYNAMIC_SHAPE_LOCAL
 
#else
 
    #ifdef HAVE_VISIBILITY
        #define EGS_DYNAMIC_SHAPE_EXPORT __attribute__ ((visibility ("default")))
        #define EGS_DYNAMIC_SHAPE_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define EGS_DYNAMIC_SHAPE_EXPORT
        #define EGS_DYNAMIC_SHAPE_LOCAL
    #endif
 
#endif
 
class EGS_DYNAMIC_SHAPE_EXPORT EGS_DynamicShape : public EGS_BaseShape {
 
public:
 
    EGS_DynamicShape(EGS_BaseShape *Shape, EGS_Input *dyninp, const string &Name="",EGS_ObjectFactory *f=0) :
        EGS_BaseShape(Name,f), shape(Shape) {
        if (shape) {
            shape->ref();
            otype = "dynamic ";
            otype += shape->getObjectType();
        }
        else {
            otype = "Invalid DynamicShape";
        }
 
        // Build dynamic shape is where many of the geometry attributes (including control points) are extracted
        buildDynamicShape(dyninp);
 
        if (cpts.size() < 2) {
            egsWarning("DynamicShape: not enough or missing control points.\n");
        }
        else {
            if (cpts[0].time > 0.0) {
                egsWarning("DynamicShape: time index of control point 1 > 0.0.  This will generate many warning messages.\n");
            }
            int npts = cpts.size();
            for (int i=0; i<npts; i++) {
                if (i>0 && cpts[i].time < cpts[i-1].time-epsilon) {
                    egsWarning("DynamicShape: time index of control point %i < time index of control point %i\n",i,i-1);
                }
                if (cpts[i].time<0.0) {
                    egsWarning("DynamicShape: time index of control point %i < 0.0\n",i);
                }
            }
 
            // Normalize time values
            for (int i=0; i<npts-1; i++) {
                cpts[i].time /= cpts[npts-1].time;
            }
        }
    };
 
    ~EGS_DynamicShape() {
        EGS_Object::deleteObject(shape);
    };
 
    EGS_Vector getPoint(EGS_RandomGenerator *rndm) {
        EGS_Vector v(shape->getPoint(rndm));
        return v;
    };
 
    EGS_Vector getRandomPoint(EGS_RandomGenerator *rndm) {
        getNextShapePosition(rndm);
        return shape->getRandomPoint(rndm);
    };
 
    struct EGS_ControlPoint {
        EGS_Float time;     
        vector<EGS_Float> trnsl; 
        vector<EGS_Float> rot;   
    };
 
    void getPointSourceDirection(const EGS_Vector &Xo,
                                 EGS_RandomGenerator *rndm, EGS_Vector &u, EGS_Float &wt) {
        if (shape->supportsDirectionMethod()) {
            getNextShapePosition(rndm);
            shape->getPointSourceDirection(Xo, rndm, u, wt);
        }
    }
 
protected:
 
    EGS_BaseShape  *shape;    
 
    vector<EGS_ControlPoint> cpts; 
 
    int ncpts; 
 
    EGS_Float ptime; 
 
    void getNextShapePosition(EGS_RandomGenerator *rndm);
 
    void containsDynamic(bool &hasdynamic) {
        hasdynamic = true;
    }
 
    bool supportsDirectionMethod() const {
        return shape->supportsDirectionMethod();
    }
 
    int getCoord(EGS_Float rand, EGS_ControlPoint &gipt);
 
    void buildDynamicShape(EGS_Input *dyninp);
 
};
 
#endif