fish/interpolatedvector/InterpolatedVector.cpp

#include <ocean/GLvish/VRenderObject.hpp>
#include <fish/lakeview/bone/FishSlice.hpp>
#include <fish/lakeview/bone/FishField.hpp>

#include <field/DirectProductArray.hpp>
#include <ocean/GLvish/BoundingBox.hpp>

#include <fish/fiber/vector/Interpolate.hpp>
#include <fish/fiber/vector/LinearIpol.hpp>

using namespace Wizt;
using namespace Fiber;


class InterpolatedVector : public virtual VRenderObject,  public virtual Fish<Slice>, public virtual Fish<Field>
{
public:
        typedef MemArray<3, Eagle::tvector3>           VectorArray_t; 
        typedef MemArray<3, Eagle::point3>             CoordsArray_t; 
        typedef DirectProductMemArray<Eagle::point3>   ProceduralArray_t; 


        TypedSlot<double> LineLength;
        TypedSlot<int>    LineWidth;

        TypedSlot<double> X,
                          Y,
                          Z;

        // Inner class to save local state Information. Besides the control parameters also 
        // pointers to the vector and coordinate data are saved here.
        struct  MyState : State
        {
                double line_length;
                double line_width;
                RefPtr<Field> Coords,
                              Vectors;
                double x, y, z;
                tvector vec;
                point pos;

                bool changed( const double ll, const int lw, const double xx, const double yy, const double zz)
                {
                        if ( ll != line_length || lw != line_width || xx != x || yy != y || zz != z)
                                return true; 
                        return false;
                }
                
                void update( const double ll, const int lw, const double xx, const double yy, const double zz)
                {
                        line_length = ll; 
                        line_width  = lw; 
                        x = xx; 
                        y = yy; 
                        z = zz;
                }
        };

        override RefPtr<State> newState() const
        {
                return new MyState();
        }



        InterpolatedVector(const string&name, int p, const RefPtr<VCreationPreferences>&VP)
        : VRenderObject(name, p, VP)
        , Fish<VObject>(this)
        , Fish<Field>("datafield")
        , LineLength(this, "LineLength", 0.1)
        , LineWidth(this, "LineWidth", 1)
        , X(this, "X", 0.0)
        , Y(this, "Y", 0.0)
        , Z(this, "Z", 0.0)
        {
                LineLength.setProperty("max", 10.0); 
                LineWidth.setProperty("max", 10); 
                X.setProperty("max", 1.0); 
                Y.setProperty("max", 1.0); 
                Z.setProperty("max", 1.0); 

                acceptType<Eagle::tvector3>();
        }


        override bool update( VRequest&R, double precision );
        override void render( VRenderContext&R ) const;
};



