source: Swollen/include/swwreader.h @ 61

/*
  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::DrawElementsUShort> getBedslopeIndexArray() {return _bedslopeindices;}
    virtual osg::ref_ptr<osg::Vec3Array> getBedslopeCentroidArray() {return _bedslopecentroids;}
    virtual osg::ref_ptr<osg::Vec2Array> getBedslopeTextureCoords() {return _bedslopetexcoords;}

    // stage
    virtual osg::ref_ptr<osg::Vec3Array> getStageVertexArray(unsigned int index);
    virtual osg::ref_ptr<osg::Vec3Array> getStageVertexNormalArray() {return _stagevertexnormals;}
    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 float getAlphaMin() {return _alphamin;}    
    virtual float getAlphaMax() {return _alphamax;}    
    virtual float getHeightMin() {return _heightmin;}        
    virtual float getHeightMax() {return _heightmax;}            

    virtual void setAlphaMin( float value ) {_alphamin = value;}    
    virtual void setAlphaMax( float value ) {_alphamax = value;}        
    virtual void setHeightMin( float value ) {_heightmin = value;}     
    virtual void setHeightMax( float value ) {_heightmax = 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::DrawElementsUShort> _bedslopeindices;
    osg::ref_ptr<osg::Vec3Array> _bedslopecentroids;
    osg::ref_ptr<osg::Vec2Array> _bedslopetexcoords;

    // geometry that changes per timestep
    osg::ref_ptr<osg::Vec3Array> _stagevertices;
    osg::ref_ptr<osg::Vec3Array> _stageprimitivenormals;
    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, _scale;
    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;

    // define alpha (transparency) function
    float _alphamax, _alphamin, _heightmax, _heightmin;

};

#endif  // SWWREADER_H