isolinerenderer.h

Go to the documentation of this file.

//************************************************************************
//                                                                      *
//           Copyright (C)  2014                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//
//  File:       isolinerenderer.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       March 2014
//
//  Description:    Definition of the IsolineRenderer class
//
#ifndef ISOLINERENDERER_H
#define ISOLINERENDERER_H

#include <GL/glew.h>
#ifdef Darwin
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#include "assert.h"
#include "renderer.h"
#include "isolineparams.h"
namespace VAPoR {

class DataMgr;
class RENDER_API IsolineRenderer : public Renderer
{

public:

    IsolineRenderer( Visualizer* , RenderParams*);
    ~IsolineRenderer();

    static Renderer* CreateInstance(Visualizer* v, RenderParams* rp) {
        return new IsolineRenderer(v,rp);
    }
    virtual int _initializeGL();
    virtual int     _paintGL(DataMgrV3_0* dmgr);
    virtual void setAllDataDirty() {invalidateCache();}
    void invalidateLineCache(int timestep);
    virtual void invalidateCache();
    bool cacheIsValid(int timestep) {return _cacheValidFlags[timestep];}

    int buildLineCache(DataMgrV3_0* dmgr);
    const std::map<pair<int,int>,vector<float*> >&  GetLineCache() {return _lineCache;}

private:
    void setupCache();
    void performRendering(size_t timestep);
    int edgeCode(int i, int j, float isoval, float* dataVals); 

    int addLineSegment(int timestep, int isoIndex, float x1, float y1, float x2, float y2);

    int numIsovalsInCache() {return _numIsovalsCached;}

    void addEdges(int segIndex, pair<int,int> edge1, pair<int,int> edge2);
    void traverseCurves(int iso);

    vector<float*>& getLineSegments(int timestep, int isoindex){
        pair<int,int> indexpair = make_pair(timestep,isoindex);
        return _lineCache[indexpair];
    }
    
    float interp_j(int i, int j, float isoval, float* dataVals){
        return ( -1. + 2.*(double)(j)/((double)_gridSize-1.) //y coordinate at (i,j)
        + 2./(double)(_gridSize -1.)  //y grid spacing
        *(isoval - dataVals[i+_gridSize*j])/(dataVals[i+_gridSize*(j+1)]-dataVals[i+_gridSize*j])); //ratio: 1 is iso at top, 0 if iso at bottom
    }
    float interp_i(int i, int j, float isoval, float* dataVals){
        return (-1. + 2.*(double)(i)/((double)_gridSize-1.) //x coordinate at (i,j)
        + 2./(double)(_gridSize -1.)  //x grid spacing
        *(isoval - dataVals[i+_gridSize*j])/(dataVals[i+1+_gridSize*(j)]-dataVals[i+_gridSize*j])); //ratio: 1 is iso at right, 0 if iso at left
    }
    void buildEdges(int isoval, float* dataVals, float missingVal);
    void attachAnnotation(int numcomponents, int iso);
#ifndef DOXYGEN_SKIP_THIS

    //for each timestep,there is a pair consisting of the isovalue index and a vector of 
    //4 floats (x1,y1,x2,y2) specifying
    //the two endpoints of an isoline segment that crosses a cell 
    std::map<pair<int,int>,vector<float*> > _lineCache;
    
    // cache valid flags indicate validity of cache at each time step.
    std::map<int,bool> _cacheValidFlags;
    //Each edge is represented as a pair (int, int).  Horizontal edges have both ints positive; vertical have both negative.
    //Vertical edges connecting grid vertices (i,j) and (i,j+1) are represented by the pair (-i, -j-1) (-i <=0; -j-1 < 0)
    //Horizontal edges connecting grid vertices (i,j) and (i+1,j) are represented by the pair (i+1,j) (i+1 > 0, j>=0)
    //
    
    // _lineCache maps pair<int,int>->vector<float[4]> maps a pair (timestep,isovalueIndex) to a vector of segment endpoints, with one segment for each line in the isoline
    //For each segment in the _lineCache, there are 5 temporary mappings:
    // prevEdge maps segments to edges.  Each segment is identified by (timestep, isoval, segmentIndex), corresponding edge is pair(int,int)
    // nextEdge is the same; map(int,int,int)->pair(int,int)
    // plus prevSegment maps prevEdge to segment; i.e. map (timestep, isoval, (int,int))-> segmentIndex
    // similarly nextSegment maps nextEdge to segment; i.e. map (timestep, isoval, (int,int))-> segmentIndex
    // plus forwardEdge maps (timestep,isoval,edge)-> edge
    // and backwardEdge maps (timestep,isoval,edge)-> edge
    
    std::map< pair<int,int>, int> _edgeSeg; //map an edge to a segment, to find 3d coords where edge is located
    
    std::map<pair<int,int>,pair<int,int> > _edgeEdge1; //map an edge to one adjacent edge;
    std::map<pair<int,int>,pair<int,int> > _edgeEdge2; //map an edge to other adjacent edge;
    std::map<pair<int,int>, bool> _markerBit;  //indicate whether or not an edge has been visited during current traversal
    vector<int> _componentLength;   //indicates the number of segments in a component.
    vector<pair<int,int> > _endEdge;  //indicates and ending edge for each component


    
    
    
    
    int _numIsovalsCached;
    int _gridSize;
    std::map<int,int> _objectNums;
#endif
};
};

#endif // ISOLINERENDERER_H