Changeset 1370 for trunk/packages


Ignore:
Timestamp:
Mar 28, 2009, 3:50:16 PM (16 years ago)
Author:
vrinside
Message:

improving the flow vis engine

  • particle advection for multiple vector field
  • specifying multiple advection planes
  • specifying the position of a particle injection plane
  • specifying the axis of a particle injection plane
  • specifying the visibility of particle injection planes
  • specifying the particle color for each particle injection plane
  • rendering device shapes

[NOTE] Currently, I commented out with the MACRO NEW_FLOW_ENGINE in config
To use this, please comment NEW_FLOW_ENGINE in

Location:
trunk/packages/vizservers/nanovis
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/packages/vizservers/nanovis/Command.cpp

    r1363 r1370  
    17681768                NanoVis::get_transfunc("default"));
    17691769
    1770     Trace("Flow Data move\n");
    17711770        float dx0 = -0.5;
    17721771        float dy0 = -0.5*volPtr->height/volPtr->width;
    … …  
    17971796    return (*proc) (cdata, interp, objc, objv);
    17981797}
     1798
     1799// INSOO
     1800// I got an compile error
     1801#ifndef SHRT_MAX
     1802#define SHRT_MAX 4096
     1803#endif
    17991804
    18001805static int
    … …  
    18321837        NanoVis::licRenderer->activate();
    18331838    }
    1834     if (NanoVis::particleRenderer) {
    1835         NanoVis::particleRenderer->activate();
     1839    if (NanoVis::flowVisRenderer) {
     1840        NanoVis::flowVisRenderer->activate();
    18361841    }
    18371842
    … …  
    18671872            NanoVis::licRenderer->convolve();
    18681873        }
    1869         if (NanoVis::particleRenderer &&
    1870             NanoVis::particleRenderer->isActivated()) {
    1871             NanoVis::particleRenderer->advect();
     1874        if (NanoVis::flowVisRenderer &&
     1875            NanoVis::flowVisRenderer->isActivated()) {
     1876            NanoVis::flowVisRenderer->advect();
    18721877        }
    18731878        NanoVis::offscreen_buffer_capture();  //enable offscreen render
    … …  
    18891894        NanoVis::licRenderer->deactivate();
    18901895    }
    1891     if (NanoVis::particleRenderer) {
    1892         NanoVis::particleRenderer->deactivate();
     1896    if (NanoVis::flowVisRenderer) {
     1897        NanoVis::flowVisRenderer->deactivate();
    18931898    }
    18941899    NanoVis::initParticle();
    … …  
    20462051        NanoVis::licRenderer->activate();
    20472052    }
    2048     if (!NanoVis::particleRenderer->isActivated()) {
    2049         NanoVis::particleRenderer->activate();
     2053    if (!NanoVis::flowVisRenderer->isActivated()) {
     2054        NanoVis::flowVisRenderer->activate();
    20502055    }
    20512056
    … …  
    20562061        NanoVis::licRenderer->convolve();
    20572062    }
    2058     NanoVis::particleRenderer->advect();
     2063    NanoVis::flowVisRenderer->advect();
    20592064    NanoVis::offscreen_buffer_capture();  //enable offscreen render
    20602065    NanoVis::display();
    … …  
    20842089        return TCL_ERROR;
    20852090    }
    2086     if (NanoVis::particleRenderer != NULL) {
    2087         NanoVis::particleRenderer->setVectorField(volPtr->id,
     2091    if (NanoVis::flowVisRenderer != NULL) {
     2092        // INSOO
     2093#ifndef NEW_FLOW_ENGINE
     2094        NanoVis::flowVisRenderer->setVectorField(volPtr->id,
    20882095            *(volPtr->get_location()),
    20892096            1.0f,
    … …  
    20912098            volPtr->depth  / (float)volPtr->width,
    20922099            volPtr->wAxis.max());
     2100#else
     2101
     2102        NanoVis::flowVisRenderer->addVectorField("vname", volPtr,
     2103            *(volPtr->get_location()),
     2104            1.0f,
     2105            volPtr->height / (float)volPtr->width,
     2106            volPtr->depth  / (float)volPtr->width,
     2107            volPtr->wAxis.max());
     2108#endif
    20932109        NanoVis::initParticle();
     2110
    20942111    }
    20952112    if (NanoVis::licRenderer != NULL) {
     2113        // INSOO
     2114        // TBD..
    20962115        NanoVis::licRenderer->setVectorField(volPtr->id,
    20972116            *(volPtr->get_location()),

  • trunk/packages/vizservers/nanovis/FlowCmds.cpp

    r1365 r1370  
    401401        return TCL_ERROR;
    402402    }
    403     if (NanoVis::particleRenderer != NULL) {
    404         NanoVis::particleRenderer->setVectorField(volPtr->id,
     403    if (NanoVis::flowVisRenderer != NULL) {
     404        NanoVis::flowVisRenderer->setVectorField(volPtr->id,
    405405            *(volPtr->get_location()),
    406406            1.0f,
    … …  
    773773        NanoVis::licRenderer->activate();
    774774    }
    775     if (!NanoVis::particleRenderer->isActivated()) {
    776         NanoVis::particleRenderer->activate();
     775    if (!NanoVis::flowVisRenderer->isActivated()) {
     776        NanoVis::flowVisRenderer->activate();
    777777    }
    778778
    … …  
    783783        NanoVis::licRenderer->convolve();
    784784    }
    785     NanoVis::particleRenderer->advect();
     785    NanoVis::flowVisRenderer->advect();
    786786    NanoVis::offscreen_buffer_capture();  //enable offscreen render
    787787    NanoVis::display();
    … …  
    837837        NanoVis::licRenderer->activate();
    838838    }
    839     if (NanoVis::particleRenderer) {
    840         NanoVis::particleRenderer->activate();
     839    if (NanoVis::flowVisRenderer) {
     840        NanoVis::flowVisRenderer->activate();
    841841    }
    842842
    … …  
    872872            NanoVis::licRenderer->convolve();
    873873        }
    874         if (NanoVis::particleRenderer &&
    875             NanoVis::particleRenderer->isActivated()) {
    876             NanoVis::particleRenderer->advect();
     874        if (NanoVis::flowVisRenderer &&
     875            NanoVis::flowVisRenderer->isActivated()) {
     876            NanoVis::flowVisRenderer->advect();
    877877        }
    878878        NanoVis::offscreen_buffer_capture();  //enable offscreen render
    … …  
    894894        NanoVis::licRenderer->deactivate();
    895895    }
    896     if (NanoVis::particleRenderer) {
    897         NanoVis::particleRenderer->deactivate();
     896    if (NanoVis::flowVisRenderer) {
     897        NanoVis::flowVisRenderer->deactivate();
    898898    }
    899899    NanoVis::initParticle();

  • trunk/packages/vizservers/nanovis/NvFlowVisRenderer.cpp

    r1369 r1370  
    3333        _psys_width = w;
    3434        _psys_height = h;
     35
     36/*
     37        licRenderer[0] = new NvLIC(NMESH, NPIX, NPIX, 0,
     38                                Vector3(0, 0, 0), g_context);
     39        licRenderer[1] = new NvLIC(NMESH, NPIX, NPIX, 1,
     40                                Vector3(0, 0, 0), g_context);
     41        licRenderer[2] = new NvLIC(NMESH, NPIX, NPIX, 2,
     42                                Vector3(0, 0, 0), g_context);
     43*/
    3544}
    3645
    … …  
    4251                delete (*iter).second;
    4352        }
     53
     54/*
     55        for (int i = 0; i < 3; ++i)
     56        {
     57                delete licRenderer[i];
     58        }
     59*/
    4460}
    4561
    … …  
    5167        {
    5268                (*iter).second->initialize();
     69        }
     70}
     71
     72void
     73NvFlowVisRenderer::reset()
     74{
     75        std::map<std::string, NvVectorField*>::iterator iter;
     76        for (iter = _vectorFieldMap.begin(); iter != _vectorFieldMap.end(); ++iter)
     77        {
     78                (*iter).second->reset();
    5379        }
    5480}

  • trunk/packages/vizservers/nanovis/NvFlowVisRenderer.h

    r1369 r1370  
    3434        bool _activated;
    3535
     36        //NvLIC* licRenderer[3];
    3637public:
    3738        NvFlowVisRenderer(int w, int h, CGcontext context);

  • trunk/packages/vizservers/nanovis/NvLIC.cpp

    r1319 r1370  
    4444    _activate(false)
    4545{
     46
    4647    axis = _axis;
    4748    slice_vector = new float[size*size*4];
    … …  
    302303NvLIC::convolve()
    303304{
     305    if (vectorFieldID == 0) return;
     306
    304307    int   i, j;
    305308    float x1, x2, y, px, py;
    … …  
    404407NvLIC::display()
    405408{
     409    if (vectorFieldID == 0) return;
     410
    406411    glBindTexture(GL_TEXTURE_2D, color_tex);
    407412    glEnable(GL_TEXTURE_2D);
    … …  
    491496    scale = Vector3(scaleX, scaleY, scaleZ);
    492497    this->max = max;
     498
     499    make_patterns();
    493500 
    494501    get_slice();
    … …  
    539546}
    540547
     548void NvLIC::reset()
     549{
     550    make_patterns();
     551}

  • trunk/packages/vizservers/nanovis/NvLIC.h

    r1311 r1370  
    105105
    106106    void setVectorField(unsigned int texID, const Vector3& ori, float scaleX, float scaleY, float scaleZ, float max);
     107
     108   void reset();
    107109};
    108110

  • trunk/packages/vizservers/nanovis/NvParticleRenderer.cpp

    r1362 r1370  
    2323#include "NvParticleRenderer.h"
    2424#include <Trace.h>
     25#include <stdlib.h>
    2526
    2627
    … …  
    3839    reborn = true;
    3940    flip = true;
     41
     42    _color.set(0.2, 0.2, 1.0, 1.0);
    4043    max_life = 500;
    4144
     45    _slice_axis = 0;
     46    _slice_pos = 0.0;
     47
    4248    data = (Particle*) malloc(w*h*sizeof(Particle));
     49    memset(data, 0, sizeof(Particle) * w * h);
    4350
    4451    m_vertex_array = new RenderVertexArray(psys_width*psys_height, 3, GL_FLOAT);
    … …  
    127134}
    128135
    129 void NvParticleRenderer::initialize(Particle* p)
    130 {
     136void NvParticleRenderer::initializeDataArray()
     137{
     138    size_t n = psys_width * psys_height * 4;
     139    memset(data, 0, sizeof(float)* n);
     140
     141    int index;
     142    bool particle;
     143    float* p = (float*) data;
     144    for (int i=0; i<psys_width; i++) {
     145        for (int j=0; j<psys_height; j++) {
     146            index = i + psys_height*j;
     147            particle = (rand() % 256) > 150;
     148            if(particle)
     149            {
     150                //assign any location (x,y,z) in range [0,1]
     151                switch (_slice_axis)
     152                {
     153                case 0 :
     154                        p[4*index] = _slice_pos;
     155                        p[4*index+1]= j/float(psys_height);
     156                        p[4*index+2]= i/float(psys_width);
     157                        break;
     158                case 1 :
     159                        p[4*index]= j/float(psys_height);
     160                        p[4*index+1] = _slice_pos;
     161                        p[4*index+2]= i/float(psys_width);
     162                        break;
     163                case 2 :
     164                        p[4*index]= j/float(psys_height);
     165                        p[4*index+1]= i/float(psys_width);
     166                        p[4*index+2] = _slice_pos;
     167                        break;
     168                default :
     169                        p[4*index] = 0;
     170                        p[4*index+1]= 0;
     171                        p[4*index+2]= 0;
     172                        p[4*index+3]= 0;
     173                }
     174               
     175                //shorter life span, quicker iterations
     176                p[4*index+3]= rand() / ((float) RAND_MAX) * 0.5  + 0.5f;
     177            }
     178            else
     179            {
     180                p[4*index] = 0;
     181                p[4*index+1]= 0;
     182                p[4*index+2]= 0;
     183                p[4*index+3]= 0;
     184            }
     185        }
     186    }
     187}
     188
     189void NvParticleRenderer::initialize()
     190{
     191    initializeDataArray();
     192
    131193    //also store the data on main memory for next initialization
    132     memcpy(data, p, psys_width*psys_height*sizeof(Particle));
     194    //memcpy(data, p, psys_width*psys_height*sizeof(Particle));
    133195
    134196    glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[0]);
    … …  
    136198#ifdef NV_32
    137199    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGBA32_NV,
    138                  psys_width, psys_height, 0, GL_RGBA, GL_FLOAT, (float*)p);
     200                 psys_width, psys_height, 0, GL_RGBA, GL_FLOAT, (float*)data);
    139201#else
    140202    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA, psys_width,
    141                  psys_height, 0, GL_RGBA, GL_FLOAT, (float*)p);
     203                 psys_height, 0, GL_RGBA, GL_FLOAT, (float*)data);
    142204#endif
    143205    glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
    … …  
    150212#ifdef NV_32
    151213    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGBA32_NV,
    152                  psys_width, psys_height, 0, GL_RGBA, GL_FLOAT, (float*)p);
     214                 psys_width, psys_height, 0, GL_RGBA, GL_FLOAT, (float*)data);
    153215#else
    154216    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA, psys_width, psys_height,
    … …  
    260322    if(psys_frame==max_life) {
    261323        psys_frame=0;
    262         reborn = true;
     324//      reborn = true;
    263325    }
    264326    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    … …  
    369431
    370432    glPointSize(1.2);
    371     glColor4f(.2,.2,.8,1.);
     433    //glColor4f(.2,.2,.8,1.);
     434    glColor4f(_color.x, _color.y, _color.z, _color.w);
    372435    glEnableClientState(GL_VERTEX_ARRAY);
    373436    m_vertex_array->SetPointer(0);
    … …  
    392455    _advectionShader->setVelocityVolume(texID, max);
    393456}
     457
     458void NvParticleRenderer::setAxis(int axis)
     459{
     460        _slice_axis = axis;
     461        initializeDataArray();
     462}
     463
     464void NvParticleRenderer::setPos(float pos)
     465{
     466        _slice_pos = pos;
     467        initializeDataArray();
     468}
     469
     470

  • trunk/packages/vizservers/nanovis/NvParticleRenderer.h

    r1333 r1370  
    4242  Particle(float _x, float _y, float _z, float _life) :
    4343   x(_x), y(_y), z(_z), aux(_life){}
    44 };
    45 
    46 struct ParticleInitSlice {
    47   int slice_id;
    48   int slice_axis;
    49   float slice_pos;
    50   bool enabled;
    5144};
    5245
    … …  
    9790    NvParticleAdvectionShader* _advectionShader;
    9891
    99     std::vector<ParticleInitSlice> _initSliceArray;
    100 
    10192    /**
    10293     * @brief scale of flow data
    … …  
    10899    bool _activate;
    109100
     101    float _slice_pos;
     102    int _slice_axis;
     103    Vector4 _color;
     104
     105
    110106public:
    111107    int psys_width;     //the storage of particles is implemented as a 2D array.
    … …  
    115111    ~NvParticleRenderer();
    116112    void setVectorField(unsigned int texID, const Vector3& ori, float scaleX, float scaleY, float scaleZ, float max);
    117     void initialize(Particle* data);
     113    void initialize();
    118114    void advect();
    119115    void update_vertex_buffer();
    … …  
    126122    bool isActivated() const;
    127123
     124    void setAxis(int axis);
     125    void setColor(const Vector4& color);
     126    void setPos(float pos);
     127
    128128    void draw_bounding_box(float x0, float y0, float z0, float x1, float y1, float z1, float r, float g, float b, float line_width);
     129    void initializeDataArray();
    129130};
    130131
    … …  
    144145}
    145146
     147inline void NvParticleRenderer::setColor(const Vector4& color)
     148{
     149        _color = color;
     150}
    146151#endif

  • trunk/packages/vizservers/nanovis/NvVectorField.cpp

    r1369 r1370  
    5252        for (iter = _particleRendererMap.begin(); iter != _particleRendererMap.end(); iter++)
    5353        {
     54                if ((*iter).second) (*iter).second->initialize();
     55        }
     56}
     57
     58void NvVectorField::reset()
     59{
     60        std::map<std::string, NvParticleRenderer*>::iterator iter;
     61        for (iter = _particleRendererMap.begin(); iter != _particleRendererMap.end(); iter++)
     62        {
    5463                if ((*iter).second) (*iter).second->reset();
    5564        }
    … …  
    99108        if (renderer)
    100109        {
    101                 renderer->reset();
     110                renderer->initialize();
    102111        }
    103112}
    … …  
    191200                NvDeviceShape& shape = (*iterShape).second;
    192201
    193                 if (shape.visible) continue;
     202                if (!shape.visible) continue;
    194203               
    195204               

  • trunk/packages/vizservers/nanovis/NvVectorField.h

    r1369 r1370  
    1616public :
    1717        NvDeviceShape()
    18         : visible(false)
     18        : visible(true)
    1919        {
    2020        }
    … …  
    6262
    6363        void initialize();
     64        void reset();
    6465
    6566        void addPlane(const std::string& name);

  • trunk/packages/vizservers/nanovis/Volume.cpp

    r1188 r1370  
    2323double Volume::valueMax = 1.0;
    2424
    25 Volume::Volume(float x, float y, float z,
     25Volume::Volume(
     26                float x, float y, float z,
    2627                int w, int h, int d, float s,
    2728                int n, float* data, double v0, double v1, double nz_min):
    … …  
    4546    iso_surface(0)
    4647{
    47     Trace("Volume constructor\n");
    48 
    4948    tex = new Texture3D(w, h, d, NVIS_FLOAT, NVIS_LINEAR_INTERP, n);
    5049    int fcount = width * height * depth * n_components;
    … …  
    6564    wAxis.SetRange(v0, v1);
    6665
    67     aspect_ratio_width = s*tex->aspect_ratio_width;
    68     aspect_ratio_height = s*tex->aspect_ratio_height;
    69     aspect_ratio_depth = s*tex->aspect_ratio_depth;
     66        // VOLUME
     67        aspect_ratio_width = s*tex->aspect_ratio_width;
     68        aspect_ratio_height = s*tex->aspect_ratio_height;
     69        aspect_ratio_depth = s*tex->aspect_ratio_depth;
    7070   
    7171    location = Vector3(x,y,z);

  • trunk/packages/vizservers/nanovis/Volume.h

    r932 r1370  
    5454                                // objects. This size is provided by the
    5555                                // render engine.
     56    Vector3 _physical_min;
     57    Vector3 _physical_max;
    5658
    5759    AxisRange xAxis, yAxis, zAxis, wAxis;
    … …  
    156158                                               // on an axis
    157159    std::string label[3];       // the labels along each axis 0:x , 1:y, 2:z
     160
     161    void setPhysicalBBox(const Vector3& min, const Vector3& max);
     162    Vector3& getPhysicalBBoxMin();
     163    Vector3& getPhysicalBBoxMax();
    158164};
    159165
    … …  
    342348}
    343349
     350inline void
     351Volume::setPhysicalBBox(const Vector3& min, const Vector3& max)
     352{
     353        _physical_min = min;
     354        _physical_max = max;
     355
     356/*
     357        aspect_ratio_width = size * 1;
     358        aspect_ratio_height = size * (max.y - min.y) / (max.x - min.x);
     359        aspect_ratio_depth = size* (max.z - min.z) / (max.x - min.x);
     360
     361        location.x = -0.5;
     362        location.y = -0.5* aspect_ratio_height;
     363        location.z = -0.5* aspect_ratio_depth;
     364*/
     365}
     366
     367inline Vector3&
     368Volume::getPhysicalBBoxMin()
     369{
     370    return _physical_min;
     371}
     372
     373inline Vector3&
     374Volume::getPhysicalBBoxMax()
     375{
     376    return _physical_max;
     377}
     378
    344379#endif

  • trunk/packages/vizservers/nanovis/config.h

    r1299 r1370  
    3131#define PROTOTYPE               1
    3232
     33//#define NEW_FLOW_ENGINE
     34
    3335/*
    3436 * The following define controls whether new load_volume_stream or

  • trunk/packages/vizservers/nanovis/data/flowvis_dx_files/3DWireLeakage/SiO2/SiO2.dx

    r1329 r1370  
    11object 1 class gridpositions counts 121 25 23
    22origin 0.000000 -1.500000 -1.000000
    3 delta 30.000000 0 0
    4 delta 0 4.500000 0
    5 delta 0 0 4.500000
     3delta 0.247933884 0 0
     4delta 0 0.18 0
     5delta 0 0 0.195652174
    66object 2 class gridconnections counts 121 25 23
    77object 3 class array type double shape 3 rank 1 items 69575 data follows

  • trunk/packages/vizservers/nanovis/dxReader.cpp

    r1325 r1370  
    5656    dx = dy = dz = 0.0;         // Suppress compiler warning.
    5757    x0 = y0 = z0 = 0.0;         // May not have an origin line.
     58
     59    Vector3 physicalMin;
     60    Vector3 physicalMax;
     61
    5862    while (!fin.eof()) {
    5963        fin.getline(line, sizeof(line) - 1);
    … …  
    98102        }
    99103    }
     104
     105    physicalMin.set(x0, y0, z0);
     106    physicalMax.set(x0 + dx * nx, y0 + dy * ny, z0 + dz * nz);
    100107
    101108    // read data points
    … …  
    193200        volPtr->wAxis.SetRange(min_mag, max_mag);
    194201        volPtr->update_pending = true;
     202        volPtr->setPhysicalBBox(physicalMin, physicalMax);
    195203        delete [] data;
    196204    } else {

  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r1363 r1370  
    5454#include "NvEventLog.h"
    5555#include "NvZincBlendeReconstructor.h"
     56#include "NvFlowVisRenderer.h"
    5657#include "HeightMap.h"
    5758#include "Grid.h"
    … …  
    7172
    7273extern void NvInitCG(); // in Shader.cpp
     74extern bool load_vector_stream2(Rappture::Outcome &result, int index,
     75        std::istream& fin);
    7376
    7477// Indicates "up" axis:  x=1, y=2, z=3, -x=-1, -y=-2, -z=-3
    … …  
    108111Texture2D* NanoVis::plane[10];
    109112NvColorTableRenderer* NanoVis::color_table_renderer = 0;
    110 NvParticleRenderer* NanoVis::particleRenderer = 0;
     113
     114#ifndef NEW_FLOW_ENGINE
     115NvParticleRenderer* NanoVis::flowVisRenderer = 0;
     116#else
     117NvFlowVisRenderer* NanoVis::flowVisRenderer = 0;
     118#endif
     119
    111120graphics::RenderContext* NanoVis::renderContext = 0;
    112121NvLIC* NanoVis::licRenderer = 0;
    … …  
    755764void NanoVis::initParticle()
    756765{
    757     //random placement on a slice
    758     size_t n = particleRenderer->psys_width * particleRenderer->psys_height * 4;
    759     float* data = new float[n];
    760     memset(data, 0, sizeof(float)* n);
    761 
    762     int index;
    763     //bool particle;
    764     for (int i=0; i<particleRenderer->psys_width; i++) {
    765         for (int j=0; j<particleRenderer->psys_height; j++) {
    766             index = i + particleRenderer->psys_height*j;
    767             //particle = rand() % 256 > 150;
    768             //if(particle)
    769             {
    770                 //assign any location (x,y,z) in range [0,1]
    771                 // TEMP
    772                 //data[4*index] = lic_slice_x;
    773                 if (j % 2) data[4*index] = 0.95;
    774                 else data[4*index] = 0.05;
    775                 data[4*index+1]= j/float(particleRenderer->psys_height);
    776                 data[4*index+2]= i/float(particleRenderer->psys_width);
    777                 //data[4*index+3]= 30; //shorter life span, quicker iterations
    778                 data[4*index+3]= rand() / ((float) RAND_MAX) * 0.5  + 0.5f; //shorter life span, quicker iterations
    779             }
    780             /*
    781               else
    782               {
    783               data[4*index] = 0;
    784               data[4*index+1]= 0;
    785               data[4*index+2]= 0;
    786               data[4*index+3]= 0;
    787               }
    788             */
    789         }
    790     }
    791 
    792     particleRenderer->initialize((Particle*)data);
     766    flowVisRenderer->initialize();
    793767    licRenderer->make_patterns();
    794 
    795     delete[] data;
    796768}
    797769
    … …  
    851823    color_table_renderer = new NvColorTableRenderer();
    852824    color_table_renderer->setFonts(fonts);
    853     particleRenderer = new NvParticleRenderer(NMESH, NMESH, g_context);
     825#ifndef NEW_FLOW_ENGINE
     826    flowVisRenderer = new NvParticleRenderer(NMESH, NMESH, g_context);
     827#else
     828    flowVisRenderer = new NvFlowVisRenderer(NMESH, NMESH, g_context);
     829#endif
     830
    854831
    855832#if PROTOTYPE
    … …  
    17281705            licRenderer->render();
    17291706        }
    1730         if ((particleRenderer != NULL) && (particleRenderer->isActivated())) {
    1731             particleRenderer->render();
    1732         }
     1707
     1708        if ((flowVisRenderer != NULL) && (flowVisRenderer->isActivated())) {
     1709            flowVisRenderer->render();
     1710        }
     1711
    17331712        //soft_display_verts();
    17341713        //perf->enable();
    … …  
    18251804}
    18261805
     1806#ifdef NEW_FLOW_ENGINE
     1807void addVectorField(const char* filename, const char* vf_name, const char* plane_name1, const char* plane_name2, const Vector4& color1, const Vector4& color2)
     1808{
     1809                Rappture::Outcome result;
     1810                std::ifstream fdata;
     1811                fdata.open(filename, std::ios::in);
     1812
     1813                int n = NanoVis::n_volumes;
     1814                //fdata.write(buf.bytes(),buf.size());
     1815                if (load_vector_stream2(result, n, fdata)) {
     1816                        Volume *volPtr = NanoVis::volume[n];
     1817                        if (volPtr != NULL) {
     1818                                volPtr->set_n_slice(256-n);
     1819                                // volPtr->set_n_slice(512-n);
     1820                                volPtr->disable_cutplane(0);
     1821                                volPtr->disable_cutplane(1);
     1822                                volPtr->disable_cutplane(2);
     1823
     1824                                NanoVis::vol_renderer->add_volume(volPtr,
     1825                                        NanoVis::get_transfunc("default"));
     1826                                        float dx0 = -0.5;
     1827                                        float dy0 = -0.5*volPtr->height/volPtr->width;
     1828                                        float dz0 = -0.5*volPtr->depth/volPtr->width;
     1829                                        volPtr->move(Vector3(dx0, dy0, dz0));
     1830                                        //volPtr->enable_data();
     1831                                        volPtr->disable_data();
     1832                                NanoVis::flowVisRenderer->addVectorField(vf_name, volPtr,
     1833                                                *(volPtr->get_location()),
     1834                                                1.0f,
     1835                                                volPtr->height / (float)volPtr->width,
     1836                                                volPtr->depth  / (float)volPtr->width,
     1837                                                1.0f);
     1838                                NanoVis::flowVisRenderer->activateVectorField(vf_name);
     1839
     1840                                //////////////////////////////////
     1841                                // ADD Particle Injection Plane1
     1842                                NanoVis::flowVisRenderer->addPlane(vf_name, plane_name1);
     1843                                NanoVis::flowVisRenderer->setPlaneAxis(vf_name, plane_name1, 0);
     1844                                NanoVis::flowVisRenderer->setPlanePos(vf_name, plane_name1, 0.9);
     1845                                NanoVis::flowVisRenderer->setParticleColor(vf_name, plane_name1, color1);
     1846                                // ADD Particle Injection Plane2
     1847                                NanoVis::flowVisRenderer->addPlane(vf_name, plane_name2);
     1848                                NanoVis::flowVisRenderer->setPlaneAxis(vf_name, plane_name2, 0);
     1849                                NanoVis::flowVisRenderer->setPlanePos(vf_name, plane_name2, 0.2);
     1850                                NanoVis::flowVisRenderer->setParticleColor(vf_name, plane_name2, color2);
     1851                                NanoVis::flowVisRenderer->initialize(vf_name);
     1852
     1853                                NanoVis::flowVisRenderer->activatePlane(vf_name, plane_name1);
     1854                                NanoVis::flowVisRenderer->activatePlane(vf_name, plane_name2);
     1855       
     1856                        NanoVis::licRenderer->setVectorField(volPtr->id,
     1857                                *(volPtr->get_location()),
     1858                                1.0f / volPtr->aspect_ratio_width,
     1859                                1.0f / volPtr->aspect_ratio_height,
     1860                                1.0f / volPtr->aspect_ratio_depth,
     1861                                volPtr->wAxis.max());
     1862                }
     1863        }
     1864        //NanoVis::initParticle();
     1865}
     1866#endif
     1867
    18271868void
    18281869NanoVis::keyboard(unsigned char key, int x, int y)
    … …  
    18391880    }
    18401881#endif
     1882
     1883#ifdef NEW_FLOW_ENGINE
     1884    switch (key)
     1885    {
     1886        case 'a' :
     1887                {
     1888                        printf("flowvis active\n");
     1889                        NanoVis::flowVisRenderer->activate();
     1890                        NanoVis::licRenderer->activate();
     1891                }
     1892                break;
     1893        case 'd' :
     1894                {
     1895                        printf("flowvis deactived\n");
     1896                        NanoVis::flowVisRenderer->deactivate();
     1897                        NanoVis::licRenderer->deactivate();
     1898                }
     1899                break;
     1900        case '1' :
     1901                {
     1902                        addVectorField("/home/iwoo/projects/nanovis/rappture/packages/vizservers/nanovis/data/flowvis_dx_files/jwire/J-wire-vec.dx",
     1903                                        "vf_name2", "plane_name1", "plane_name2", Vector4(0, 0, 1, 1), Vector4(0, 1, 1, 1));
     1904                        printf("add vector field\n");
     1905                }
     1906                break;
     1907        case '2' :
     1908                {
     1909                        printf("add vector field\n");
     1910                        addVectorField("/home/iwoo/projects/nanovis/rappture/packages/vizservers/nanovis/data/flowvis_dx_files/3DWireLeakage/SiO2/SiO2.dx",
     1911                                        "vf_name1", "plane_name1", "plane_name2", Vector4(1, 0, 0, 1), Vector4(1, 1, 0, 1));
     1912                }
     1913                break;
     1914        case '3':
     1915                {
     1916                        printf("activate\n");
     1917                        NanoVis::flowVisRenderer->activatePlane("vf_name1", "plane_name2");
     1918                }
     1919                break;
     1920        case '4' :
     1921                {
     1922                        printf("deactivate\n");
     1923                        NanoVis::flowVisRenderer->deactivatePlane("vf_name1", "plane_name2");
     1924                }
     1925                break;
     1926        case '5' :
     1927                {
     1928                        printf("vector field deleted (vf_name2)\n");
     1929                        NanoVis::flowVisRenderer->removeVectorField("vf_name2");
     1930                }
     1931                break;
     1932        case '6' :
     1933                {
     1934                        printf("add device shape\n");
     1935                        NvDeviceShape shape;
     1936                        shape.min.set(0, 0, 0);
     1937                        shape.max.set(30, 3, 3);
     1938                        shape.color.set(1, 0, 0, 1);
     1939                        NanoVis::flowVisRenderer->addDeviceShape("vf_name1", "device1", shape);
     1940                        shape.min.set(0, -1, -1);
     1941                        shape.max.set(30, 4, 4);
     1942                        shape.color.set(0, 1, 0, 1);
     1943                        NanoVis::flowVisRenderer->addDeviceShape("vf_name1", "device2", shape);
     1944                        shape.min.set(10, -1.5, -1);
     1945                        shape.max.set(20, 4.5, 4.5);
     1946                        shape.color.set(0, 0, 1, 1);
     1947                        NanoVis::flowVisRenderer->addDeviceShape("vf_name1", "device3", shape);
     1948                        NanoVis::flowVisRenderer->activateDeviceShape("vf_name1");
     1949                }
     1950                break;
     1951        case '7' :
     1952                {
     1953                        printf("hide shape \n");
     1954                        NanoVis::flowVisRenderer->deactivateDeviceShape("vf_name1");
     1955                }
     1956                break;
     1957        case '8' :
     1958                {
     1959                        printf("show shape\n");
     1960                        NanoVis::flowVisRenderer->activateDeviceShape("vf_name1");
     1961                }
     1962                break;
     1963        case '9' :
     1964                {
     1965                        printf("show a shape \n");
     1966                        NanoVis::flowVisRenderer->activateDeviceShape("vf_name1", "device3");
     1967                }
     1968                break;
     1969        case '0' :
     1970                {
     1971                        printf("delete a shape \n");
     1972                        NanoVis::flowVisRenderer->deactivateDeviceShape("vf_name1", "device3");
     1973                }
     1974                break;
     1975        case 'r' :
     1976                {
     1977                        NanoVis::flowVisRenderer->reset();
     1978                        NanoVis::licRenderer->reset();
     1979                        printf("reset \n");
     1980                }
     1981                break;
     1982        }
     1983#endif
    18411984}
    18421985
    … …  
    18892032NanoVis::render()
    18902033{
     2034
    18912035    if ((NanoVis::licRenderer != NULL) &&
    18922036        (NanoVis::licRenderer->isActivated())) {
    … …  
    18942038    }
    18952039
    1896     if ((NanoVis::particleRenderer != NULL) &&
    1897         (NanoVis::particleRenderer->isActivated())) {
    1898         NanoVis::particleRenderer->advect();
     2040    if ((NanoVis::flowVisRenderer != NULL) &&
     2041        (NanoVis::flowVisRenderer->isActivated())) {
     2042        NanoVis::flowVisRenderer->advect();
    18992043    }
    19002044

  • trunk/packages/vizservers/nanovis/nanovis.h

    r1310 r1370  
    5252#include "Volume.h"
    5353#include "NvParticleRenderer.h"
     54#include "NvFlowVisRenderer.h"
    5455#include "PerfQuery.h"
    5556#include "Event.h"
    … …  
    7273#define SCALE 3.0       //scale for background pattern. small value -> fine texture
    7374
     75class NvVectorField;
     76
    7477struct Vector2 {
    7578    float x, y;
    … …  
    106109    static VolumeRenderer* vol_renderer;
    107110    static PointSetRenderer* pointset_renderer;
    108     static NvParticleRenderer* particleRenderer;
     111#ifndef NEW_FLOW_ENGINE
     112    static NvParticleRenderer* flowVisRenderer;
     113#else
     114    static NvFlowVisRenderer* flowVisRenderer;
     115#endif
    109116    static NvLIC* licRenderer;
    110117    static vector<PointSet*> pointSet;
    … …  
    120127    static unsigned char* screen_buffer;
    121128    static vector<Volume*> volume;
     129    static vector<NvVectorField*> flow;
    122130    static Grid* grid;
    123131    static R2Fonts* fonts;

  • trunk/packages/vizservers/nanovis/shaders/update_pos.cg

    r1331 r1370  
    7171    /*
    7272    if(ret.x<0 || ret.x>1 || ret.y<0 || ret.y>1 || ret.z<0 || ret.z>1 || time==0)
    73       ret = float4(1,0,0,0);
     73      ret = float4(0,0,0,0);
    7474    else
    7575      ret.w = 1;
Note: See TracChangeset for help on using the changeset viewer.