bool InterpolatedVector::update( VRequest&R, double precision )
{
        printf("InterpolatedVector::update(): updating\n"); 

FieldSelector FS = getFieldSelector(R);

// get the grid of the fiber bundle 
RefPtr<Grid>  G = FS.GridSource();
        if (!G)
        {
                if (RefPtr<MyState> S = getState(R) )
                        {
                                S-> Coords = NullPtr(); 
                                S-> Vectors = NullPtr();
                        } 
                return true;
        } 

// get the coordinates of the grid
RefPtr<Field> Coords  = G->CartesianPositions(); 
        if (!Coords)  { puts("InterpolatedVector::update(): No coord field!"); return true; } 


// get the vector data of the grid      
RefPtr<Field> Vectors = FS.getField() ; 
        if (!Vectors) { puts("InterpolatedVector::update(): No vector field!"); return true; } 


// get the actual state object
RefPtr<MyState> S = myState(R); 

        assert(S); 

        // save coordinates and vector data into the state 
        S -> Coords = Coords; 
        S -> Vectors = Vectors; 

        RefPtr<VectorArray_t> Vctrs = Vectors->getData(); 

        if( !Vctrs)
        {
                printf("InterpolatedVector::update(): Could get vector field data yet!\n"); 
                return false;
        } 
        else
                printf("InterpolatedVector::update(): Gotvector field data!\n"); 

        RefPtr<ProceduralArray_t>   PCrds = Coords->getData(); 
        RefPtr<CoordsArray_t>       Crds  = Coords->getData(); 
        if (!(Crds || PCrds))
                {
                        printf("InterpolatedVector::update(): Did not find any coordinates :  %s\n",
                               Typename( Coords->getType() ).c_str() ); 
                        return false;
                } 


// Now do the Interpolation of the Coordinates 

// Get index Range of Data (and Coordinates)
        MultiIndex<3> FieldSize = Vctrs->Size(); 


double x, y, z; 
point position; 
point vertex; 

// Get user specified position ranging from 0 to 1.0 in each coordinate covering the whole dataset 
        X << R >> x; 
        Y << R >> y; 
        Z << R >> z; 

// Clamp wrong inputs
        for (int i = 0; i < 3; i++)
        {
                if( position[i] < 0 )
                        position[i] = 0.0; 

                if( position[i] >= FieldSize[i] )
                        position[i] = FieldSize[i] - 1;
        } 

// Calculate float index for coordinates and data. (Unnormalize)
        position = x * FieldSize[0] - 1, y * FieldSize[1] -1 , z * FieldSize[2] - 1; 

point VoxelIntervalFloor; 
point VoxelIntervalCeil; 

tvector Unit[3];
Unit[0] = 1.0, 0.0, 0.0; 
Unit[1] = 0.0, 1.0, 0.0; 
Unit[2] = 0.0, 0.0, 1.0; 

tvector VoxelIntervalSpan; 

        MultiIndex<3> FloorIntervalIndex; 

        // Get index of lower coordinate 
        FloorIntervalIndex = (int)floor(position[0]), (int)floor(position[1]), (int)floor(position[2]); 

        if (PCrds) // found procedural coordinates
        {       
                // Get position at lower coordinate
                VoxelIntervalFloor = (*PCrds)[FloorIntervalIndex]; 
                // Increase index in each direction by 1
                FloorIntervalIndex[0]++; 
                FloorIntervalIndex[1]++; 
                FloorIntervalIndex[2]++; 
                // Get position at upper coordinate
                VoxelIntervalCeil  = (*PCrds)[FloorIntervalIndex]; 


        } 
        if (Crds)  // found numerical coordinates
        {
                // Get position at lower coordinate
                VoxelIntervalFloor = (*Crds)[FloorIntervalIndex]; 
                // Increase index in each direction by 1
                FloorIntervalIndex[0]++; 
                FloorIntervalIndex[1]++; 
                FloorIntervalIndex[2]++; 
                // Get position at lower coordinate
                VoxelIntervalCeil  = (*Crds)[FloorIntervalIndex];       
        } 

        // Calculate diagonal of voxel
        VoxelIntervalSpan = VoxelIntervalCeil - VoxelIntervalFloor; 


vertex = VoxelIntervalFloor; 

for(int i = 0; i<3; i++)
        {
                vertex += ( VoxelIntervalSpan[i] * (position[i] - FloorIntervalIndex[i])) * Unit[i]; 
        }

        S->pos = vertex;

Interpolate<3, tvector, LinearIpol<tvector> > VecField(*Vctrs, position); 

        S->vec = VecField.eval(); 


        

        return true;
}


