fish/vectorfieldlines/VectorFieldLines.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>

using namespace Wizt;
using namespace Fiber;


class VectorFieldLines : public virtual VRenderObject,  virtual public Fish<Slice>, virtual public Fish<Field>
{
public:
        // Shortcut some Datatypes used to acess coordinate and vector data.
        // Note that coordinates can come procedural or numerical and need different 
        // data types to be handled.
        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;

        // 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;

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

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



        VectorFieldLines(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)
        {
                LineLength.setProperty("max", 10.0); 
                LineWidth.setProperty("max", 10); 

                acceptType<Eagle::tvector3>();
        }


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



bool VectorFieldLines::update( VRequest&R, double precision )
{
        printf("VectorFieldLines::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("VectorFieldLines::update(): No coord field!"); return true; } 


// get the vector data of the grid 
RefPtr<Field> Vectors = FS.getField() ;
        if (!Vectors) { puts("VectorFieldLines::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; 

        return true;
}


void VectorFieldLines::render( VRenderContext& Context ) const
{
        //resetBBox(Context);

        printf("VectorFieldLines::render(): starting to render\n");
double line_length = 0.0; 
int line_width = 2; 

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

        glEnable(GL_DEPTH_TEST); 
        glDisable(GL_LIGHTING); 

        // get current state
        RefPtr<MyState>  state = myState(Context); 

        // return if no valid coord and vector data is available 
        if(!state)
        {
                printf("VectorFieldLines::render(): Invalid State!\n");
                return; 
        }
        if (!state->Coords)
        {
                printf("VectorFieldLines::render(): Invalid Coordinates!\n");
                return; 
        }
        if (!state->Vectors)
        {
                printf("VectorFieldLines::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) )   //call display list if availlable
        {
                if(DL->call())
                {
                        printf("VectorFieldLines::render(): Called List\n");
                        return;
                } 
        } 
        else                                                   //prepare display list
        {
                DL = Context[*state][this][ RenderParameterSpace ]; 
                if (!DL) throw "VectorFieldLines::render() No Display List!?"; 

                state->update( line_length, line_width); 


                // 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("VectorFieldLines::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("VectorFieldLines::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("VectorFieldLines::render(): got numerical coordinates\n" ); 
                } 


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


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

        glCompile( *DL ) 
                {
                        printf("VectorFieldLines::render(): compiling new list\n");
                        glLineWidth(line_width); 
                        glBegin(GL_LINES); 
                        glColor3f(1.0,1.0,1.0); 

                        do
                        {
                        point Vertex, VertexTo; 

                                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]; 
                                VertexTo = Vertex + Vector * line_length;
                                //Vector.normalize(); 
                                //glColor3f(norm(Vector)*line_length, 1, 1); 
                                glVertex(Vertex); 
                                glVertex(VertexTo); 

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


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

VISH_DEFAULT_INIT

---