VectorFieldLines.cpp

This is tutorial demostrates how to access a vector field to draw some openGL lines. For accessing the data the fiber data model is used, which is located in vish's fish (= Fiber Vish). You should be familiar with VRenderObject and the use of display lists in vish.

To see the VectorFieldLines module connected to the CouetteFlow start it by using the .vis file.

../../../bin/vish VectorFieldLines.vis

There's an issue with updating at the beginning. So you have to move the mouse shortly over the LineLength QTWidget or change the value, before you can see the lines in the viewer.

See also:

Required tutorials: - Simple3DObject.cpp - DisplayListObject.cpp - SimpleCoords.cpp

Further tutorials: - 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>

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

---