void InterpolatedVector::render( VRenderContext& Context ) const
{



        //resetBBox(Context);

        printf("InterpolatedVector::render(): starting to render\n");
double line_length = 0.0; 
int line_width = 2; 
double x, y, z;

        LineLength << Context >> line_length; 
        LineWidth  << Context >> line_width; 

        if(line_width < 1)
                line_width = 1;
        X << Context >> x; 
        Y << Context >> y; 
        Z << Context >> z; 

        glEnable(GL_DEPTH_TEST); 
        glDisable(GL_LIGHTING); 

        // diplay list
        RefPtr<MyState>  state = myState(Context); 

        // return if no valid coord and vector data is available 
        if(!state)
        {
                printf("InterpolatedVector::render(): Invalid State!\n");
                return; 
        }
        if (!state->Coords)
        {
                printf("InterpolatedVector::render(): Invalid Coordinates!\n");
                return; 
        }
        if (!state->Vectors)
        {
                printf("InterpolatedVector::render(): Invalid Vectors!\n");
                return; 
        } 

        
        RefPtr<ValueSet> RenderParameterSpace = new ValueSet(); 
        RefPtr<DisplayList> DL; 
        try{
        DL = Context(*state)(this)( RenderParameterSpace ); 
        } 
        catch(...){}
        if (DL && !state->changed(line_length, line_width, x, y, z) )   //call display list if availlable
        {
                if(DL->call())
                {
                        printf("InterpolatedVector::render(): Called List\n");
                        return;
                } 
        } 
        else                                                   //prepare display list
        {
                DL = Context[*state][this][ RenderParameterSpace ]; 
                if (!DL) throw "InterpolatedVector::render() No Display List!?"; 

                state->update( line_length, line_width, x, y, z); 


                // Get the coordinates saved in actual state. 
                // They can come as procedural or numerical coordinates. 
                // Be prepared for both types, because they need different handling.
                RefPtr<ProceduralArray_t>   PCrds = state->Coords->getData(); 
                RefPtr<CoordsArray_t>       Crds  = state->Coords->getData(); 
                if (!(Crds || PCrds))
                {
                        printf("InterpolatedVector::render(): Did not find any coordinates :  %s\n",
                               Typename( state->Coords->getType() ).c_str() ); 
                        return;
                } 

                if (PCrds) // found procedural coordinates
                {
                point Start = PCrds->first(); 
                point End   = PCrds->last(); 
                        setBoundingBall(Context, new BoundingBox(Start, End) ); 
                        printf("InterpolatedVector::render(): got procedural coordinates\n" );
                } 
                if (Crds)  // found numerical coordinates
                {
                point Start = Crds->first(); 
                point End   = Crds->last(); 
                        setBoundingBall(Context, new BoundingBox(Start, End) ); 
                        printf("InterpolatedVector::render(): got numerical coordinates\n" ); 
                } 


//              // get vectors
//              RefPtr<VectorArray_t> Vctrs = state->Vectors->getData(); 
//              if (!Vctrs)
//              {
//                      printf("InterpolatedVector::render(): No vectors\n" ); 
//                      return;
//              } 
//              else
//                      printf("InterpolatedVector::render(): got Vectors data\n" ); 


//      // create a Multiindex for traversing coordinate and vector data. 
//      MultiIndex<3> M; 


        glCompile( *DL ) 
                {
                        glLineWidth(line_width); 
                        glBegin(GL_LINES); 
                        glColor3f(z, 0.0, x); 
                        glVertex(state->pos); 
                        glColor3f(1-z, 0.0, 1-x);
                        glVertex(state->pos + state->vec * line_length); 
                        glEnd();
//                      printf("InterpolatedVector::render(): compiling new list\n");
//                      glLineWidth(line_width); 
//                      glBegin(GL_LINES); 
//                      glColor3f(1.0,1.0,1.0); 

//                      do
//                      {
//                      point Vertex; 

//                              if (Crds) // get numerical coordinate
//                              {
//                                      Vertex = (*Crds)[M];
//                              }
//                              else      // get procedural coordinate
//                              {
//                                      Vertex = (*PCrds)[M];
//                              } 

//                              // get vector of same index as according coordinate, should always be consistent!
//                      tvector Vector = (*Vctrs)[M]; 
//                              //Vector.normalize(); 
//                              //glColor3f(norm(Vector)*line_length, 1, 1); 
//                              glVertex(Vertex); 
//                              glVertex(Vertex + Vector * line_length); 

//                              //embrace( Context, Vertex );
//                      }
//                      while( M.inc( (*Vctrs).Size()  ) ); // proceed to new Multiindex 
                        
//                      glEnd();
 
                } 

        //closeBBox(Context);
        }

}


static Ref<VCreator<InterpolatedVector, AcceptList<Fiber::BundlePtr> > > myCreator("Tutorial/InterpolatedVector");

VISH_DEFAULT_INIT

---