raster.h

// -*-C++-*-

#ifndef __RASTER_H
#define __RASTER_H

#include "mathlib.h"
#include "felib.h"

// =========================================================================
class STOASTLIB Raster {
public:
    Raster (const IVector &_bdim, const IVector &_gdim, Mesh *mesh,
        RDenseMatrix *bb = 0);

    virtual ~Raster();

    const int Dim() const {return dim; }

    const IVector &BDim() const { return bdim; }

    const IVector &GDim() const { return gdim; }

    const RVector &GSize() const { return bbsize; }

    inline int GLen() const { return glen; }

    inline int BLen() const { return blen; }

    inline int SLen() const { return slen; }

    inline const Mesh &mesh() const { return *meshptr; }

    inline int *Elref() const { return gelref; }

    inline int *BElref() const { return belref; }

    void BasisVoxelPositions (RDenseMatrix &pos) const;

    void SolutionVoxelPositions (RDenseMatrix &pos) const;

    virtual void Sample (const RVector &bvec, const IVector &grd, RVector &img)
    const;

    virtual double Value (const Point &p, int i) const;

    virtual double Value_nomask (const Point &p, int i, bool is_solidx=true)
    const = 0;

    virtual void Map_MeshToGrid (const RVector &mvec, RVector &gvec) const;

    virtual void Map_MeshToGrid (const CVector &mvec, CVector &gvec) const;

    virtual void Map_MeshToGrid (const Solution &msol, Solution &gsol,
        bool mapall = false) const;

    virtual void Map_GridToMesh (const RVector &gvec, RVector &mvec) const;

    virtual void Map_GridToMesh (const CVector &gvec, CVector &mvec) const;

    virtual void Map_GridToMesh (const Solution &gsol, Solution &msol,
    bool mapall = false) const;

    virtual void Map_GridToBasis (const RVector &gvec, RVector &bvec) const =0;

    virtual void Map_GridToBasis (const CVector &gvec, CVector &bvec) const =0;

    virtual void Map_GridToBasis (const Solution &gsol, Solution &bsol,
    bool mapall = false) const;

    virtual void Map_BasisToGrid (const RVector &bvec, RVector &gvec) const =0;

    virtual void Map_BasisToGrid (const CVector &bvec, CVector &gvec) const =0;

    virtual void Map_BasisToGrid (const Solution &bsol, Solution &gsol,
    bool mapall = false) const;

    virtual void Map_MeshToBasis (const RVector &mvec, RVector &bvec) const;

    virtual void Map_MeshToBasis (const CVector &mvec, CVector &bvec) const;

    virtual void Map_BasisToMesh (const RVector &bvec, RVector &mvec) const;

    virtual void Map_BasisToMesh (const CVector &bvec, CVector &mvec) const;

    virtual void Map_BasisToSol (const RVector &bvec, RVector &svec) const;

    virtual void Map_BasisToSol (const CVector &bvec, CVector &svec) const;

    virtual void Map_SolToBasis (const RVector &svec, RVector &bvec) const;

    virtual void Map_SolToBasis (const CVector &svec, CVector &bvec) const;

    virtual void Map_SolToBasis (const Solution &ssol, Solution &bsol,
    bool mapall = false) const;

    virtual void Map_SolToGrid (const RVector &svec, RVector &gvec) const;

    virtual void Map_SolToGrid (const CVector &svec, CVector &gvec) const;

    virtual void Map_GridToSol (const RVector &gvec, RVector &svec) const;

    virtual void Map_GridToSol (const CVector &gvec, CVector &svec) const;

    virtual void Map_SolToMesh (const RVector &svec, RVector &mvec) const;

    virtual void Map_SolToMesh (const CVector &svec, CVector &mvec) const;

    virtual void Map_SolToMesh (const Solution &ssol, Solution &msol,
    bool mapall = false ) const;

    // Mapping from active parameter vector to solution
    virtual void Map_ActiveSolToMesh (const RVector &asol, Solution &msol) const;

    virtual void Map_MeshToSol (const RVector &mvec, RVector &svec) const;

    virtual void Map_MeshToSol (const CVector &mvec, CVector &svec) const;

    virtual void Map_MeshToSol (const Solution &msol, Solution &ssol,
        bool mapall = false) const;

    inline const RGenericSparseMatrix &Mesh2GridMatrix()  const
    {   return *B; }

    virtual const RGenericSparseMatrix &Mesh2BasisMatrix() const
    {   ERROR_UNDEF;
    static RCompRowMatrix dummy;
    return dummy; }

    virtual const RGenericSparseMatrix &Basis2MeshMatrix() const
    {   ERROR_UNDEF;
    static RCompRowMatrix dummy;
    return dummy; }

    virtual int GetSolIdx (int basisidx) const;

    virtual int GetSolIdx (const IVector &crd) const;

    virtual int GetBasisIdx (int solidx) const;

    virtual void GetBasisIndices (int basisidx, IVector &crd) const;

    //virtual IVector &GetBasisIndices (int basisidx) const;

    virtual IVector &GetGridIndices (int grididx) const;

    inline int Basis2Sol (int i) const { return basis2sol[i]; }

    inline int Sol2Basis (int j) const { return sol2basis[j]; }

    void NeighbourGraph (idxtype *&rowptr, idxtype *&colidx, int &nzero) const;
    void NeighbourGraph (ICompRowMatrix &NG) const;
    IVector NeighbourShift (const ICompRowMatrix &NG, int i, int j) const;
    RVector RNeighbourShift (const ICompRowMatrix &NG, int i, int j) const;

    RVector SmoothImage (const RVector &x, double sd) const;

    RVector * ImageJet(const RVector &x, double sd, bool *iflags) const;

    RVector ImageGradient(const RVector &x, double sd) const;

protected:
    int dim;             
    IVector bdim;        
    IVector gdim;        
    int blen;            
    int glen;            
    int slen;            
    RVector bbsize;      
    Mesh *meshptr;       
    Point bbmin, bbmax;  
    int *belref;         
    int *gelref;         

    IVector paddim;      
    int padlen;          

    RVector bsupport;

    IVector basis2sol;

    IVector sol2basis;

    RGenericSparseMatrix *B;  
    RGenericSparseMatrix *BI; 
};

#endif // !__RASTER_H