UniGridMapper.hpp

#ifndef __UNIGRIDMAPPER_HPP
#define __UNIGRIDMAPPER_HPP
 
#include <aerie/BoundingBox.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <eagle/QuadraticMatrix.hpp>
 
#include <field/UniformCartesianArray.hpp>
 
#include <fish/fiber/vector/Interpolate.hpp>
#include <fish/fiber/vector/LinearIpol.hpp>
 
#include <memcore/RefPtr.hpp>
 
#include "gridopDllApi.h"
 
using namespace Fiber;
using namespace Eagle;
using namespace std;
 
using namespace Eagle::PhysicalSpace;
 
 
class   gridop_API UniGridMapper : public ReferenceBase<UniGridMapper>
{
        typedef MemArray<3, point> CoordsArray_t;
        typedef MemArray<3, tvector> TVectorArray_t;
        typedef std::list<MultiIndex<3> > IndexList_t;
        typedef MemArray<3, IndexList_t > IndexListArray_t;
 
//      typedef LinearDirectProductMemArray<Eagle::point3>   ProcArray_t;
 
        RefPtr<IndexListArray_t>        CurviIndexList;
        RefPtr<UniformCartesianArray>   UniGridCoords;
        RefPtr<CoordsArray_t>           CurviCoords;
 
        RefPtr<BoundingBox>        BBox;
 
        double                  prec;
        tvector                 cell_len;
        MultiIndex<3>           res, ix, iy, iz;
 
        int     MaxListSize;
 
        // used for the correction of 'bad' points by EpsilonPreventer
        struct DistPoint_t
        {
                double dist;
                point uvw;
                MultiIndex<3> self;
        };
 
public:
        UniGridMapper(const RefPtr<CoordsArray_t>&_CurviCoords, const double res_scale = 1.0, const double prec_scale = 1.0);
 
        int     MaximalCurvicellPerUnicell() const
        {
                return MaxListSize;
        }
 
 
static  inline double avg(const double a, const double b)
        {
                return (a+b)/2;
        }
 
static  inline void clampRange(point&p, const double min, const double max)
        {
                for(unsigned i = 0; i < 3; i++)
                {
                        p[i] = ( p[i] < min) ? min : p[i];
                        p[i] = ( p[i] > max) ? max : p[i];
                }
        }
 
static  inline bool uvwInRange2( point& u, const MultiIndex<3>&it, const MultiIndex<3>&max, const double prec)
        {
                if( u[0] >= it[0] && u[0] <= it[0]+1 &&
                    u[1] >= it[1] && u[1] <= it[1]+1 &&
                    u[2] >= it[2] && u[2] <= it[2]+1    )
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }
 
static  inline bool localPointToIndex(const point&p, MultiIndex<3>&cc)
        {
                if(p[0] >= 0.0 && p[1] >= 0.0 && p[2] >= 0.0)
                {
                        cc[0] = unsigned(floor(p[0]));
                        cc[1] = unsigned(floor(p[1]));
                        cc[2] = unsigned(floor(p[2]));
                        return true;
                }
                return false;
        }
 
 
        MultiIndex<3>  Size() const                            { return CurviIndexList->Size();}
 
        point          operator[](const MultiIndex<3>&m) const { return (*UniGridCoords)[m];   }
 
        IndexList_t&   operator()(const MultiIndex<3>&m) const { return (*CurviIndexList)[m];   }
        RefPtr<CoordsArray_t> getCurviCoords() const           { return  CurviCoords;           }
        RefPtr<UniformCartesianArray> getUniCoords() const      { return  UniGridCoords;        }
 
        point          getMin()                                { return BBox->mincoord();      }
 
        point          getMax()                                { return BBox->maxcoord();      }
 
 
        bool     add( MultiIndex<3>& curvi_i );
 
        bool     inUniCell(const point&p, MultiIndex<3>&index );
 
        bool     curviCells(const point&p, IndexList_t&list);
 
        unsigned localCellCoordinatesFromCurviGrid(const point&p, point&uvw, double grid_epsilon = 0.0);
 
        bool     localCellCoordinatesFromCell(point&uvw, const point&P, MultiIndex<3>&it,const CoordsArray_t&Data, const MultiIndex<3>&max,const double prec);
 
         // do it projectively instead of iteratively
        unsigned localCellCoordinatesFromCurviGridProjective(const point&p, point&uvw, const double& grid_epsilon );
 
};
 
 
 
#endif // __UNIGRIDMAPPER_HPP