source: Swollen/include/swwreader.h @ 44

/*
  SWWReader

    A C++ class for reading PyVolution SWW files from within
    OpenSceneGraph.

    An SWW file is the visualization output of the pyVolution
    Shallow Water Wave equation solver.  SWW files contain bedslope
    geometry and a sequence of stages at known timesteps.  The
    internal format is NetCDF:

    netcdf demo.sww {
        dimensions:
            number_of_volumes = <integer> ;
            number_of_vertices = 3 ;
            number_of_points = <integer> ;
            number_of_timesteps = UNLIMITED ;
        variables:
            float x(number_of_points) ;
            float y(number_of_points) ;
            float z(number_of_points) ;
            int volumes(number_of_volumes, number_of_vertices) ;
            float time(number_of_timesteps) ;
            float stage(number_of_timesteps, number_of_points) ;


    Authored under contract to Geoscience Australia by:

            Darran Edmundson
            ANU Supercomputer Facility Vizlab
            Australian National University
            Canberra, ACT 2600

    copyright (C) 2004 Geoscience Australia
*/

#ifndef SWWREADER_H
#define SWWREADER_H

#include <string>
#include <project.h>
#include <iostream>
#include <osg/Geometry>


// needed to create a .lib file under win32/Visual Studio
#if defined(_MSC_VER)
    #define SWWREADER_EXPORT   __declspec(dllexport)
#else
    #define SWWREADER_EXPORT
#endif


typedef std::vector<unsigned int> triangle_list;

class SWWREADER_EXPORT SWWReader
{

public:

    SWWReader(const std::string& filename);

    virtual bool isValid() {return _valid;}

    // bedslope
    virtual osg::ref_ptr<osg::Vec3Array> getBedslopeVertexArray() {return _bedslopevertices;}
    virtual osg::ref_ptr<osg::Vec3Array> getBedslopeNormalArray() {return _bedslopenormals;}
    virtual osg::ref_ptr<osg::UIntArray> getBedslopeIndexArray() {return _bedslopeindices;}
    virtual osg::ref_ptr<osg::Vec3Array> getBedslopeCentroidArray() {return _bedslopecentroids;}

    // stage
    virtual osg::ref_ptr<osg::Vec3Array> getStageVertexArray(unsigned int index);
    virtual osg::ref_ptr<osg::UIntArray> getStageIndexArray() {return _stageindices;}
    virtual osg::ref_ptr<osg::Vec3Array> getStageVertexNormalArray() {return _stagevertexnormals;}
    virtual osg::ref_ptr<osg::Vec3Array> getStagePrimitiveNormalArray() {return _stageprimitivenormals;}
    virtual osg::ref_ptr<osg::Vec3Array> getStageCentroidsArray() {return _stagecentroids;}
    virtual osg::ref_ptr<osg::Vec4Array> getStageColorArray() {return _stagecolors;}


    virtual float getTime(unsigned int index) {return *(_ptime+index);}
    virtual size_t getNumberOfVertices() {return _npoints;}
    virtual unsigned int getNumberOfTimesteps() {return _ntimesteps;}
    virtual int getNumberOfBedslopeIndices() {return _bedslopeindices->size();}
    virtual int getNumberOfStageIndices() {return _stageindices->size();}

    // stage culling
    virtual void toggleCullSetting();
    virtual float getCullNearZero() {return _cullnearzero;}
    virtual float getCullSteepAngle() {return _cullsteepangle;}
    virtual void setCullNearZero( float value ) {_cullnearzero = value; }
    virtual void setCullSteepAngle( float value ) {_cullsteepangle = value; }

    virtual triangle_list getConnectivity(unsigned int index) {return _connectivity.at(index);}


protected:

    virtual ~SWWReader();

    std::string* _filename;
    
    // constructor determines SWW validity (netcdf + proper structure)
    bool _valid;

    // netCDF file id
    int _ncid;

    // netcdf dimension ids
    int _nvolumesid, _nverticesid, _npointsid, _ntimestepsid;

    // netcdf dimension values
    size_t _nvolumes, _nvertices, _npoints, _ntimesteps;

    // netcdf variable ids
    int _xid, _yid, _zid, _volumesid, _timeid, _stageid;

    // netcdf variable values (allocated in constructor)
    float *_px, *_py, *_pz, *_ptime, *_pstage;
    unsigned int *_pvolumes;

    // fixed geometry
    osg::ref_ptr<osg::Vec3Array> _bedslopevertices;
    osg::ref_ptr<osg::Vec3Array> _bedslopenormals;
    osg::ref_ptr<osg::UIntArray> _bedslopeindices;
    osg::ref_ptr<osg::Vec3Array> _bedslopecentroids;

    // geometry that changes per timestep
    osg::ref_ptr<osg::Vec3Array> _stagevertices;
    osg::ref_ptr<osg::Vec3Array> _stageprimitivenormals;
    osg::ref_ptr<osg::UIntArray> _stageindices;
    osg::ref_ptr<osg::Vec3Array> _stagevertexnormals;
    osg::ref_ptr<osg::Vec3Array> _stagecentroids;
    osg::ref_ptr<osg::Vec4Array> _stagecolors;

    // bedslope vertex scale and shift factors (for normalizing to unit cube)
    float _xscale, _yscale, _zscale;
    float _xoffset, _yoffset, _zoffset;
    float _xcenter, _ycenter, _zcenter;

    // stack of return values from netcdf function calls
    std::vector<int> _status;

    // error checker (iterates through _status stack)
    bool _statusHasError();

    // triangle connectivity, list (indexed by vertex number) of 
    // lists (indices of triangles sharing this vertex)
    std::vector<triangle_list> _connectivity;

    // stage culling
    float _cullnearzero;
    float _cullsteepangle;
    enum cullstate { CULLALL, CULLNEARZERO, CULLSTEEPANGLE, CULLNONE };
    cullstate _cullsetting;

};

#endif  // SWWREADER_H