Changeset 5588 for nanovis


Ignore:
Timestamp:
May 21, 2015, 6:27:43 AM (4 years ago)
Author:
ldelgass
Message:

Merge support for VTK vector fields in nanovis to release branch

Location:
nanovis/branches/1.2
Files:
27 edited

Legend:

Unmodified
Added
Removed
  • nanovis/branches/1.2

  • nanovis/branches/1.2/Command.cpp

    r5542 r5588  
    5656#include "CmdProc.h"
    5757#include "FlowCmd.h"
     58#ifdef USE_DX_READER
    5859#include "dxReader.h"
     60#endif
    5961#ifdef USE_VTK
    6062#include "VtkDataSetReader.h"
     
    13571359        }
    13581360    } else {
     1361#ifdef USE_DX_READER
    13591362        // **Deprecated** OpenDX format
    13601363        if ((nBytes > 5) && (strncmp(bytes, "<ODX>", 5) == 0)) {
     
    13731376            return TCL_ERROR;
    13741377        }
     1378#else
     1379        Tcl_AppendResult(interp, "Loading DX files is not supported by this server", (char*)NULL);
     1380        return TCL_ERROR;
     1381#endif
    13751382    }
    13761383
  • nanovis/branches/1.2/Doxyfile.in

    r4612 r5588  
    599599# subdirectory from a directory tree whose root is specified with the INPUT tag.
    600600
    601 EXCLUDE                = @srcdir@/newmat11 @srcdir@/CircularQueue.h @srcdir@/ParticleEmitter.h @srcdir@/ParticleEmitter.cpp @srcdir@/ParticleSystem.h @srcdir@/ParticleSystem.cpp @srcdir@/ParticleSystemFactory.h @srcdir@/ParticleSystemFactory.cpp @srcdir@/BucketSort.h @srcdir@/BucketSort.cpp @srcdir@/PCASplit.h @srcdir@/PCASplit.cpp @srcdir@/PointSet.h @srcdir@/PointSet.cpp @srcdir@/PointSetRenderer.h @srcdir@/PointSetRenderer.cpp @srcdir@/PointShader.h @srcdir@/PointShader.cpp
     601EXCLUDE                = @srcdir@/bak @srcdir@/newmat11 @srcdir@/CircularQueue.h @srcdir@/ParticleEmitter.h @srcdir@/ParticleEmitter.cpp @srcdir@/ParticleSystem.h @srcdir@/ParticleSystem.cpp @srcdir@/ParticleSystemFactory.h @srcdir@/ParticleSystemFactory.cpp @srcdir@/BucketSort.h @srcdir@/BucketSort.cpp @srcdir@/PCASplit.h @srcdir@/PCASplit.cpp @srcdir@/PointSet.h @srcdir@/PointSet.cpp @srcdir@/PointSetRenderer.h @srcdir@/PointSetRenderer.cpp @srcdir@/PointShader.h @srcdir@/PointShader.cpp
    602602
    603603# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
  • nanovis/branches/1.2/Flow.cpp

    r5576 r5588  
    4141    _interp(interp),
    4242    _name(name),
    43     _data(NULL),
    4443    _volume(NULL)
    4544{
     
    5958    FreeSwitches(_switches, &_sv, 0);
    6059
    61     if (_data != NULL) {
    62         delete _data;
    63     }
    6460    if (_volume != NULL) {
    6561        NanoVis::removeVolume(_volume);
     
    8985
    9086    BBox allBounds;
     87    if (isDataLoaded()) {
     88        BBox bbox;
     89        _volume->getWorldSpaceBounds(bbox.min, bbox.max);
     90        allBounds.extend(bbox);
     91    }
    9192    for (BoxHashmap::iterator itr = _boxTable.begin();
    9293         itr != _boxTable.end(); ++itr) {
     
    107108{
    108109    if (position->flags == RELPOS) {
    109         return position->value;
     110        return (float)position->value;
    110111    }
    111112    switch (position->axis) {
    112     case AXIS_X: 
    113         return (position->value - NanoVis::xMin) /
    114             (NanoVis::xMax - NanoVis::xMin);
    115     case AXIS_Y: 
    116         return (position->value - NanoVis::yMin) /
    117             (NanoVis::yMax - NanoVis::yMin);
    118     case AXIS_Z: 
    119         return (position->value - NanoVis::zMin) /
    120             (NanoVis::zMax - NanoVis::zMin);
    121     }
    122     return 0.0;
     113    case AXIS_X:
     114        return (float)((position->value - _volume->xAxis.min()) /
     115                       (_volume->xAxis.max() - _volume->xAxis.min()));
     116    case AXIS_Y:
     117        return (float)((position->value - _volume->yAxis.min()) /
     118                       (_volume->yAxis.max() - _volume->yAxis.min()));
     119    case AXIS_Z:
     120        return (float)((position->value - _volume->zAxis.min()) /
     121                       (_volume->zAxis.max() - _volume->zAxis.min()));
     122    }
     123    return 0.0f;
    123124}
    124125
     
    257258
    258259bool
     260Flow::configure()
     261{
     262    bool needReset = false;
     263
     264    if (_volume != NULL) {
     265        _volume->transferFunction(_sv.transferFunction);
     266        _volume->dataEnabled(_sv.showVolume);
     267        _volume->twoSidedLighting(_sv.twoSidedLighting);
     268        _volume->outline(_sv.showOutline);
     269        _volume->opacityScale(_sv.opacity);
     270        _volume->ambient(_sv.ambient);
     271        _volume->diffuse(_sv.diffuse);
     272        _volume->specularLevel(_sv.specular);
     273        _volume->specularExponent(_sv.specularExp);
     274    }
     275
     276    float slicePos = getRelativePosition(&_sv.slicePos);
     277
     278    // FIXME: LIC and arrows should be per-flow
     279    if (NanoVis::licRenderer != NULL) {
     280        if (NanoVis::licRenderer->getSliceAxis() != _sv.slicePos.axis) {
     281            needReset = true;
     282            NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
     283        }
     284        if (NanoVis::licRenderer->getSlicePosition() != slicePos) {
     285            needReset = true;
     286            NanoVis::licRenderer->setSlicePosition(slicePos);
     287        }
     288        NanoVis::licRenderer->visible(_sv.sliceVisible);
     289    }
     290    if (NanoVis::velocityArrowsSlice != NULL) {
     291        NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
     292        NanoVis::velocityArrowsSlice->setSlicePosition(slicePos);
     293        NanoVis::velocityArrowsSlice->visible(_sv.showArrows);
     294    }
     295
     296    return needReset;
     297}
     298
     299bool
    259300Flow::scaleVectorField()
    260301{
    261     if (_volume != NULL) {
    262         TRACE("Removing existing volume: %s", _volume->name());
    263         NanoVis::removeVolume(_volume);
    264         _volume = NULL;
    265     }
    266     float *vdata = getScaledVector();
    267     if (vdata == NULL) {
     302    if (_volume == NULL) {
     303        ERROR("Called with NULL _volume");
    268304        return false;
    269305    }
    270     Volume *volume = makeVolume(vdata);
    271     delete [] vdata;
    272     if (volume == NULL) {
    273         return false;
    274     }
    275     _volume = volume;
    276 
    277     Vector3f scale = volume->getPhysicalScaling();
    278     Vector3f pos = _volume->getPosition();
    279 
     306
     307    // FIXME: LIC and arrows should be per-flow
    280308    if (NanoVis::licRenderer != NULL) {
    281         NanoVis::licRenderer->
    282             setVectorField(_volume->textureID(),
    283                            pos,
    284                            scale.x,
    285                            scale.y,
    286                            scale.z,
    287                            _volume->wAxis.max());
     309        NanoVis::licRenderer->setVectorField(_volume);
    288310        NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
    289         NanoVis::licRenderer->setSlicePosition(_sv.slicePos.value);
     311        NanoVis::licRenderer->setSlicePosition(getRelativePosition(&_sv.slicePos));
    290312        NanoVis::licRenderer->visible(_sv.sliceVisible);
    291313    }
    292 
    293314    if (NanoVis::velocityArrowsSlice != NULL) {
    294         NanoVis::velocityArrowsSlice->
    295             setVectorField(_volume->textureID(),
    296                            pos,
    297                            scale.x,
    298                            scale.y,
    299                            scale.z,
    300                            _volume->wAxis.max());
     315        NanoVis::velocityArrowsSlice->setVectorField(_volume);
    301316        NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
    302         NanoVis::velocityArrowsSlice->setSlicePosition(_sv.slicePos.value);
     317        NanoVis::velocityArrowsSlice->setSlicePosition(getRelativePosition(&_sv.slicePos));
    303318        NanoVis::velocityArrowsSlice->visible(_sv.showArrows);
    304319    }
    305 
    306     for (ParticlesHashmap::iterator itr = _particlesTable.begin();
    307          itr != _particlesTable.end(); ++itr) {
    308         itr->second->setVectorField(_volume,
    309                                     pos,
    310                                     scale.x,
    311                                     scale.y,
    312                                     scale.z,
    313                                     _volume->wAxis.max());
     320    for (ParticlesHashmap::iterator itr = _particlesTable.begin();
     321         itr != _particlesTable.end(); ++itr) {
     322        itr->second->setVectorField(_volume);
    314323    }
    315324    return true;
     
    328337
    329338float *
    330 Flow::getScaledVector()
    331 {
    332     assert(_data->nComponents() == 3);
    333     size_t n = _data->nValues() / _data->nComponents() * 4;
     339Flow::getScaledVector(Unirect3d *unirect)
     340{
     341    assert(unirect->nComponents() == 3);
     342    size_t n = unirect->nValues() / unirect->nComponents() * 4;
    334343    float *data = new float[n];
    335     if (data == NULL) {
    336         return NULL;
    337     }
    338344    memset(data, 0, sizeof(float) * n);
    339345    float *dest = data;
    340     const float *values = _data->values();
    341     for (size_t iz = 0; iz < _data->zNum(); iz++) {
    342         for (size_t iy = 0; iy < _data->yNum(); iy++) {
    343             for (size_t ix = 0; ix < _data->xNum(); ix++) {
     346    const float *values = unirect->values();
     347    for (size_t iz = 0; iz < unirect->zNum(); iz++) {
     348        for (size_t iy = 0; iy < unirect->yNum(); iy++) {
     349            for (size_t ix = 0; ix < unirect->xNum(); ix++) {
    344350                double vx, vy, vz, vm;
    345351                vx = values[0];
     
    347353                vz = values[2];
    348354                vm = sqrt(vx*vx + vy*vy + vz*vz);
    349                 dest[0] = vm / magMax;
    350                 dest[1] = vx /(2.0 * magMax) + 0.5;
    351                 dest[2] = vy /(2.0 * magMax) + 0.5;
    352                 dest[3] = vz /(2.0 * magMax) + 0.5;
     355                dest[0] = vm / unirect->magMax();
     356                dest[1] = vx /(2.0 * unirect->magMax()) + 0.5;
     357                dest[2] = vy /(2.0 * unirect->magMax()) + 0.5;
     358                dest[3] = vz /(2.0 * unirect->magMax()) + 0.5;
    353359                values += 3;
    354360                dest += 4;
     
    360366
    361367Volume *
    362 Flow::makeVolume(float *data)
     368Flow::makeVolume(Unirect3d *unirect, float *data)
    363369{
    364370    Volume *volume =
    365371        NanoVis::loadVolume(_name.c_str(),
    366                             _data->xNum(),
    367                             _data->yNum(),
    368                             _data->zNum(),
     372                            unirect->xNum(),
     373                            unirect->yNum(),
     374                            unirect->zNum(),
    369375                            4, data,
    370                             magMin,
    371                             magMax,
     376                            unirect->magMin(),
     377                            unirect->magMax(),
    372378                            0);
    373     volume->xAxis.setRange(_data->xMin(), _data->xMax());
    374     volume->yAxis.setRange(_data->yMin(), _data->yMax());
    375     volume->zAxis.setRange(_data->zMin(), _data->zMax());
    376 
    377     TRACE("mag=%g %g", magMin, magMax);
    378 
    379     volume->disableCutplane(0);
    380     volume->disableCutplane(1);
    381     volume->disableCutplane(2);
    382 
    383     /* Initialize the volume with the previously configured values. */
    384     volume->transferFunction(_sv.transferFunction);
    385     volume->dataEnabled(_sv.showVolume);
    386     volume->twoSidedLighting(_sv.twoSidedLighting);
    387     volume->outline(_sv.showOutline);
    388     volume->opacityScale(_sv.opacity);
    389     volume->ambient(_sv.ambient);
    390     volume->diffuse(_sv.diffuse);
    391     volume->specularLevel(_sv.specular);
    392     volume->specularExponent(_sv.specularExp);
    393     volume->visible(_sv.showVolume);
     379    volume->xAxis.setRange(unirect->xMin(), unirect->xMax());
     380    volume->yAxis.setRange(unirect->yMin(), unirect->yMax());
     381    volume->zAxis.setRange(unirect->zMin(), unirect->zMax());
     382
     383    TRACE("mag=%g %g", unirect->magMin(), unirect->magMax());
    394384
    395385    Vector3f volScaling = volume->getPhysicalScaling();
     
    401391    return volume;
    402392}
     393
     394void
     395Flow::initVolume()
     396{
     397    _volume->disableCutplane(0);
     398    _volume->disableCutplane(1);
     399    _volume->disableCutplane(2);
     400
     401    /* Initialize the volume with the previously configured values. */
     402    _volume->transferFunction(_sv.transferFunction);
     403    _volume->dataEnabled(_sv.showVolume);
     404    _volume->twoSidedLighting(_sv.twoSidedLighting);
     405    _volume->outline(_sv.showOutline);
     406    _volume->opacityScale(_sv.opacity);
     407    _volume->ambient(_sv.ambient);
     408    _volume->diffuse(_sv.diffuse);
     409    _volume->specularLevel(_sv.specular);
     410    _volume->specularExponent(_sv.specularExp);
     411    _volume->visible(_sv.showVolume);
     412
     413    Volume::updatePending = true;
     414}
  • nanovis/branches/1.2/Flow.h

    r5489 r5588  
    2525#include "FlowBox.h"
    2626#include "LIC.h"
     27#include "VelocityArrowsSlice.h"
    2728#include "Unirect.h"
    2829#include "Volume.h"
     
    8283    void getBoxNames(std::vector<std::string>& names);
    8384
    84     float *getScaledVector();
    85 
    86     Volume *makeVolume(float *data);
    87 
    88     bool scaleVectorField();
    89 
    9085    bool visible()
    9186    {
     
    10095    bool isDataLoaded()
    10196    {
    102         return (_data != NULL);
    103     }
    104 
    105     Unirect3d *data()
    106     {
    107         return _data;
     97        return (_volume != NULL);
     98    }
     99
     100    void getVectorRange(double range[])
     101    {
     102        range[0] = _volume->wAxis.min();
     103        range[1] = _volume->wAxis.max();
    108104    }
    109105
    110106    void data(Unirect3d *unirect)
    111107    {
    112         if (_data != NULL) {
    113             delete _data;
    114         }
    115         _data = unirect;
     108        float *vdata = getScaledVector(unirect);
     109        _volume = makeVolume(unirect, vdata);
     110        delete [] vdata;
     111        delete unirect;
     112        initVolume();
     113        scaleVectorField();
     114    }
     115
     116    void data(Volume *volume)
     117    {
     118        _volume = volume;
     119        initVolume();
     120        scaleVectorField();
    116121    }
    117122
     
    125130        return _sv.transferFunction;
    126131    }
    127 
    128     float getRelativePosition()
    129     {
    130         return getRelativePosition(&_sv.slicePos);
    131     }
    132 
    133132#if 0
    134133    void setSliceAxis(FlowSliceAxis axis)
     
    189188    }
    190189
     190    bool configure();
     191
    191192    Tcl_Command getCommandToken()
    192193    {
     
    194195    }
    195196
    196     static float getRelativePosition(FlowPosition *pos);
     197    float getRelativePosition(FlowPosition *pos);
    197198
    198199    static bool updatePending;
     
    205206    typedef std::tr1::unordered_map<BoxId, FlowBox *> BoxHashmap;
    206207
     208    void initVolume();
     209
     210    bool scaleVectorField();
     211
     212    float *getScaledVector(Unirect3d *unirect);
     213
     214    Volume *makeVolume(Unirect3d *unirect, float *data);
     215
    207216    void renderBoxes();
    208217
     
    222231
    223232    /**
    224      * Uniform rectangular data
    225      * representing the mesh and vector
    226      * field values.  These values are
    227      * kept to regenerate the volume
    228      * associated with the flow. */
    229     Unirect3d *_data;
    230 
    231     /**
    232233     * The volume associated with the
    233234     * flow.  This isn't the same thing as
  • nanovis/branches/1.2/FlowCmd.cpp

    r5551 r5588  
    3232#include "Command.h"
    3333#include "PPMWriter.h"
     34#ifdef USE_VTK
     35#include "VtkDataSetReader.h"
     36#else
     37#include "VtkReader.h"
     38#endif
    3439#include "FlowCmd.h"
    3540#include "FlowTypes.h"
     
    173178
    174179    Unirect3d *unirect = NULL;
     180    Volume *volume = NULL;
    175181
    176182    Flow *flow = (Flow *)clientData;
    177183    if ((length > 4) && (strncmp(bytes, "<DX>", 4) == 0)) {
     184#ifdef USE_DX_READER
    178185        unirect = new Unirect3d(nComponents);
    179186        if (!unirect->importDx(nComponents, length - 4, bytes + 4)) {
     
    182189            return TCL_ERROR;
    183190        }
     191#else
     192        Tcl_AppendResult(interp, "Loading DX files is not supported by this server", (char*)NULL);
     193        return TCL_ERROR;
     194#endif
    184195    } else if ((length > 10) && (strncmp(bytes, "unirect3d ", 10) == 0)) {
    185196        unirect = new Unirect3d(nComponents);
     
    197208        unirect->convert(u2dPtr);
    198209        delete u2dPtr;
     210    } else if ((length > 14) && (strncmp(bytes, "# vtk DataFile", 14) == 0)) {
     211        TRACE("VTK loading...");
     212#ifdef USE_VTK
     213        volume = load_vtk_volume_stream(flow->name(), bytes, length);
     214#else
     215        std::stringstream fdata;
     216        fdata.write(bytes, length);
     217        volume = load_vtk_volume_stream(flow->name(), fdata);
     218#endif
     219        if (volume == NULL) {
     220            Tcl_AppendResult(interp, "Failed to load VTK file", (char*)NULL);
     221            return TCL_ERROR;
     222        }
    199223    } else {
     224#ifdef USE_DX_READER
    200225        TRACE("header is %.14s", buf.bytes());
    201226        unirect = new Unirect3d(nComponents);
     
    205230            return TCL_ERROR;
    206231        }
     232#else
     233        Tcl_AppendResult(interp, "Loading DX files is not supported by this server", (char*)NULL);
     234        return TCL_ERROR;
     235#endif
    207236    }
    208237    if (unirect != NULL && unirect->nValues() == 0) {
     
    226255        TRACE("magMin = %g magMax = %g",
    227256              unirect->magMin(), unirect->magMax());
     257
    228258        flow->data(unirect);
    229 
     259    } else {
     260        flow->data(volume);
     261    }
     262    double range[2];
     263    flow->getVectorRange(range);
     264    {
    230265        char info[1024];
    231266        int length =
    232267            sprintf(info, "nv>data tag %s min %g max %g\n",
    233                     flow->name(), unirect->magMin(), unirect->magMax());
     268                    flow->name(), range[0], range[1]);
    234269#ifdef USE_THREADS
    235270        queueResponse(info, (size_t)length, Response::VOLATILE);
     
    435470    p = strrchr((char *)string, '%');
    436471    if (p == NULL) {
    437         float value;
    438 
    439         if (GetFloatFromObj(interp, objPtr, &value) != TCL_OK) {
     472        double value;
     473
     474        if (Tcl_GetDoubleFromObj(interp, objPtr, &value) != TCL_OK) {
    440475            return TCL_ERROR;
    441476        }
     
    449484            return TCL_ERROR;
    450485        }
    451         posPtr->value = (float)value * 0.01;
     486        posPtr->value = value * 0.01;
    452487        posPtr->flags = RELPOS;
    453488    }
     
    497532        return TCL_ERROR;
    498533    }
    499     Flow::updatePending = true;
     534    if (flow->configure()) {
     535        Flow::updatePending = true;
     536    }
    500537    NanoVis::eventuallyRedraw();
    501538    return TCL_OK;
  • nanovis/branches/1.2/FlowParticles.cpp

    r4923 r5588  
    2424FlowParticles::FlowParticles(const char *name) :
    2525    _name(name),
    26     _renderer(new ParticleRenderer(NMESH, NMESH))
     26    _renderer(new ParticleRenderer(NMESH, NMESH)),
     27    _volume(NULL)
    2728{
    28     _sv.position.value = 0.0f;
     29    _sv.position.value = 0.0;
    2930    _sv.position.flags = RELPOS;
    3031    _sv.position.axis = AXIS_Z;
     
    4445}
    4546
     47float
     48FlowParticles::getRelativePosition(FlowPosition *position)
     49{
     50    if (position->flags == RELPOS) {
     51        return (float)position->value;
     52    }
     53    switch (position->axis) {
     54    case AXIS_X:
     55        return (float)((position->value - _volume->xAxis.min()) /
     56                       (_volume->xAxis.max() - _volume->xAxis.min()));
     57    case AXIS_Y:
     58        return (float)((position->value - _volume->yAxis.min()) /
     59                       (_volume->yAxis.max() - _volume->yAxis.min()));
     60    case AXIS_Z:
     61        return (float)((position->value - _volume->zAxis.min()) /
     62                       (_volume->zAxis.max() - _volume->zAxis.min()));
     63    }
     64    return 0.0;
     65}
     66
    4667void
    4768FlowParticles::render()
     
    4970    TRACE("Particles '%s' axis: %d pos: %g rel pos: %g",
    5071          _name.c_str(), _sv.position.axis, _sv.position.value,
    51           Flow::getRelativePosition(&_sv.position));
     72          getRelativePosition(&_sv.position));
    5273
    53     _renderer->setSlicePosition(Flow::getRelativePosition(&_sv.position));
     74    _renderer->setSlicePosition(getRelativePosition(&_sv.position));
    5475    _renderer->setSliceAxis(_sv.position.axis);
    5576    assert(_renderer->active());
     
    7192        _renderer->setSliceAxis(_sv.position.axis);
    7293    }
    73     float pos = Flow::getRelativePosition(&_sv.position);
     94    float pos = getRelativePosition(&_sv.position);
    7495    if (_renderer->getSlicePosition() != pos) {
    7596        needReset = true;
  • nanovis/branches/1.2/FlowParticles.h

    r4904 r5588  
    7777    }
    7878
    79     void setVectorField(Volume *volume, const vrmath::Vector3f& location,
    80                         float scaleX, float scaleY, float scaleZ,
    81                         float max)
     79    void setVectorField(Volume *volume)
    8280    {
    83         _renderer->
    84             setVectorField(volume->textureID(),
    85                            location,
    86                            scaleX,
    87                            scaleY,
    88                            scaleZ,
    89                            max);
     81        _volume = volume;
     82        _renderer->setVectorField(volume);
    9083    }
     84
     85    float getRelativePosition(FlowPosition *position);
    9186
    9287    bool configure();
     
    9994    std::string _name;
    10095    nv::ParticleRenderer *_renderer;        ///< Particle renderer
     96    Volume *_volume;
    10197    FlowParticlesValues _sv;
    10298
  • nanovis/branches/1.2/FlowTypes.h

    r4904 r5588  
    2929
    3030struct FlowPosition {
    31     float value;
     31    double value;
    3232    unsigned int flags;
    3333    FlowSliceAxis axis;
  • nanovis/branches/1.2/Grid.cpp

    r5542 r5588  
    6565    glPushMatrix();
    6666
     67#ifdef USE_WORLD_COORDS
     68    double xLen = xAxis.length();
     69    double yLen = yAxis.length();
     70    double zLen = zAxis.length();
     71    double avgLen = 0.;
     72    double denom = 0.;
     73    if (xLen > 0.0) {
     74        avgLen += xLen;
     75        denom += 1.0;
     76    }
     77    if (yLen > 0.0) {
     78        avgLen += yLen;
     79        denom += 1.0;
     80    }
     81    if (zLen > 0.0) {
     82        avgLen += zLen;
     83        denom += 1.0;
     84    }
     85    if (denom > 0.0) {
     86        avgLen /= denom;
     87    } else {
     88        avgLen = 1.0;
     89    }
     90    float xTickLen = (TICK_LENGTH * avgLen) / xLen;
     91    float yTickLen = (TICK_LENGTH * avgLen) / yLen;
     92    float zTickLen = (TICK_LENGTH * avgLen) / zLen;
     93    float xLabelOfs = (LABEL_OFFSET * avgLen) / xLen;
     94    //float yLabelOfs = (LABEL_OFFSET * avgLen) / yLen;
     95    float zLabelOfs = (LABEL_OFFSET * avgLen) / zLen;
     96    float xTitleOfs = (TITLE_OFFSET * avgLen) / xLen;
     97    float yTitleOfs = (TITLE_OFFSET * avgLen) / yLen;
     98    float zTitleOfs = (TITLE_OFFSET * avgLen) / zLen;
     99
     100    glTranslated(xAxis.min(), yAxis.min(), zAxis.min());
     101    glScaled(xLen, yLen, zLen);
     102#else
    67103    double xDataRange = xAxis.dataMax() - xAxis.dataMin();
    68104    double yDataRange = yAxis.dataMax() - yAxis.dataMin();
     
    109145    glScalef(xscale, yscale, zscale);
    110146    glTranslatef(xoffset, yoffset, zoffset);
     147#endif
    111148
    112149    glLineWidth(2.0f);
  • nanovis/branches/1.2/LIC.cpp

    r4904 r5588  
    480480
    481481void
    482 LIC::setVectorField(unsigned int texID, const Vector3f& origin,
    483                       float scaleX, float scaleY, float scaleZ, float max)
    484 {
    485     TRACE("LIC: vector field is assigned [%d]", texID);
    486     _vectorFieldId = texID;
    487     _origin = origin;
    488     _scale.set(scaleX, scaleY, scaleZ);
    489     _max = max;
     482LIC::setVectorField(Volume *volume)
     483{
     484    TRACE("LIC: vector field is assigned [%d]", volume->textureID());
     485
     486    _vectorFieldId = volume->textureID();
     487#ifdef USE_WORLD_COORDS
     488    Vector3f bmin, bmax;
     489    volume->getBounds(bmin, bmax);
     490    _origin = bmin;
     491    Vector3f scale(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
     492#else
     493    _origin = volume->getPosition();
     494    Vector3f scale = volume->getPhysicalScaling();
     495#endif
     496    _scale.set(scale.x, scale.y, scale.z);
     497    _max = volume->wAxis.max();
    490498
    491499    makePatterns();
  • nanovis/branches/1.2/LIC.h

    r4904 r5588  
    4848    }
    4949
    50     void setVectorField(unsigned int texID, const vrmath::Vector3f& origin,
    51                         float scaleX, float scaleY, float scaleZ, float max);
     50    void setVectorField(Volume *volume);
    5251
    5352    void reset();
  • nanovis/branches/1.2/Makefile.in

    r5542 r5588  
    33USE_POINTSET_RENDERER   = #yes
    44USE_PARTICLE_SYSTEM     = #yes
    5 USE_VTK                 = #yes
     5USE_DX_READER           = yes
     6USE_VTK                 = yes
    67
    78SHELL = /bin/sh
     
    7778endif
    7879
     80NEED_RAPPTURE2  =
     81ifdef USE_DX_READER
     82NEED_RAPPTURE2  = yes
     83endif
     84ifndef USE_VTK
     85NEED_RAPPTURE2  = yes
     86endif
     87
    7988EXTRA_LIBS      = -lm -lpthread
    8089RP_DIR          =  @RP_DIR@
    81 RP_INC_SPEC     = -I$(RP_DIR)/include -I$(RP_DIR)/include/rappture2
     90RP_INC_SPEC     = -I$(RP_DIR)/include
     91ifdef NEED_RAPPTURE2
     92RP_INC_SPEC     += -I$(RP_DIR)/include/rappture2
     93endif
     94ifdef NEED_RAPPTURE2
    8295RP_LIB_SPEC     = -L$(RP_DIR)/lib -lrappture2 -lrappture -lexpat -lz
     96else
     97RP_LIB_SPEC     = -L$(RP_DIR)/lib -lrappture -lexpat -lz
     98endif
    8399
    84100TCL_LIB_SPEC    = @TCL_LIB_SPEC@
     
    123139ifdef TRACE
    124140DEFINES         += -DWANT_TRACE
     141endif
     142ifdef USE_DX_READER
     143DEFINES         += -DUSE_DX_READER
    125144endif
    126145ifdef USE_THREADS
     
    181200                ZincBlendeVolume.o \
    182201                ZincBlendeVolumeShader.o \
    183                 dxReader.o \
    184202                md5.o \
    185203                nanovis.o \
     
    206224                $(srcdir)/shaders/vertex_std.cg \
    207225                $(srcdir)/shaders/zincblende_volume.cg
     226
     227ifdef USE_DX_READER
     228OBJS +=         dxReader.o
     229endif
    208230
    209231ifdef USE_PARTICLE_SYSTEM
     
    333355ParticleAdvectionShader.o: ParticleAdvectionShader.cpp ParticleAdvectionShader.h Shader.h
    334356ParticleEmitter.o: ParticleEmitter.cpp ParticleEmitter.h
    335 ParticleRenderer.o: ParticleRenderer.cpp ParticleRenderer.h FlowTypes.h define.h
     357ParticleRenderer.o: ParticleRenderer.cpp ParticleRenderer.h ParticleAdvectionShader.h FlowTypes.h define.h
    336358ParticleSystem.o: ParticleSystem.cpp ParticleSystem.h
    337359ParticleSystemFactory.o: ParticleSystemFactory.cpp ParticleSystemFactory.h
  • nanovis/branches/1.2/ParticleAdvectionShader.h

    r5397 r5588  
    3333        _velocityVolumeID = texID;
    3434        _max = max;
    35         // FIXME: Is this needed?
     35        /* FIXME: _max is the maximum displacement in world coords per
     36         * time step.  Need to determine a scale factor to get an
     37         * appropriate animation speed
     38         */
    3639        if (_max > 100.f)
    3740            _max = 100.0f;
     41        setTimeStep(0.0005f);
    3842    }
    3943
  • nanovis/branches/1.2/ParticleRenderer.cpp

    r5482 r5588  
    1717
    1818#include "ParticleRenderer.h"
     19#include "ParticleAdvectionShader.h"
    1920#include "Volume.h"
    2021#include "define.h"
     
    322323
    323324void
    324 ParticleRenderer::setVectorField(unsigned int texID, const vrmath::Vector3f& origin,
    325                                  float scaleX, float scaleY, float scaleZ,
    326                                  float max)
    327 {
    328     _origin = origin;
    329     _scale.set(scaleX, scaleY, scaleZ);
     325ParticleRenderer::setVectorField(Volume *volume)
     326{
     327#ifdef USE_WORLD_COORDS
     328    Vector3f bmin, bmax;
     329    volume->getBounds(bmin, bmax);
     330    _origin = bmin;
     331    Vector3f scale(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
     332#else
     333    _origin = volume->getPosition();
     334    Vector3f scale = volume->getPhysicalScaling();
     335#endif
     336    _scale.set(scale.x, scale.y, scale.z);
    330337    _advectionShader->setScale(_scale);
    331     _advectionShader->setVelocityVolume(texID, max);
     338    _advectionShader->setVelocityVolume(volume->textureID(),
     339                                        volume->wAxis.max());
    332340}
    333341
  • nanovis/branches/1.2/ParticleRenderer.h

    r5481 r5588  
    4545    ~ParticleRenderer();
    4646
    47     void setVectorField(unsigned int texID, const vrmath::Vector3f& origin,
    48                         float scaleX, float scaleY, float scaleZ, float max);
     47    void setVectorField(Volume *volume);
    4948
    5049    void initialize();
  • nanovis/branches/1.2/ParticleSystem.cpp

    r4904 r5588  
    44 *
    55 */
     6#include "nvconf.h"
    67
    78#include <time.h>
  • nanovis/branches/1.2/Shader.h

    r4904 r5588  
    237237    static void setErrorCallback(ShaderCallbackFunction callback);
    238238
    239     static CGcontext getCgContext()
    240     {
    241         return _cgContext;
    242     }
    243 
    244 protected:
     239private:
    245240    typedef CGparameter Parameter;
    246241    typedef std::tr1::unordered_map<std::string, Parameter> ParameterHashmap;
     
    328323    }
    329324
     325    static CGcontext getCgContext()
     326    {
     327        return _cgContext;
     328    }
     329
     330    static CGprogram loadCgSourceProgram(CGcontext context,
     331                                         const char *filename,
     332                                         CGprofile profile,
     333                                         const char *entryPoint);
     334
    330335    std::string _vpFile;
    331336    std::string _fpFile;
     
    343348    static CGprofile _defaultFragmentProfile;
    344349    static CGcontext _cgContext;
    345 
    346 private:
    347     static CGprogram
    348     loadCgSourceProgram(CGcontext context, const char *filename,
    349                         CGprofile profile, const char *entryPoint);
    350350};
    351351
  • nanovis/branches/1.2/Unirect.cpp

    r5553 r5588  
    489489}
    490490
     491#ifdef USE_DX_READER
    491492bool
    492493nv::Unirect3d::importDx(size_t nComponents,
     
    643644    return true;
    644645}
     646#endif
    645647
    646648void
  • nanovis/branches/1.2/Unirect.h

    r5553 r5588  
    223223    int parseBuffer(Tcl_Interp *interp, const char *bytes, size_t len);
    224224
     225#ifdef USE_DX_READER
    225226    bool importDx(size_t nComponents, size_t length, char *string);
     227#endif
    226228
    227229    bool convert(Unirect2d *dataPtr);
  • nanovis/branches/1.2/VelocityArrowsSlice.cpp

    r5394 r5588  
    1818#include "nanovis.h"
    1919#include "VelocityArrowsSlice.h"
     20#include "Volume.h"
    2021#include "Shader.h"
    2122#include "Camera.h"
     
    316317    glPushMatrix();
    317318
     319    glTranslatef(_origin.x, _origin.y, _origin.z);
    318320    glScalef(_scale.x, _scale.y, _scale.z);
    319     glTranslatef(-0.5f, -0.5f, -0.5f);
    320321
    321322    if (_renderMode == LINES) {
     
    463464
    464465void
    465 VelocityArrowsSlice::setVectorField(unsigned int vfGraphicsID, const Vector3f& origin,
    466                                     float xScale, float yScale, float zScale, float max)
    467 {
    468     _vectorFieldGraphicsID = vfGraphicsID;
    469     _scale.set(xScale, yScale, zScale);
     466VelocityArrowsSlice::setVectorField(Volume *volume)
     467{
     468    _vectorFieldGraphicsID = volume->textureID();
     469#ifdef USE_WORLD_COORDS
     470    Vector3f bmin, bmax;
     471    volume->getBounds(bmin, bmax);
     472    _origin = bmin;
     473    Vector3f scale(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
     474#else
     475    _origin = volume->getPosition();
     476    Vector3f scale = volume->getPhysicalScaling();
     477#endif
     478    _scale.set(scale.x, scale.y, scale.z);
    470479
    471480    _dirty = true;
  • nanovis/branches/1.2/VelocityArrowsSlice.h

    r4904 r5588  
    1212
    1313#include "FlowTypes.h"
     14#include "Volume.h"
    1415#include "Texture2D.h"
    1516#include "Shader.h"
     
    2930    ~VelocityArrowsSlice();
    3031
    31     void setVectorField(unsigned int vfGraphicsID, const vrmath::Vector3f& origin,
    32                         float xScale, float yScale, float zScale, float max);
     32    void setVectorField(Volume *volume);
    3333
    3434    void setSliceAxis(FlowSliceAxis axis);
     
    9696
    9797    unsigned int _vectorFieldGraphicsID;
     98    vrmath::Vector3f _origin;
    9899    vrmath::Vector3f _scale;
    99100
  • nanovis/branches/1.2/Volume.cpp

    r5406 r5588  
    6666    int fcount = _width * _height * _depth * _numComponents;
    6767    _data = new float[fcount];
    68     if (data != NULL) {
    69         memcpy(_data, data, fcount * sizeof(float));
    70     } else {
    71         TRACE("data is NULL");
    72         memset(_data, 0, fcount * sizeof(float));
    73     }
     68    memcpy(_data, data, fcount * sizeof(float));
    7469    _tex->initialize(_data);
     70
    7571    _id = _tex->id();
    7672
     
    9389    delete [] _data;
    9490    delete _tex;
     91}
     92
     93void Volume::setData(float *data, double vmin, double vmax, double nonZeroMin)
     94{
     95    int fcount = _width * _height * _depth * _numComponents;
     96    memcpy(_data, data, fcount * sizeof(float));
     97    _tex->update(_data);
     98    wAxis.setRange(vmin, vmax);
     99    _nonZeroMin = nonZeroMin;
     100    updatePending = true;
    95101}
    96102
  • nanovis/branches/1.2/Volume.h

    r5406 r5588  
    125125    }
    126126
     127    void setData(float *data, double vmin, double vmax, double nonZeroMin);
     128
    127129    const float *data() const
    128130    {
  • nanovis/branches/1.2/dxReader.cpp

    r5551 r5588  
    5959nv::load_dx_volume_stream(const char *tag, std::iostream& fin)
    6060{
    61     TRACE("Enter tag:%s", tag);
     61    TRACE("Enter tag: %s", tag);
    6262
    6363    Rappture::MeshTri2D xymesh;
  • nanovis/branches/1.2/nanovis.cpp

    r5584 r5588  
    616616
    617617    TRACE("leaving initGL");
    618 
    619618    return true;
    620619}
     
    766765NanoVis::collectBounds(bool onlyVisible)
    767766{
    768     if (Flow::updatePending) {
    769         setFlowRanges();
    770     }
    771 
    772767    sceneBounds.makeEmpty();
    773768
     
    916911            continue;
    917912        }
    918         Unirect3d *data = flow->data();
    919913        double range[2];
    920         range[0] = data->magMin();
    921         range[1] = data->magMax();
     914        flow->getVectorRange(range);
    922915        if (range[0] < Flow::magMin) {
    923916            Flow::magMin = range[0];
     
    926919            Flow::magMax = range[1];
    927920        }
    928         if (data->xMin() < xMin) {
    929             xMin = data->xMin();
    930         }
    931         if (data->yMin() < yMin) {
    932             yMin = data->yMin();
    933         }
    934         if (data->zMin() < zMin) {
    935             zMin = data->zMin();
    936         }
    937         if (data->xMax() > xMax) {
    938             xMax = data->xMax();
    939         }
    940         if (data->yMax() > yMax) {
    941             yMax = data->yMax();
    942         }
    943         if (data->zMax() > zMax) {
    944             zMax = data->zMax();
     921        const Volume *volume = flow->getVolume();
     922        if (xMin > volume->xAxis.min()) {
     923            xMin = volume->xAxis.min();
     924        }
     925        if (xMax < volume->xAxis.max()) {
     926            xMax = volume->xAxis.max();
     927        }
     928        if (yMin > volume->yAxis.min()) {
     929            yMin = volume->yAxis.min();
     930        }
     931        if (yMax < volume->yAxis.max()) {
     932            yMax = volume->yAxis.max();
     933        }
     934        if (zMin > volume->zAxis.min()) {
     935            zMin = volume->zAxis.min();
     936        }
     937        if (zMax < volume->zAxis.max()) {
     938            zMax = volume->zAxis.max();
    945939        }
    946940    }
     
    969963            flow->initializeParticles();
    970964        }
    971         if (!flow->scaleVectorField()) {
    972             return false;
    973         }
    974         // FIXME: This doesn't work when there is more than one flow.
    975         licRenderer->setSlicePosition(flow->getRelativePosition());
    976         velocityArrowsSlice->setSlicePosition(flow->getRelativePosition());
    977     }
    978     advectFlows();
     965    }
    979966
    980967    Flow::updatePending = false;
     
    10791066
    10801067    // Now render things in the scene
    1081     //orientationIndicator->setPosition(sceneBounds.getCenter());
    1082     //orientationIndicator->setScale(sceneBounds.getSize());
     1068    orientationIndicator->setPosition(sceneBounds.getCenter());
     1069    orientationIndicator->setScale(sceneBounds.getSize());
    10831070    orientationIndicator->render();
    10841071
  • nanovis/branches/1.2/nanovis.h

    r5585 r5588  
    122122    static void deleteFlows(Tcl_Interp *interp);
    123123    static void deleteFlow(const char *name);
     124
    124125    static void renderFlows();
    125126    static void resetFlows();
Note: See TracChangeset for help on using the changeset viewer.