Changeset 4904 for nanovis/branches/1.1


Ignore:
Timestamp:
Dec 22, 2014, 7:18:59 AM (5 years ago)
Author:
ldelgass
Message:

Merge serveral changes from trunk. Does not include threading, world space
changes, etc.

Location:
nanovis/branches/1.1
Files:
89 edited

Legend:

Unmodified
Added
Removed
  • nanovis/branches/1.1/Axis.h

    r4889 r4904  
    399399                                 * the data. */
    400400
    401     double _range;              /**< Range of values on axis (max_ - min_) */
     401    double _range;              /**< Range of values on axis (_max - _min) */
    402402    double _scale;              /**< Scale factor for axis (1.0/_range) */
    403403
  • nanovis/branches/1.1/Camera.cpp

    r4889 r4904  
    1818#include <vrmath/Vector3f.h>
    1919#include <vrmath/Vector4f.h>
     20#include <vrmath/BBox.h>
    2021
    2122#include "nanovis.h"
     
    3637}
    3738
    38 Camera::Camera(int startx, int starty, int w, int h,
    39                float loc_x, float loc_y, float loc_z) :
    40     _location(loc_x, loc_y, loc_z),
     39Camera::Camera(int x, int y, int width, int height) :
     40    _updir(Y_POS),
     41    _position(0, 0, 2.5),
    4142    _fov(30.0),
    4243    _near(0.1),
    43     _far(50.0),
    44     _width(w),
    45     _height(h),
    46     _startX(startx),
    47     _startY(starty)
    48 {
     44    _far(50.0)
     45{
     46    _viewport[0] = x;
     47    _viewport[1] = y;
     48    _viewport[2] = width;
     49    _viewport[3] = height;
     50}
     51
     52const Matrix4x4d&
     53Camera::getUpDirMatrix() const
     54{
     55    return _updirMatrix;
    4956}
    5057
    5158void
    52 Camera::getUpDirMatrix(Matrix4x4d& upMat)
    53 {
    54     switch (NanoVis::updir) {
    55     case NanoVis::X_POS: {
    56         upMat.makeRotation(0, 0, 1, deg2rad(90));
     59Camera::setUpDirMatrix(AxisDirection dir)
     60{
     61    _updir = dir;
     62
     63    switch (_updir) {
     64    case X_POS: {
     65        _updirMatrix.makeRotation(0, 0, 1, deg2rad(90));
    5766        Matrix4x4d tmp;
    5867        tmp.makeRotation(1, 0, 0, deg2rad(90));
    59         upMat.multiply(tmp);
    60     }
    61         break;
    62     case NanoVis::Y_POS:
    63         upMat.makeIdentity();
    64         break;
    65     case NanoVis::Z_POS: {
    66         upMat.makeRotation(1, 0, 0, deg2rad(-90));
     68        _updirMatrix.multiply(tmp);
     69    }
     70        break;
     71    case Y_POS:
     72        _updirMatrix.makeIdentity();
     73        break;
     74    case Z_POS: {
     75        _updirMatrix.makeRotation(1, 0, 0, deg2rad(-90));
    6776        Matrix4x4d tmp;
    6877        tmp.makeRotation(0, 0, 1, deg2rad(-90));
    69         upMat.multiply(tmp);
    70     }
    71         break;
    72     case NanoVis::X_NEG:
    73         upMat.makeRotation(0, 0, 1, deg2rad(-90));
    74         break;
    75     case NanoVis::Y_NEG: {
    76         upMat.makeRotation(0, 0, 1, deg2rad(180));
     78        _updirMatrix.multiply(tmp);
     79    }
     80        break;
     81    case X_NEG:
     82        _updirMatrix.makeRotation(0, 0, 1, deg2rad(-90));
     83        break;
     84    case Y_NEG: {
     85        _updirMatrix.makeRotation(0, 0, 1, deg2rad(180));
    7786        Matrix4x4d tmp;
    7887        tmp.makeRotation(0, 1, 0, deg2rad(-90));
    79         upMat.multiply(tmp);
    80     }
    81         break;
    82     case NanoVis::Z_NEG:
    83         upMat.makeRotation(1, 0, 0, deg2rad(90));
     88        _updirMatrix.multiply(tmp);
     89    }
     90        break;
     91    case Z_NEG:
     92        _updirMatrix.makeRotation(1, 0, 0, deg2rad(90));
    8493        break;
    8594    }
     
    97106
    98107    if (resetOrientation) {
    99         _cameraMatrix.makeIdentity();
     108        _rotationMatrix.makeIdentity();
    100109    }
    101110
     
    104113
    105114    Matrix4x4d mat, upMat;
    106     getUpDirMatrix(upMat);
     115    upMat = getUpDirMatrix();
    107116    mat.makeTranslation(-center);
    108     mat.multiply(_cameraMatrix, mat);
     117    mat.multiply(_rotationMatrix, mat);
    109118    mat.multiply(upMat);
    110119
     
    146155
    147156    // Deal with vertical aspect window
    148     double winAspect = (double)(_width - _startX)/(double)(_height - _startY);
     157    double winAspect = (double)_viewport[2]/(double)_viewport[3];
    149158    double sceneAspect = 1.0;;
    150159    if (bheight > 0.0)
     
    161170    _far = _near + bdepth;
    162171
    163     _location.set(center.x, center.y, center.z + distance);
     172    _position.set(center.x, center.y, center.z + distance);
    164173
    165174    TRACE("win aspect: %g scene aspect: %g", winAspect, sceneAspect);
    166175    TRACE("c: %g,%g,%g, d: %g", center.x, center.y, center.z, distance);
     176    TRACE("pos: %g, %g, %g", _position.x, _position.y, _position.z);
    167177    TRACE("near: %g, far: %g", _near, _far);
    168178
     
    171181}
    172182
     183/**
     184 * \brief Reset near and far planes based on given world space
     185 * bounding box
     186 */
    173187void
    174188Camera::resetClippingRange(const Vector3f& bboxMin, const Vector3f& bboxMax)
     
    187201    radius = (radius == 0) ? 1.0 : radius;
    188202
    189     TRACE("c: %g,%g,%g, r: %g cam z: %g", center.x, center.y, center.z, radius, _location.z);
    190 
    191     _near = _location.z - radius;
    192     _far = _location.z + radius;
     203    TRACE("c: %g,%g,%g, r: %g cam z: %g", center.x, center.y, center.z, radius, _position.z);
     204
     205    _near = _position.z - radius;
     206    _far = _position.z + radius;
    193207
    194208    if (_near < 0.0) {
     
    204218    glLoadIdentity();
    205219    gluPerspective(_fov,
    206                    (GLdouble)(_width - _startX)/(GLdouble)(_height - _startY),
     220                   (GLdouble)_viewport[2]/(GLdouble)_viewport[3],
    207221                   _near, _far);
    208222    glMatrixMode(GL_MODELVIEW);
     
    217231    print();
    218232
    219     glViewport(_startX, _startY, _width, _height);
     233    glViewport(_viewport[0], _viewport[1], _viewport[2], _viewport[3]);
    220234    glMatrixMode(GL_PROJECTION);
    221235    glLoadIdentity();
    222236    gluPerspective(_fov,
    223                    (GLdouble)(_width - _startX)/(GLdouble)(_height - _startY),
     237                   (GLdouble)_viewport[2]/(GLdouble)_viewport[3],
    224238                   _near, _far);
    225239
     
    227241    glLoadIdentity();
    228242
    229     glTranslatef(-_location.x, -_location.y, -_location.z);
    230     glMultMatrixd((const GLdouble *)_cameraMatrix.get());
    231 }
    232 
    233 void Camera::rotate(double *quat)
     243    glTranslatef(-_position.x, -_position.y, -_position.z);
     244    glMultMatrixd((const GLdouble *)_rotationMatrix.get());
     245}
     246
     247void Camera::getProjectionMatrix(Matrix4x4d& mat)
     248{
     249    glMatrixMode(GL_PROJECTION);
     250    glPushMatrix();
     251    glLoadIdentity();
     252    gluPerspective(_fov,
     253                   (GLdouble)_viewport[2]/(GLdouble)_viewport[3],
     254                   _near, _far);
     255    glGetDoublev(GL_PROJECTION_MATRIX, (GLdouble *)mat.get());
     256    glPopMatrix();
     257    glMatrixMode(GL_MODELVIEW);
     258}
     259
     260void Camera::orient(double *quat)
    234261{
    235262    Quaternion q(quat[0], quat[1], quat[2], quat[3]);
    236263    Rotation rot;
    237264    rot.set(q);
    238     _cameraMatrix.makeRotation(rot);
    239     _cameraMatrix.transpose();
     265    _rotationMatrix.makeRotation(rot);
     266    _rotationMatrix.transpose();
     267
    240268    TRACE("Set rotation to quat: %g %g %g %g",
    241269          quat[0], quat[1], quat[2], quat[3]);
    242270}
    243271
    244 void Camera::rotate(float angleX, float angleY, float angleZ)
     272void Camera::orient(float angleX, float angleY, float angleZ)
    245273{
    246274    angleX = -angleX;
    247275    angleY = angleY - 180.;
    248276
    249     _cameraMatrix.makeRotation(1, 0, 0, deg2rad(angleX));
     277    _rotationMatrix.makeRotation(1, 0, 0, deg2rad(angleX));
    250278    Matrix4x4d mat;
    251279    mat.makeRotation(0, 1, 0, deg2rad(angleY));
    252     _cameraMatrix.multiply(mat);
     280    _rotationMatrix.multiply(mat);
    253281    mat.makeRotation(0, 0, 1, deg2rad(angleZ));
    254     _cameraMatrix.multiply(mat);
    255     //_cameraMatrix.transpose();
     282    _rotationMatrix.multiply(mat);
    256283
    257284    TRACE("Set rotation to angles: %g %g %g",
     
    261288void Camera::print() const
    262289{
    263     TRACE("x: %d y: %d w: %d h: %d", _startX, _startY, _width, _height);
    264     TRACE("loc: %g %g %g",
    265           _location.x, _location.y, _location.z);
    266     TRACE("Camera matrix: ");
    267     _cameraMatrix.print();
     290    TRACE("x: %d y: %d w: %d h: %d",
     291          _viewport[0], _viewport[1], _viewport[2], _viewport[3]);
    268292    TRACE("fov: %g near: %g far: %g", _fov, _near, _far);
    269 }
     293    TRACE("pos: %g %g %g",
     294          _position.x, _position.y, _position.z);
     295    TRACE("Rotation matrix: ");
     296    _rotationMatrix.print();
     297}
  • nanovis/branches/1.1/Camera.h

    r4889 r4904  
    1919{
    2020public:
    21     Camera(int startx, int starty, int w, int h,
    22              float loc_x, float loc_y, float loc_z);
     21    enum AxisDirection {
     22        X_POS = 1,
     23        Y_POS = 2,
     24        Z_POS = 3,
     25        X_NEG = -1,
     26        Y_NEG = -2,
     27        Z_NEG = -3
     28    };
     29
     30    Camera(int x, int y, int width, int height);
    2331
    2432    ~Camera()
    2533    {}
    2634
    27     //move location of camera
     35    void setUpdir(AxisDirection dir)
     36    {
     37        setUpDirMatrix(dir);
     38    }
     39
     40    AxisDirection getUpdir()
     41    {
     42        return _updir;
     43    }
     44
     45    void setPosition(const vrmath::Vector3f& pos)
     46    {
     47        _position = pos;
     48    }
     49
     50    const vrmath::Vector3f& getPosition() const
     51    {
     52        return _position;
     53    }
     54
    2855    void x(float loc_x)
    2956    {
    30         _location.x = loc_x;
     57        _position.x = loc_x;
    3158    }
    3259
    3360    float x() const
    3461    {
    35         return _location.x;
     62        return _position.x;
    3663    }
    3764
    3865    void y(float loc_y)
    3966    {
    40         _location.y = loc_y;
     67        _position.y = loc_y;
    4168    }
    4269
    4370    float y() const
    4471    {
    45         return _location.y;
     72        return _position.y;
    4673    }
    4774
    4875    void z(float loc_z)
    4976    {
    50         _location.z = loc_z;
     77        _position.z = loc_z;
    5178    }
    5279
    5380    float z() const
    5481    {
    55         return _location.z;
     82        return _position.z;
    5683    }
    5784
    58     void rotate(double *quat);
     85    void orient(double *quat);
    5986
    60     void rotate(float angle_x, float angle_y, float angle_z);
     87    void orient(float angleX, float angleY, float angleZ);
    6188
    62     void fov(float fov)
     89    void setFov(float fov)
    6390    {
    6491        _fov = fov;
    6592    }
    6693
    67     float fov() const
     94    float getFov() const
    6895    {
    6996        return _fov;
     
    74101               bool resetOrientation = false);
    75102
    76     void setClippingRange(float near, float far)
    77     {
    78         _near = near;
    79         _far = far;
    80     }
    81 
    82103    void resetClippingRange(const vrmath::Vector3f& bboxMin,
    83104                            const vrmath::Vector3f& bboxMax);
    84105
    85     void setScreenSize(int sx, int sy, int w, int h)
     106    void setViewport(int x, int y, int width, int height)
    86107    {
    87         _width = w;
    88         _height = h;
    89         _startX = sx;
    90         _startY = sy;
     108        _viewport[0] = x;
     109        _viewport[1] = y;
     110        _viewport[2] = width;
     111        _viewport[3] = height;
    91112    }
    92113
     
    99120    void print() const;
    100121
     122    void getProjectionMatrix(vrmath::Matrix4x4d& mat);
     123
     124    const vrmath::Matrix4x4d& getUpDirMatrix() const;
     125
    101126private:
    102     void getUpDirMatrix(vrmath::Matrix4x4d& upMat);
     127    void setClippingRange(float near, float far)
     128    {
     129        _near = near;
     130        _far = far;
     131    }
    103132
    104     /// Location of the camera in the scene
    105     vrmath::Vector3f _location;
    106     /// Camera view matrix (orientation only, no translation)
    107     vrmath::Matrix4x4d _cameraMatrix;
     133    void setUpDirMatrix(AxisDirection dir);
     134
     135    AxisDirection _updir;
     136
     137    /// Position of the camera in the scene
     138    vrmath::Vector3f _position;
     139
     140    /// Model transform for z-up scene
     141    vrmath::Matrix4x4d _updirMatrix;
     142    /// Camera orientation
     143    vrmath::Matrix4x4d _rotationMatrix;
     144
    108145    /// Field of view (vertical angle in degrees)
    109146    float _fov;
     
    111148    float _near, _far;
    112149
    113     /// screen width
    114     int _width;
    115     /// screen height
    116     int _height;
    117     int _startX;
    118     int _startY;
     150    // x, y, width, height
     151    int _viewport[4];
    119152};
    120153
  • nanovis/branches/1.1/CmdProc.cpp

    r4893 r4904  
    117117nv::GetOpFromObj(Tcl_Interp *interp,    /* Interpreter to report errors to */
    118118                 int nSpecs,            /* Number of specifications in array */
    119                  CmdSpec *specs,                /* Op specification array */
     119                 CmdSpec *specs,        /* Op specification array */
    120120                 int operPos,           /* Position of operation in argument
    121121                                         * list. */
  • nanovis/branches/1.1/ColorTableShader.cpp

    r4889 r4904  
    1919void ColorTableShader::init()
    2020{
    21     loadFragmentProgram("one_plane.cg", "main");
     21    loadFragmentProgram("one_plane.cg");
    2222}
    2323
  • nanovis/branches/1.1/Command.cpp

    r4893 r4904  
    3737#include <unistd.h>                     /* Needed for getpid, gethostname,
    3838                                         * write, etc. */
     39
     40#include <sstream>
     41
    3942#include <tcl.h>
    4043
    4144#include <RpEncode.h>
    42 #include <RpOutcome.h>
    4345#include <RpBuffer.h>
    4446
     
    569571        return TCL_ERROR;
    570572    }
    571     NanoVis::cam->rotate(phi, theta, psi);
     573    NanoVis::rotateCamera(phi, theta, psi);
    572574    return TCL_OK;
    573575}
     
    584586        return TCL_ERROR;
    585587    }
    586     NanoVis::cam->rotate(quat);
     588    NanoVis::orientCamera(quat);
    587589    return TCL_OK;
    588590}
     
    597599        return TCL_ERROR;
    598600    }
    599     NanoVis::pan(x, y);
     601    NanoVis::panCamera(x, y);
    600602    return TCL_OK;
    601603}
     
    605607                 Tcl_Obj *const *objv)
    606608{
    607     float x, y, z;
    608     if ((GetFloatFromObj(interp, objv[2], &x) != TCL_OK) ||
    609         (GetFloatFromObj(interp, objv[3], &y) != TCL_OK) ||
    610         (GetFloatFromObj(interp, objv[4], &z) != TCL_OK)) {
    611         return TCL_ERROR;
    612     }
    613     NanoVis::cam->x(x);
    614     NanoVis::cam->y(y);
    615     NanoVis::cam->z(z);
     609    Vector3f pos;
     610    if ((GetFloatFromObj(interp, objv[2], &pos.x) != TCL_OK) ||
     611        (GetFloatFromObj(interp, objv[3], &pos.y) != TCL_OK) ||
     612        (GetFloatFromObj(interp, objv[4], &pos.z) != TCL_OK)) {
     613        return TCL_ERROR;
     614    }
     615    NanoVis::setCameraPosition(pos);
    616616    return TCL_OK;
    617617}
     
    644644        return TCL_ERROR;
    645645    }
    646     NanoVis::zoom(z);
     646    NanoVis::zoomCamera(z);
    647647    return TCL_OK;
    648648}
     
    721721    std::vector<Volume *>::iterator iter;
    722722    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
    723         (*iter)->moveCutplane(axis, relval);
     723        (*iter)->setCutplanePosition(axis, relval);
    724724    }
    725725    return TCL_OK;
     
    10981098                }
    10991099            }
     1100
    11001101            alphaKeys[i/2] = (float)q[0];
    11011102            alphas[i/2] = (float)q[1];
     
    11531154        return TCL_ERROR;
    11541155    }
    1155     NanoVis::updir = (axis+1)*sign;
     1156    NanoVis::setCameraUpdir(Camera::AxisDirection((axis+1)*sign));
    11561157    return TCL_OK;
    11571158}
     
    12831284    if ((nBytes > 5) && (strncmp(bytes, "<HDR>", 5) == 0)) {
    12841285        TRACE("ZincBlende Stream loading...");
    1285         volume = ZincBlendeReconstructor::getInstance()->loadFromMemory(buf.bytes());
     1286        volume = ZincBlendeReconstructor::getInstance()->loadFromMemory(bytes);
    12861287        if (volume == NULL) {
    12871288            Tcl_AppendResult(interp, "can't get volume instance", (char *)NULL);
     
    12911292
    12921293        Vector3f scale = volume->getPhysicalScaling();
    1293         Vector3f loc(scale);
    1294         loc *= -0.5;
    1295         volume->location(loc);
     1294        Vector3f pos(scale);
     1295        pos *= -0.5;
     1296        volume->setPosition(pos);
    12961297
    12971298        NanoVis::VolumeHashmap::iterator itr = NanoVis::volumeTable.find(tag);
     
    13051306    } else if ((nBytes > 14) && (strncmp(bytes, "# vtk DataFile", 14) == 0)) {
    13061307        TRACE("VTK loading...");
    1307         std::stringstream fdata;
    1308         fdata.write(bytes, nBytes);
    13091308        if (nBytes <= 0) {
    13101309            ERROR("data buffer is empty");
    13111310            abort();
    13121311        }
    1313         Rappture::Outcome context;
    1314         volume = load_vtk_volume_stream(context, tag, fdata);
     1312        std::stringstream fdata;
     1313        fdata.write(bytes, nBytes);
     1314        volume = load_vtk_volume_stream(tag, fdata);
    13151315        if (volume == NULL) {
    1316             Tcl_AppendResult(interp, context.remark(), (char*)NULL);
     1316            Tcl_AppendResult(interp, "Failed to load VTK file", (char*)NULL);
    13171317            return TCL_ERROR;
    13181318        }
     
    13331333        std::stringstream fdata;
    13341334        fdata.write(bytes, nBytes);
    1335         Rappture::Outcome context;
    1336         volume = load_dx_volume_stream(context, tag, fdata);
     1335        volume = load_dx_volume_stream(tag, fdata);
    13371336        if (volume == NULL) {
    1338             Tcl_AppendResult(interp, context.remark(), (char*)NULL);
     1337            Tcl_AppendResult(interp, "Failed to load DX file", (char*)NULL);
    13391338            return TCL_ERROR;
    13401339        }
     
    13621361        }
    13631362    }
     1363
    13641364    return TCL_OK;
    13651365}
     
    17661766    }
    17671767    Unirect2d data(1);
    1768     if (data.parseBuffer(interp, buf) != TCL_OK) {
     1768    if (data.parseBuffer(interp, buf.bytes(), buf.size()) != TCL_OK) {
    17691769        return TCL_ERROR;
    17701770    }
  • nanovis/branches/1.1/Flow.cpp

    r4893 r4904  
    99 *   Leif Delgass <ldelgass@purdue.edu>
    1010 */
     11
     12#include <float.h>
    1113
    1214#include <tcl.h>
     
    3133using namespace vrmath;
    3234
     35bool Flow::updatePending = false;
     36
    3337Flow::Flow(Tcl_Interp *interp, const char *name) :
    3438    _interp(interp),
     
    8185        return;
    8286
    83 #if 0  // Using volume bounds instead of these
    84     if (isDataLoaded()) {
    85         Vector3f umin, umax;
    86         Rappture::Unirect3d *unirect = data();
    87         unirect->getWorldSpaceBounds(umin, umax);
    88         if (min.x > umin.x) {
    89             min.x = umin.x;
    90         }
    91         if (max.x < umax.x) {
    92             max.x = umax.x;
    93         }
    94         if (min.y > umin.y) {
    95             min.y = umin.y;
    96         }
    97         if (max.y < umax.y) {
    98             max.y = umax.y;
    99         }
    100         if (min.z > umin.z) {
    101             min.z = umin.z;
    102         }
    103         if (max.z < umax.z) {
    104             max.z = umax.z;
    105         }
    106     }
    107 #endif
    10887    for (BoxHashmap::iterator itr = _boxTable.begin();
    10988         itr != _boxTable.end(); ++itr) {
     
    155134}
    156135
    157 float
    158 Flow::getRelativePosition()
    159 {
    160     return getRelativePosition(&_sv.slicePos);
    161 }
    162 
    163136void
    164137Flow::resetParticles()
     
    314287
    315288    Vector3f scale = volume->getPhysicalScaling();
    316     Vector3f location = _volume->location();
     289    Vector3f pos = _volume->getPosition();
    317290
    318291    if (NanoVis::licRenderer != NULL) {
    319292        NanoVis::licRenderer->
    320293            setVectorField(_volume->textureID(),
    321                            location,
     294                           pos,
    322295                           scale.x,
    323296                           scale.y,
    324297                           scale.z,
    325298                           _volume->wAxis.max());
    326         setCurrentPosition();
    327         setAxis();
    328         setActive();
     299        NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
     300        NanoVis::licRenderer->setSlicePosition(_sv.slicePos.value);
     301        NanoVis::licRenderer->visible(_sv.sliceVisible);
    329302    }
    330303
     
    332305        NanoVis::velocityArrowsSlice->
    333306            setVectorField(_volume->textureID(),
    334                            location,
     307                           pos,
    335308                           scale.x,
    336309                           scale.y,
    337310                           scale.z,
    338311                           _volume->wAxis.max());
    339         NanoVis::velocityArrowsSlice->axis(_sv.slicePos.axis);
    340         NanoVis::velocityArrowsSlice->slicePos(_sv.slicePos.value);
    341         NanoVis::velocityArrowsSlice->enabled(_sv.showArrows);
     312        NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
     313        NanoVis::velocityArrowsSlice->setSlicePosition(_sv.slicePos.value);
     314        NanoVis::velocityArrowsSlice->visible(_sv.showArrows);
    342315    }
    343316
     
    345318         itr != _particlesTable.end(); ++itr) {
    346319        itr->second->setVectorField(_volume,
    347                                     location,
     320                                    pos,
    348321                                    scale.x,
    349322                                    scale.y,
     
    433406
    434407    Vector3f volScaling = volume->getPhysicalScaling();
    435     Vector3f loc(volScaling);
    436     loc *= -0.5;
    437     volume->location(loc);
     408    Vector3f pos(volScaling);
     409    pos *= -0.5;
     410    volume->setPosition(pos);
    438411
    439412    Volume::updatePending = true;
  • nanovis/branches/1.1/Flow.h

    r4893 r4904  
    5050{
    5151public:
    52     enum SliceAxis { AXIS_X, AXIS_Y, AXIS_Z };
    53 
    5452    Flow(Tcl_Interp *interp, const char *name);
    5553
     
    117115        _data = unirect;
    118116    }
     117
     118    FlowSliceAxis getSliceAxis()
     119    {
     120        return _sv.slicePos.axis;
     121    }
     122
     123    TransferFunction *getTransferFunction()
     124    {
     125        return _sv.transferFunction;
     126    }
     127
     128    float getRelativePosition()
     129    {
     130        return getRelativePosition(&_sv.slicePos);
     131    }
     132
    119133#if 0
    120     void activateSlice()
    121     {
    122         /* Must set axis before offset or position goes to wrong axis. */
    123         NanoVis::licRenderer->setAxis(_sv.slicePos.axis);
    124         NanoVis::licRenderer->setOffset(_sv.slicePos.value);
    125         NanoVis::licRenderer->active(true);
    126     }
    127 
    128     void deactivateSlice()
    129     {
    130         NanoVis::licRenderer->active(false);
     134    void setSliceAxis(FlowSliceAxis axis)
     135    {
     136        _sv.slicePos.axis = axis;
     137        if (NanoVis::licRenderer != NULL) {
     138            NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
     139        }
     140        if (NanoVis::velocityArrowsSlice != NULL) {
     141            NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
     142        }
     143    }
     144
     145    void setCurrentPosition(float position)
     146    {
     147        _sv.slicePos.value = position;
     148        if (NanoVis::licRenderer != NULL) {
     149            NanoVis::licRenderer->setSlicePosition(_sv.slicePos.value);
     150        }
     151        if (NanoVis::velocityArrowsSlice != NULL) {
     152            NanoVis::velocityArrowsSlice->setSlicePosition(_sv.slicePos.value);
     153        }
     154    }
     155
     156    void setLICActive(bool state)
     157    {
     158        _sv.sliceVisible = state;
     159        if (NanoVis::licRenderer != NULL) {
     160            NanoVis::licRenderer->setVectorField(_volume);
     161            NanoVis::licRenderer->setSliceAxis(_sv.slicePos.axis);
     162            NanoVis::licRenderer->setSlicePosition(_sv.slicePos.value);
     163            NanoVis::licRenderer->visible(state);
     164        }
     165    }
     166
     167    void setArrowsActive(bool state)
     168        _sv.showArrows = state;
     169        if (NanoVis::velocityArrowsSlice != NULL) {
     170            NanoVis::velocityArrowsSlice->setVectorField(_volume);
     171            NanoVis::velocityArrowsSlice->setSliceAxis(_sv.slicePos.axis);
     172            NanoVis::velocityArrowsSlice->setSlicePosition(_sv.slicePos.value);
     173            NanoVis::velocityArrowsSlice->visible(_sv.showArrows);
     174        }
    131175    }
    132176#endif
    133     SliceAxis getAxis()
    134     {
    135         return (SliceAxis)_sv.slicePos.axis;
    136     }
    137 
    138     TransferFunction *getTransferFunction()
    139     {
    140         return _sv.transferFunction;
    141     }
    142 
    143     float getRelativePosition();
    144 
    145     void setAxis()
    146     {
    147         NanoVis::licRenderer->setAxis(_sv.slicePos.axis);
    148     }
    149 
    150     void setAxis(Flow::SliceAxis axis)
    151     {
    152         _sv.slicePos.axis = axis;
    153         NanoVis::licRenderer->setAxis(_sv.slicePos.axis);
    154     }
    155 
    156     void setCurrentPosition(float position)
    157     {
    158         _sv.slicePos.value = position;
    159         NanoVis::licRenderer->setOffset(_sv.slicePos.value);
    160     }
    161 
    162     void setCurrentPosition()
    163     {
    164         NanoVis::licRenderer->setOffset(_sv.slicePos.value);
    165     }
    166 
    167     void setActive(bool state)
    168     {
    169         _sv.sliceVisible = state;
    170         NanoVis::licRenderer->active(state);
    171     }
    172 
    173     void setActive()
    174     {
    175         NanoVis::licRenderer->active(_sv.sliceVisible);
    176     }
    177 
    178177    const Volume *getVolume() const
    179178    {
     
    196195
    197196    static float getRelativePosition(FlowPosition *pos);
     197
     198    static bool updatePending;
    198199
    199200private:
     
    202203    typedef std::tr1::unordered_map<ParticlesId, FlowParticles *> ParticlesHashmap;
    203204    typedef std::tr1::unordered_map<BoxId, FlowBox *> BoxHashmap;
    204 
    205     void configure();
    206205
    207206    void renderBoxes();
  • nanovis/branches/1.1/FlowBox.cpp

    r4893 r4904  
    5252    bboxMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
    5353
    54     Vector3f origin = vol->location();
     54    Vector3f origin = vol->getPosition();
    5555    Vector3f scale = vol->getPhysicalScaling();
    5656
     
    131131    glPushMatrix();
    132132
    133     Vector3f origin = vol->location();
     133    Vector3f origin = vol->getPosition();
    134134    glTranslatef(origin.x, origin.y, origin.z);
    135135
  • nanovis/branches/1.1/FlowCmd.cpp

    r4893 r4904  
    55 */
    66#include <assert.h>
     7#include <errno.h>
    78#define _OPEN_SYS
    89#include <fcntl.h>
     
    1718#include <poll.h>
    1819
     20#include <sstream>
     21
    1922#include <tcl.h>
    2023
    21 #include <RpOutcome.h>
    2224#include <RpBuffer.h>
    2325
     
    138140                  Tcl_Obj *const *objv)
    139141{
    140     Rappture::Outcome result;
    141 
    142142    TRACE("Enter");
    143143
     
    177177    if ((length > 4) && (strncmp(bytes, "<DX>", 4) == 0)) {
    178178        unirect = new Unirect3d(nComponents);
    179         if (!unirect->importDx(result, nComponents, length - 4, bytes + 4)) {
    180             Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     179        if (!unirect->importDx(nComponents, length - 4, bytes + 4)) {
     180            Tcl_AppendResult(interp, "Failed to load DX file", (char *)NULL);
    181181            delete unirect;
    182182            return TCL_ERROR;
     
    184184    } else if ((length > 10) && (strncmp(bytes, "unirect3d ", 10) == 0)) {
    185185        unirect = new Unirect3d(nComponents);
    186         if (unirect->parseBuffer(interp, buf) != TCL_OK) {
     186        if (unirect->parseBuffer(interp, bytes, length) != TCL_OK) {
    187187            delete unirect;
    188188            return TCL_ERROR;
    189189        }
    190190    } else if ((length > 10) && (strncmp(bytes, "unirect2d ", 10) == 0)) {
    191         unirect = new Unirect3d(nComponents);
    192191        Unirect2d *u2dPtr = new Unirect2d(nComponents);
    193         if (u2dPtr->parseBuffer(interp, buf) != TCL_OK) {
     192        if (u2dPtr->parseBuffer(interp, bytes, length) != TCL_OK) {
    194193            delete u2dPtr;
    195194            return TCL_ERROR;
    196195        }
     196        unirect = new Unirect3d(nComponents);
    197197        unirect->convert(u2dPtr);
    198198        delete u2dPtr;
     
    200200        TRACE("header is %.14s", buf.bytes());
    201201        unirect = new Unirect3d(nComponents);
    202         if (!unirect->importDx(result, nComponents, length, bytes)) {
    203             Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     202        if (!unirect->importDx(nComponents, length, bytes)) {
     203            Tcl_AppendResult(interp, "Failed to load DX file", (char *)NULL);
    204204            delete unirect;
    205205            return TCL_ERROR;
    206206        }
    207207    }
    208     if (unirect->nValues() == 0) {
     208    if (unirect != NULL && unirect->nValues() == 0) {
    209209        delete unirect;
    210210        Tcl_AppendResult(interp, "no data found in stream", (char *)NULL);
    211211        return TCL_ERROR;
    212212    }
    213     TRACE("nx = %d ny = %d nz = %d",
    214           unirect->xNum(), unirect->yNum(), unirect->zNum());
    215     TRACE("x0 = %lg y0 = %lg z0 = %lg",
    216           unirect->xMin(), unirect->yMin(), unirect->zMin());
    217     TRACE("lx = %lg ly = %lg lz = %lg",
    218           unirect->xMax() - unirect->xMin(),
    219           unirect->yMax() - unirect->yMin(),
    220           unirect->zMax() - unirect->zMin());
    221     TRACE("dx = %lg dy = %lg dz = %lg",
    222           unirect->xNum() > 1 ? (unirect->xMax() - unirect->xMin())/(unirect->xNum()-1) : 0,
    223           unirect->yNum() > 1 ? (unirect->yMax() - unirect->yMin())/(unirect->yNum()-1) : 0,
    224           unirect->zNum() > 1 ? (unirect->zMax() - unirect->zMin())/(unirect->zNum()-1) : 0);
    225     TRACE("magMin = %lg magMax = %lg",
    226           unirect->magMin(), unirect->magMax());
    227     flow->data(unirect);
    228     {
     213    if (unirect != NULL) {
     214        TRACE("nx = %d ny = %d nz = %d",
     215              unirect->xNum(), unirect->yNum(), unirect->zNum());
     216        TRACE("x0 = %lg y0 = %lg z0 = %lg",
     217              unirect->xMin(), unirect->yMin(), unirect->zMin());
     218        TRACE("lx = %lg ly = %lg lz = %lg",
     219              unirect->xMax() - unirect->xMin(),
     220              unirect->yMax() - unirect->yMin(),
     221              unirect->zMax() - unirect->zMin());
     222        TRACE("dx = %lg dy = %lg dz = %lg",
     223              unirect->xNum() > 1 ? (unirect->xMax() - unirect->xMin())/(unirect->xNum()-1) : 0,
     224              unirect->yNum() > 1 ? (unirect->yMax() - unirect->yMin())/(unirect->yNum()-1) : 0,
     225              unirect->zNum() > 1 ? (unirect->zMax() - unirect->zMin())/(unirect->zNum()-1) : 0);
     226        TRACE("magMin = %lg magMax = %lg",
     227              unirect->magMin(), unirect->magMax());
     228        flow->data(unirect);
     229
    229230        char info[1024];
    230231        int length =
     
    235236        }
    236237    }
    237     NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     238    Flow::updatePending = true;
     239    NanoVis::eventuallyRedraw();
    238240    return TCL_OK;
    239241}
     
    280282    const char *string = Tcl_GetString(objPtr);
    281283    if (string[1] == '\0') {
    282         Flow::SliceAxis *axisPtr = (Flow::SliceAxis *)(record + offset);
     284        FlowSliceAxis *axisPtr = (FlowSliceAxis *)(record + offset);
    283285        char c;
    284286        c = tolower((unsigned char)string[0]);
    285287        if (c == 'x') {
    286             *axisPtr = Flow::AXIS_X;
     288            *axisPtr = AXIS_X;
    287289            return TCL_OK;
    288290        } else if (c == 'y') {
    289             *axisPtr = Flow::AXIS_Y;
     291            *axisPtr = AXIS_Y;
    290292            return TCL_OK;
    291293        } else if (c == 'z') {
    292             *axisPtr = Flow::AXIS_Z;
     294            *axisPtr = AXIS_Z;
    293295            return TCL_OK;
    294296        }
     
    491493        return TCL_ERROR;
    492494    }
    493     NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     495    Flow::updatePending = true;
     496    NanoVis::eventuallyRedraw();
    494497    return TCL_OK;
    495498}
     
    514517    }
    515518    particles->configure();
     519    Flow::updatePending = true;
    516520    NanoVis::eventuallyRedraw();
    517521    Tcl_SetObjResult(interp, objv[3]);
     
    535539        return TCL_ERROR;
    536540    }
    537     particles->configure();
    538     NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     541    if (particles->configure()) {
     542        Flow::updatePending = true;
     543    }
     544    NanoVis::eventuallyRedraw();
    539545    return TCL_OK;
    540546}
     
    742748        return TCL_ERROR;
    743749    }
    744     if (NanoVis::flags & NanoVis::MAP_FLOWS) {
    745         NanoVis::mapFlows();
     750    if (Flow::updatePending) {
     751        NanoVis::setFlowRanges();
    746752    }
    747753    NanoVis::renderLegend(tf, NanoVis::magMin, NanoVis::magMax, w, h, label);
     
    832838        }
    833839    }
    834     NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
     840    Flow::updatePending = true;
     841    NanoVis::eventuallyRedraw();
    835842    return TCL_OK;
    836843}
     
    866873    }
    867874    NanoVis::resetFlows();
    868     if (NanoVis::flags & NanoVis::MAP_FLOWS) {
    869         NanoVis::mapFlows();
    870     }
    871     NanoVis::advectFlows();
     875    if (Flow::updatePending) {
     876        NanoVis::setFlowRanges();
     877    }
    872878    for (int i = 0; i < nSteps; i++) {
    873         if (NanoVis::licRenderer->active()) {
    874             NanoVis::licRenderer->convolve();
    875         }
     879        NanoVis::licRenderer->convolve();
    876880        NanoVis::advectFlows();
    877881    }
     
    901905{
    902906    assert(NanoVis::licRenderer != NULL);
    903     if (NanoVis::flags & NanoVis::MAP_FLOWS) {
    904         NanoVis::mapFlows();
    905     }
    906     NanoVis::eventuallyRedraw();
     907    if (Flow::updatePending) {
     908        NanoVis::setFlowRanges();
     909    }
    907910    NanoVis::licRenderer->convolve();
    908911    NanoVis::advectFlows();
     912    NanoVis::eventuallyRedraw();
    909913    return TCL_OK;
    910914}
     
    918922}
    919923
    920 #ifdef HAVE_FFMPEG
     924#if defined(HAVE_FFMPEG) || defined(HAVE_AVCONV)
    921925
    922926/**
     
    10771081            break;
    10781082        }
    1079         if (NanoVis::licRenderer->active()) {
    1080             NanoVis::licRenderer->convolve();
    1081         }
     1083        NanoVis::licRenderer->convolve();
    10821084        NanoVis::advectFlows();
    10831085
     
    11111113          FlowVideoSwitches *switchesPtr)
    11121114{
    1113 #ifndef FFMPEG
    1114 #  define FFMPEG "/usr/bin/ffmpeg"
     1115    char cmd[BUFSIZ];
     1116#ifdef HAVE_AVCONV
     1117    /* Generate the movie from the frame images by exec-ing avconv */
     1118    /* The avconv command is
     1119     *   avconv -f image2 -i /var/tmp/xxxxx/image%d.ppm                 \
     1120     *      -f outformat -b bitrate -r framerate /var/tmp/xxxxx/movie.mpeg
     1121     */
     1122#ifndef AVCONV
     1123#  define AVCONV "/usr/bin/avconv"
    11151124#endif
     1125    sprintf(cmd, "%s -f image2 -i %s/image%%d.ppm -f %s -b %d -r %f -",
     1126            AVCONV, tmpFileName, Tcl_GetString(switchesPtr->formatObjPtr),
     1127            switchesPtr->bitRate, switchesPtr->frameRate);
     1128#else
    11161129    /* Generate the movie from the frame images by exec-ing ffmpeg */
    11171130    /* The ffmpeg command is
     
    11191132     *      -b bitrate -f framerate /var/tmp/xxxxx/movie.mpeg
    11201133     */
    1121     char cmd[BUFSIZ];
     1134#ifndef FFMPEG
     1135#  define FFMPEG "/usr/bin/ffmpeg"
     1136#endif
    11221137    sprintf(cmd, "%s -f image2 -i %s/image%%d.ppm -f %s -b %d -r %f -",
    11231138            FFMPEG, tmpFileName, Tcl_GetString(switchesPtr->formatObjPtr),
    11241139            switchesPtr->bitRate, switchesPtr->frameRate);
     1140#endif
    11251141    TRACE("Enter: %s", cmd);
    11261142    FILE *f = popen(cmd, "r");
  • nanovis/branches/1.1/FlowParticles.cpp

    r4893 r4904  
    2828    _sv.position.value = 0.0f;
    2929    _sv.position.flags = RELPOS;
    30     _sv.position.axis = 0; // X_AXIS
     30    _sv.position.axis = AXIS_Z;
    3131    _sv.color.r = _sv.color.g = _sv.color.b = _sv.color.a = 1.0f;
    3232    _sv.isHidden = false;
     
    5151          Flow::getRelativePosition(&_sv.position));
    5252
    53     _renderer->setPos(Flow::getRelativePosition(&_sv.position));
    54     _renderer->setAxis(_sv.position.axis);
     53    _renderer->setSlicePosition(Flow::getRelativePosition(&_sv.position));
     54    _renderer->setSliceAxis(_sv.position.axis);
    5555    assert(_renderer->active());
    5656    _renderer->render();
    5757}
    5858
    59 void
     59bool
    6060FlowParticles::configure()
    6161{
    62     _renderer->setPos(Flow::getRelativePosition(&_sv.position));
     62    bool needReset = false;
     63
    6364    _renderer->setColor(Color4f(_sv.color.r,
    6465                                _sv.color.g,
     
    6667                                _sv.color.a));
    6768    _renderer->particleSize(_sv.particleSize);
    68     _renderer->setAxis(_sv.position.axis);
     69    if (_renderer->getSliceAxis() != _sv.position.axis) {
     70        needReset = true;
     71        _renderer->setSliceAxis(_sv.position.axis);
     72    }
     73    float pos = Flow::getRelativePosition(&_sv.position);
     74    if (_renderer->getSlicePosition() != pos) {
     75        needReset = true;
     76        _renderer->setSlicePosition(pos);
     77    }
    6978    _renderer->active(!_sv.isHidden);
     79
     80    return needReset;
    7081}
  • nanovis/branches/1.1/FlowParticles.h

    r4893 r4904  
    9090    }
    9191
    92     void configure();
     92    bool configure();
    9393
    9494private:
  • nanovis/branches/1.1/FlowTypes.h

    r4889 r4904  
    1414namespace nv {
    1515
     16enum FlowSliceAxis {
     17    AXIS_X,
     18    AXIS_Y,
     19    AXIS_Z
     20};
     21
    1622struct FlowColor {
    1723    float r, g, b, a;
     
    2531    float value;
    2632    unsigned int flags;
    27     int axis;
     33    FlowSliceAxis axis;
    2834};
    2935
  • nanovis/branches/1.1/Grid.cpp

    r4890 r4904  
    2020
    2121#define NUMDIGITS       6
    22 #define GRID_TICK       0.05
     22#define TICK_LENGTH     0.05
     23#define LABEL_OFFSET    0.06
     24#define TITLE_OFFSET    0.2
    2325
    2426Grid::Grid() :
     
    3840}
    3941
     42void Grid::getBounds(vrmath::Vector3f& bboxMin, vrmath::Vector3f& bboxMax) const
     43{
     44    bboxMin.set(xAxis.min(), yAxis.min(), zAxis.min());
     45    bboxMax.set(xAxis.min() + xAxis.range(),
     46                yAxis.min() + yAxis.range(),
     47                zAxis.min() + zAxis.range());
     48}
     49
    4050void Grid::render()
    4151{
     
    4757    glEnable(GL_DEPTH_TEST);
    4858    glDisable(GL_TEXTURE_2D);
     59#ifdef notdef
    4960    glEnable(GL_BLEND);
    50 #ifdef notdef
    5161    glEnable(GL_LINE_SMOOTH);
     62#else
     63    glDisable(GL_BLEND);
    5264#endif
    5365
     
    7082    double yoffset = (yAxis.min() - yAxis.dataMin()) * yAxis.scale();
    7183    double zoffset = (zAxis.min() - zAxis.dataMin()) * zAxis.scale();
     84
     85    float xTickLen = TICK_LENGTH;
     86    float yTickLen = TICK_LENGTH;
     87    float zTickLen = TICK_LENGTH;
     88    float xLabelOfs = LABEL_OFFSET;
     89    //float yLabelOfs = LABEL_OFFSET;
     90    float zLabelOfs = LABEL_OFFSET;
     91    float xTitleOfs = TITLE_OFFSET;
     92    float yTitleOfs = TITLE_OFFSET;
     93    float zTitleOfs = TITLE_OFFSET;
    7294
    7395    TRACE("Axis ranges: %g %g %g", xAxis.range(), yAxis.range(), zAxis.range());
     
    89111
    90112    glLineWidth(2.0f);
    91     glColor4f(_axisColor.r, _axisColor.g, _axisColor.b, 
     113    glColor4f(_axisColor.r, _axisColor.g, _axisColor.b,
    92114              _axisColor.a);
    93115
     
    95117    {
    96118        glVertex3f(0.0f, 0.0f, 0.0f);
    97         glVertex3f(1.0f + GRID_TICK, 0.0f, 0.0f);
     119        glVertex3f(1.0f + xTickLen, 0.0f, 0.0f);
    98120        glVertex3f(0.0f, 0.0f, 0.0f);
    99         glVertex3f(0.0f, 1.0f + GRID_TICK, 0.0f);
     121        glVertex3f(0.0f, 1.0f + yTickLen, 0.0f);
    100122        glVertex3f(0.0f, 0.0f, 0.0f);
    101         glVertex3f(0.0f, 0.0f, 1.0f + GRID_TICK);
     123        glVertex3f(0.0f, 0.0f, 1.0f + zTickLen);
    102124    }
    103125    glEnd();
    104126
    105127    glLineWidth(1.0f);
    106     glColor4f(_majorColor.r, _majorColor.g, _majorColor.b, 
     128    glColor4f(_majorColor.r, _majorColor.g, _majorColor.b,
    107129              _majorColor.a);
    108130
     
    118140            glVertex3f(x, 1.0f, 0.0f);
    119141            glVertex3f(x, 0.0f, 0.0f);
    120             glVertex3f(x, 0.0f, 1.0f + GRID_TICK);
     142            glVertex3f(x, 0.0f, 1.0f + zTickLen);
    121143        }
    122144        for (result = yAxis.firstMajor(iter); result; result = iter.next()) {
     
    124146            y = yAxis.map(iter.getValue());
    125147            glVertex3f(0.0f, y, 0.0f);
    126             glVertex3f(1.0f + GRID_TICK, y, 0.0f);
     148            glVertex3f(1.0f + xTickLen, y, 0.0f);
    127149            glVertex3f(0.0f, y, 0.0f);
    128150            glVertex3f(0.0f, y, 1.0f);
     
    134156            glVertex3f(0.0f, 1.0f, z);
    135157            glVertex3f(0.0f, 0.0f, z);
    136             glVertex3f(1.0f + GRID_TICK, 0.0f, z);
     158            glVertex3f(1.0f + xTickLen, 0.0f, z);
    137159        }
    138160    }
     
    185207        glGetDoublev(GL_PROJECTION_MATRIX, prjm);
    186208        glGetIntegerv(GL_VIEWPORT, viewport);
    187        
     209
    188210        _font->begin();
    189         if (gluProject(1.2, 0.0, 0.0, mv, prjm, viewport, &wx, &wy, &wz)) {
     211
     212        glColor4f(_axisColor.r, _axisColor.g, _axisColor.b,
     213                  _axisColor.a);
     214
     215        if (gluProject(1.0 + xTitleOfs, 0.0, 0.0,
     216                       mv, prjm, viewport,
     217                       &wx, &wy, &wz) &&
     218            wz >= 0.0 && wz <= 1.0) {
    190219            glLoadIdentity();
    191220            glTranslatef((int) wx, viewport[3] - (int) wy, 0);
     
    197226        }
    198227       
    199         if (gluProject(0.0, 1.2, 0.0, mv, prjm, viewport, &wx, &wy, &wz)) {
     228        if (gluProject(0.0, 1.0 + yTitleOfs, 0.0,
     229                       mv, prjm, viewport,
     230                       &wx, &wy, &wz) &&
     231            wz >= 0.0 && wz <= 1.0) {
    200232            glLoadIdentity();
    201233            glTranslatef((int) wx, viewport[3] - (int)wy, 0);
     
    207239        }
    208240       
    209         if (gluProject(0.0, 0.0, 1.2, mv, prjm, viewport, &wx, &wy, &wz)) {
     241        if (gluProject(0.0, 0.0, 1.0 + zTitleOfs,
     242                       mv, prjm, viewport,
     243                       &wx, &wy, &wz) &&
     244            wz >= 0.0 && wz <= 1.0) {
    210245            glLoadIdentity();
    211246            glTranslatef((int) wx, (int) viewport[3] - (int)wy, 0.0f);
     
    216251            _font->draw(name);
    217252        }
    218        
    219         glColor4f(1.0f, 1.0f, 0.0f, 1.0f);
     253
     254        glColor4f(_majorColor.r, _majorColor.g, _majorColor.b,
     255                  _majorColor.a);
    220256
    221257        for (result = xAxis.firstMajor(iter); result; result = iter.next()) {
    222258            float x;
    223259            x = xAxis.map(iter.getValue());
    224             if (gluProject(x, 0.0f, 1.06f, mv, prjm, viewport, &wx, &wy, &wz)) {
     260            if (gluProject(x, 0.0f, 1.0 + zLabelOfs,
     261                           mv, prjm, viewport,
     262                           &wx, &wy, &wz) &&
     263                wz >= 0.0 && wz <= 1.0) {
    225264                char buff[20];
    226265                glLoadIdentity();
     
    233272            float y;
    234273            y = yAxis.map(iter.getValue());
    235             if (gluProject(1.06f, y, 0.0f, mv, prjm, viewport, &wx, &wy, &wz)) {
     274            if (gluProject(1.0 + xLabelOfs, y, 0.0f,
     275                           mv, prjm, viewport,
     276                           &wx, &wy, &wz) &&
     277                wz >= 0.0 && wz <= 1.0) {
    236278                char buff[20];
    237279                glLoadIdentity();
     
    244286            float z;
    245287            z = zAxis.map(iter.getValue());
    246             if (gluProject(1.06f, 0.0f, z, mv, prjm, viewport, &wx, &wy, &wz)) {
     288            if (gluProject(1.0 + xLabelOfs, 0.0f, z,
     289                           mv, prjm, viewport,
     290                           &wx, &wy, &wz) &&
     291                wz >= 0.0 && wz <= 1.0) {
    247292                char buff[20];
    248293                glLoadIdentity();
  • nanovis/branches/1.1/Grid.h

    r4890 r4904  
    77#define NV_GRID_H
    88
     9#include <vrmath/Vector3f.h>
    910#include <vrmath/Color4f.h>
    1011
     
    4950    void setFont(nv::util::Fonts *font);
    5051
     52    void getBounds(vrmath::Vector3f& bboxMin,
     53                   vrmath::Vector3f& bboxMax) const;
     54
    5155    Axis xAxis;
    5256    Axis yAxis;
  • nanovis/branches/1.1/HeightMap.cpp

    r4889 r4904  
    4040{
    4141    _shader = new Shader();
    42     _shader->loadFragmentProgram("heightcolor.cg", "main");
     42    _shader->loadFragmentProgram("heightcolor.cg");
    4343}
    4444
     
    493493                               Vector3f& bboxMax) const
    494494{
    495     bboxMin.set(FLT_MAX, FLT_MAX, FLT_MAX);
    496     bboxMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
    497 
    498    
    499 }
     495    bboxMin.set(xAxis.min(), yAxis.min(), zAxis.min());
     496    bboxMax.set(xAxis.max(), yAxis.max(), zAxis.max());
     497}
  • nanovis/branches/1.1/LIC.cpp

    r4889 r4904  
    2525using namespace vrmath;
    2626
    27 LIC::LIC(int size, int width, int height, int axis,
    28          float offset) :
    29     _width(width),
    30     _height(height),
    31     _size(size),
     27LIC::LIC(FlowSliceAxis axis, float offset) :
     28    _width(NPIX),
     29    _height(NPIX),
     30    _size(NMESH),
    3231    _scale(1.0f, 1.0f, 1.0f),
    3332    _origin(0, 0, 0),
     
    4241    _disListID(0),
    4342    _vectorFieldId(0),
    44     _activate(false)
    45 {
    46     _sliceVector = new float[_size*_size*4];
     43    _visible(false)
     44{
     45    _sliceVector = new float[_size * _size * 4];
    4746    memset(_sliceVector, 0, sizeof(float) * _size * _size * 4);
    4847
     
    5756    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    5857    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    59     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    60 
    6158    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, NPN, NPN, 0,
    6259                 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     
    6562    //render buffer for projecting 3D velocity onto a 2D plane
    6663    glGenFramebuffersEXT(1, &_velFbo);
     64    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _velFbo);
     65
    6766    glGenTextures(1, &_sliceVectorTex);
    68 
    69     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _velFbo);
    70 
    7167    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, _sliceVectorTex);
    7268    glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    7369    glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    74     glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    75     glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    76 
     70    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     71    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    7772    glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA32F_ARB, _size, _size,
    7873                 0, GL_RGBA, GL_FLOAT, NULL);
     
    8378    //render buffer for the convolution
    8479    glGenFramebuffersEXT(1, &_fbo);
     80    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
     81
     82    //initialize color texture for lic
    8583    glGenTextures(1, &_colorTex);
    86 
    87     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
    88 
    89     //initialize color texture for lic
    9084    glBindTexture(GL_TEXTURE_2D, _colorTex);
    9185    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    9286    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    93     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    94 
     87    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     88    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    9589    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, _width, _height, 0,
    9690                 GL_RGB, GL_UNSIGNED_BYTE, NULL);
     
    10599
    106100    _renderVelShader = new Shader();
    107     _renderVelShader->loadFragmentProgram("render_vel.cg", "main");
     101    _renderVelShader->loadFragmentProgram("render_vel.cg");
    108102
    109103    makePatterns();
     
    179173}
    180174
    181 void LIC::makeMagnitudes()
     175void
     176LIC::makeMagnitudes()
    182177{
    183178    GLubyte mag[NMESH][NMESH][4];
     
    209204    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    210205    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    211     //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
    212206    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, NMESH, NMESH, 0, GL_RGBA,
    213207                 GL_UNSIGNED_BYTE, mag);
     
    247241
    248242    switch (_axis) {
    249     case 0:
     243    case AXIS_X:
    250244        _renderVelShader->setFPParameter3f("projection_vector", 0., 1., 1.);
    251245        break;
    252     case 1:
     246    case AXIS_Y:
    253247        _renderVelShader->setFPParameter3f("projection_vector", 1., 0., 1.);
    254248        break;
    255249    default:
    256     case 2:
     250    case AXIS_Z:
    257251        _renderVelShader->setFPParameter3f("projection_vector", 1., 1., 0.);
    258252        break;
     
    262256    {
    263257        switch (_axis) {
    264         case 0:
     258        case AXIS_X:
    265259            glTexCoord3f(_offset, 0., 0.); glVertex2f(0.,    0.);
    266260            glTexCoord3f(_offset, 1., 0.); glVertex2f(_size, 0.);
     
    268262            glTexCoord3f(_offset, 0., 1.); glVertex2f(0.,    _size);
    269263            break;
    270         case 1:
     264        case AXIS_Y:
    271265            glTexCoord3f(0., _offset, 0.); glVertex2f(0.,    0.);
    272266            glTexCoord3f(1., _offset, 0.); glVertex2f(_size, 0.);
     
    274268            glTexCoord3f(0., _offset, 1.); glVertex2f(0.,    _size);
    275269            break;
    276         case 2:
     270        case AXIS_Z:
    277271            glTexCoord3f(0., 0., _offset); glVertex2f(0.,    0.);
    278272            glTexCoord3f(1., 0., _offset); glVertex2f(_size, 0.);
     
    328322    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
    329323
    330     glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     324    glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_TEXTURE_BIT);
    331325
    332326    glMatrixMode(GL_PROJECTION);
     
    352346    glEnable(GL_TEXTURE_2D);
    353347    glBindTexture(GL_TEXTURE_2D, _patternTex);
     348    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    354349    _sa = 0.01;
    355350 
     
    429424LIC::render()
    430425{
    431     if (_vectorFieldId == 0) {
     426    if (_vectorFieldId == 0 || !_visible) {
    432427        return;
    433428    }
     
    435430    //draw line integral convolution quad
    436431
    437     glPushAttrib(GL_ENABLE_BIT | GL_LIGHTING_BIT);
     432    glPushAttrib(GL_ENABLE_BIT | GL_LIGHTING_BIT | GL_TEXTURE_BIT);
    438433    glBindTexture(GL_TEXTURE_2D, _colorTex);
     434    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    439435    glEnable(GL_TEXTURE_2D);
    440436    //glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
     
    452448    glBegin(GL_QUADS);
    453449    switch (_axis) {
    454     case 0:
     450    case AXIS_X:
    455451        glNormal3f(1, 0, 0);
    456452        glTexCoord2f(0, 0); glVertex3f(_offset, 0, 0);
     
    459455        glTexCoord2f(0, 1); glVertex3f(_offset, 0, 1);
    460456        break;
    461     case 1:
     457    case AXIS_Y:
    462458        glNormal3f(0, 1, 0);
    463459        glTexCoord2f(0, 0); glVertex3f(0, _offset, 0);
     
    466462        glTexCoord2f(0, 1); glVertex3f(0, _offset, 1);
    467463        break;
    468     case 2:
     464    case AXIS_Z:
    469465        glNormal3f(0, 0, 1);
    470466        glTexCoord2f(0, 0); glVertex3f(0, 0, _offset);
     
    490486    _vectorFieldId = texID;
    491487    _origin = origin;
    492     _scale = Vector3f(scaleX, scaleY, scaleZ);
     488    _scale.set(scaleX, scaleY, scaleZ);
    493489    _max = max;
    494490
     
    508504    //TRACE("(xi yi) = (%d %d), ", xi, yi);
    509505   switch (_axis) {
    510    case 0:
     506   case AXIS_X:
    511507       vx = _sliceVector[4 * (xi+yi*_size)+2];
    512508       vy = _sliceVector[4 * (xi+yi*_size)+1];
    513509       break;
    514    case 1:
     510   case AXIS_Y:
    515511       vx = _sliceVector[4 * (xi+yi*_size)];
    516512       vy = _sliceVector[4 * (xi+yi*_size)+2];
    517513       break;
    518    case 2:
     514   case AXIS_Z:
    519515   default:
    520516       vx = _sliceVector[4 * (xi+yi*_size)];
     
    538534
    539535void
    540 LIC::setOffset(float offset)
     536LIC::setSlicePosition(float offset)
    541537{
    542538    _offset = offset;
     
    544540}
    545541
    546 void LIC::setAxis(int axis)
     542void LIC::setSliceAxis(FlowSliceAxis axis)
    547543{
    548544    _axis = axis;
  • nanovis/branches/1.1/LIC.h

    r4889 r4904  
    1313#include <vrmath/Vector3f.h>
    1414
     15#include "FlowTypes.h"
    1516#include "Volume.h"
    1617#include "Shader.h"
     
    2122{
    2223public:
    23     LIC(int size, int width, int height, int axis, float offset);
     24    LIC(FlowSliceAxis axis = AXIS_Z, float offset = 0.f);
    2425    ~LIC();
    2526
     
    3031    void render();
    3132
    32     void makePatterns();
     33    void setSlicePosition(float pos);
    3334
    34     void makeMagnitudes();
    35 
    36     void getVelocity(float x, float y, float *px, float *py);
    37 
    38     void getSlice();
    39 
    40     void setOffset(float offset);
     35    float getSlicePosition() const
     36    {
     37        return _offset;
     38    }
    4139
    4240    /**
    43      * @brief Specify the perpendicular axis
    44      *
    45      * 0 : x axis<br>
    46      * 1 : y axis<br>
    47      * 2 : z axis<br>
     41     * \brief Specify the perpendicular axis
    4842     */
    49     void setAxis(int axis);
     43    void setSliceAxis(FlowSliceAxis axis);
     44
     45    FlowSliceAxis getSliceAxis() const
     46    {
     47        return _axis;
     48    }
    5049
    5150    void setVectorField(unsigned int texID, const vrmath::Vector3f& origin,
     
    5655    void visible(bool state)
    5756    {
    58         _isHidden = !state;
     57        _visible = state;
    5958    }
    6059
    6160    bool visible() const
    6261    {
    63         return (!_isHidden);
    64     }
    65 
    66     void active(bool state)
    67     {
    68         _activate = state;
    69     }
    70 
    71     bool active() const
    72     {
    73         return _activate;
     62        return _visible;
    7463    }
    7564
    7665private:
     66    void getVelocity(float x, float y, float *px, float *py);
     67
     68    void getSlice();
     69
     70    void makePatterns();
     71
     72    void makeMagnitudes();
     73
    7774    /**
    78      * @brief the normal vector of the LIC plane,
     75     * \brief the normal vector of the LIC plane,
    7976     * the inherited Vector3 location is its center
    8077     */
     
    8683    float *_sliceVector;        /**< Storage for the per slice vectors
    8784                                   driving the flow */
    88     vrmath::Vector3f _scale;             /**< Scaling factor stretching the lic
     85    vrmath::Vector3f _scale;    /**< Scaling factor stretching the lic
    8986                                   plane to fit the actual dimensions */
    9087    vrmath::Vector3f _origin;
    91     float _offset;            ///< [0,1] offset of slice plane
    92     int _axis;                ///< Axis normal to slice plane
     88    float _offset;              ///< [0,1] offset of slice plane
     89    FlowSliceAxis _axis;        ///< Axis normal to slice plane
    9390
    9491    //some convolve variables. They can pretty much stay fixed
     
    114111     * flag for rendering
    115112     */
    116     bool _activate;
    117     bool _isHidden;                     // Indicates if LIC plane is displayed.
     113    bool _visible;                      // Indicates if LIC plane is displayed.
    118114};
    119115
  • nanovis/branches/1.1/Makefile.in

    r4890 r4904  
    3030
    3131GL_INC_SPEC     =
    32 GL_LIB_SPEC     = -lGL -lglut -lGLEW -lGLU
     32GL_LIB_SPEC     = -lglut -lGLEW -lGLU -lGL
    3333GRAPHICS_DIR      = ./graphics
    3434GRAPHICS_INC_SPEC = -I$(srcdir)/$(GRAPHICS_DIR)/include
     
    284284GradientFilter.o: GradientFilter.cpp GradientFilter.h
    285285Grid.o: Grid.cpp Grid.h Axis.h Chain.h $(UTIL_DIR)/Fonts.h $(VRMATH_DIR)/include/vrmath/Color4f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h
    286 HeightMap.o: HeightMap.cpp HeightMap.h
    287 LIC.o: LIC.cpp LIC.h define.h
     286HeightMap.o: HeightMap.cpp HeightMap.h Shader.h
     287LIC.o: LIC.cpp LIC.h FlowTypes.h Shader.h define.h
    288288ParticleAdvectionShader.o: ParticleAdvectionShader.cpp ParticleAdvectionShader.h Shader.h
    289289ParticleEmitter.o: ParticleEmitter.cpp ParticleEmitter.h
    290 ParticleRenderer.o: ParticleRenderer.cpp ParticleRenderer.h define.h
     290ParticleRenderer.o: ParticleRenderer.cpp ParticleRenderer.h FlowTypes.h define.h
    291291ParticleSystem.o: ParticleSystem.cpp ParticleSystem.h
    292292ParticleSystemFactory.o: ParticleSystemFactory.cpp ParticleSystemFactory.h
     
    311311TransferFunction.o: TransferFunction.cpp
    312312Unirect.o: Unirect.cpp Unirect.h Command.h Trace.h
    313 VelocityArrowsSlice.o: VelocityArrowsSlice.cpp VelocityArrowsSlice.h
     313VelocityArrowsSlice.o: VelocityArrowsSlice.cpp VelocityArrowsSlice.h nanovis.h FlowTypes.h Camera.h Volume.h Shader.h
    314314Volume.o: Volume.cpp Volume.h config.h define.h
    315315VolumeInterpolator.o: VolumeInterpolator.cpp VolumeInterpolator.h Volume.h
    316316VolumeRenderer.o: VolumeRenderer.cpp VolumeRenderer.h ConvexPolygon.h Volume.h nanovis.h Trace.h Plane.h StdVertexShader.h Shader.h
    317317VolumeShader.o: VolumeShader.cpp VolumeShader.h Shader.h
    318 VtkReader.o: VtkReader.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h nanovis.h
     318VtkReader.o: VtkReader.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h nanovis.h config.h
    319319ZincBlendeReconstructor.o: ZincBlendeReconstructor.cpp ZincBlendeReconstructor.h ZincBlendeVolume.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h
    320320ZincBlendeVolume.o: ZincBlendeVolume.cpp ZincBlendeVolume.h config.h define.h
  • nanovis/branches/1.1/ParticleAdvectionShader.cpp

    r4889 r4904  
    1212    _scale(1.0f, 1.0f, 1.0f),
    1313    _max(1.0f),
    14     _timeStep(0.0005f),
    15     _mode(1)
     14    _timeStep(0.0005f)
    1615{
    1716    init();
     
    2423void ParticleAdvectionShader::init()
    2524{
    26     loadFragmentProgram("update_pos.cg", "main");
     25    loadFragmentProgram("update_pos.cg");
    2726}
    2827
     
    3635    setFPParameter1f("timestep", _timeStep);
    3736    setFPParameter1f("max", _max);
    38     setFPParameter1f("mode", _mode);
    3937    setFPParameter3f("scale", _scale.x, _scale.y, _scale.z);
    4038
  • nanovis/branches/1.1/ParticleAdvectionShader.h

    r4889 r4904  
    4343    }
    4444
    45     void setRenderMode(int mode)
    46     {
    47         _mode = mode;
    48     }
    49 
    5045private:
    5146    void init();
     
    5550    float _max;
    5651    float _timeStep;
    57     int _mode;
    5852};
    5953
  • nanovis/branches/1.1/ParticleRenderer.cpp

    r4890 r4904  
    2727    _initPosTex(0),
    2828    _data(NULL),
    29     _psysFrame(0),
     29    _psysFrame(0U),
    3030    _reborn(true),
    3131    _flip(true),
    32     _maxLife(500),
     32    _maxLife(500U),
    3333    _particleSize(1.2),
    3434    _vertexArray(NULL),
     
    3737    _activate(false),
    3838    _slicePos(0.0),
    39     _sliceAxis(0),
     39    _sliceAxis(AXIS_Z),
    4040    _color(0.2, 0.2, 1.0, 1.0),
    4141    _psysWidth(w),
     
    220220    _flip = true;
    221221    _reborn = false;
    222     _psysFrame = 0;
     222    _psysFrame = 0U;
    223223}
    224224
     
    282282    _psysFrame++;
    283283    if (_psysFrame == _maxLife) {
    284         _psysFrame = 0;
     284        _psysFrame = 0U;
    285285        // _reborn = true;
    286286    }
     
    339339
    340340void
    341 ParticleRenderer::setAxis(int axis)
     341ParticleRenderer::setSliceAxis(FlowSliceAxis axis)
    342342{
    343343    _sliceAxis = axis;
     
    346346
    347347void
    348 ParticleRenderer::setPos(float pos)
     348ParticleRenderer::setSlicePosition(float pos)
    349349{
    350350    _slicePos = pos;
  • nanovis/branches/1.1/ParticleRenderer.h

    r4890 r4904  
    1414#include <vrmath/Color4f.h>
    1515
     16#include "FlowTypes.h"
    1617#include "ParticleAdvectionShader.h"
    1718#include "RenderVertexArray.h"
     
    2324    float y;
    2425    float z;
    25     float aux;
     26    float life;
    2627
    2728    Particle()
     
    2930
    3031    Particle(float _x, float _y, float _z, float _life) :
    31         x(_x), y(_y), z(_z), aux(_life)
     32        x(_x),
     33        y(_y),
     34        z(_z),
     35        life(_life)
    3236    {}
    3337};
     
    4650
    4751    void advect();
    48 
    49     void updateVertexBuffer();
    5052
    5153    void reset();
     
    6870    }
    6971
    70     void setAxis(int axis);
     72    void setSliceAxis(FlowSliceAxis axis);
    7173
    72     void setPos(float pos);
     74    FlowSliceAxis getSliceAxis() const
     75    {
     76        return _sliceAxis;
     77    }
    7378
    74     void initializeDataArray();
     79    void setSlicePosition(float pos);
     80
     81    float getSlicePosition() const
     82    {
     83        return _slicePos;
     84    }
    7585
    7686    void particleSize(float size)
     
    8797
    8898private:
     99    void initializeDataArray();
     100
     101    void updateVertexBuffer();
     102
    89103    /// frame buffer objects: two are defined, flip them as input output every step
    90104    GLuint _psysFbo[2];
     
    96110
    97111    /// Count the frame number of particle system iteration
    98     int _psysFrame;
     112    unsigned int _psysFrame;
    99113
    100114    /// Reinitiate particles
     
    104118    bool _flip;
    105119
    106     float _maxLife;
     120    unsigned int _maxLife;
    107121
    108122    /// Size of the particle: default is 1.2
     
    120134
    121135    float _slicePos;
    122     int _sliceAxis;
     136    FlowSliceAxis _sliceAxis;
    123137
    124138    vrmath::Color4f _color;
  • nanovis/branches/1.1/ParticleSystem.cpp

    r4889 r4904  
    44 *
    55 */
    6 #include "nvconf.h"
    76
    87#include <time.h>
     
    16281627            glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f);
    16291628            glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, 100.0f);
    1630             glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
     1629            glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    16311630
    16321631            cgGLBindProgram(_particleVP);
     
    16831682            glBindTexture(GL_TEXTURE_2D, ::SpotTexID);
    16841683            glEnable(GL_TEXTURE_2D);
    1685             //glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
    1686             glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
    1687 
    1688             glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
    1689             glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
    1690             glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
     1684            //glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f);
     1685            glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f);
     1686
     1687            glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f);
     1688            glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, 100.0f);
     1689            glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    16911690
    16921691            glEnableClientState(GL_VERTEX_ARRAY);
  • nanovis/branches/1.1/PointSetRenderer.cpp

    r4890 r4904  
    7979    glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, 100);
    8080#ifdef USE_TEXTURE
    81     glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
     81    glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    8282#endif
    8383
     
    120120#ifdef USE_TEXTURE
    121121    _pointTexture->activate();
    122     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
     122    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    123123#endif
    124124
     
    158158
    159159#ifdef USE_TEXTURE
    160     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
     160    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    161161    _pointTexture->deactivate();
    162162#endif
  • nanovis/branches/1.1/PointShader.cpp

    r4889 r4904  
    1313    _normal(NULL)
    1414{
    15     loadVertexProgram("pointsvp.cg", "main");
     15    loadVertexProgram("pointsvp.cg");
    1616}
    1717
     
    2222void PointShader::bind()
    2323{
    24     setGLStateMatrixVPParameter("modelview", MODELVIEW_MATRIX, MATRIX_IDENTITY);
    25     setGLStateMatrixVPParameter("projection", PROJECTION_MATRIX, MATRIX_IDENTITY);
     24    setGLStateMatrixVPParameter("modelView", MODELVIEW_MATRIX, MATRIX_IDENTITY);
     25    setGLStateMatrixVPParameter("modelViewProj", MODELVIEW_PROJECTION_MATRIX, MATRIX_IDENTITY);
    2626
    2727    setVPParameter1f("atten", 1.0f);
  • nanovis/branches/1.1/ReaderCommon.cpp

    r4889 r4904  
    6464
    6565/**
     66 * \brief Normalize data to [0,1] based on vmin,vmax range
     67 *
     68 * \param data Float array of unnormalized data, will be normalized on return
     69 * \param count Number of elts in array
     70 * \param vmin Minimum value in data array
     71 * \param vmax Maximum value in data array
     72 */
     73void
     74nv::normalizeVector(float *data, int count, double vmin, double vmax)
     75{
     76    for (int p = 0; p < count; p++) {
     77        int i = p * 4;
     78        data[i  ] = data[i]/vmax;
     79        data[i+1] = data[i+1]/(2.0 * vmax) + 0.5;
     80        data[i+2] = data[i+2]/(2.0 * vmax) + 0.5;
     81        data[i+3] = data[i+3]/(2.0 * vmax) + 0.5;
     82    }
     83}
     84
     85/**
    6686 * \brief Compute Sobel filtered gradients for a 3D volume
    6787 *
  • nanovis/branches/1.1/ReaderCommon.h

    r4889 r4904  
    1515normalizeScalar(float *data, int count, int stride, double min, double max);
    1616
     17extern void
     18normalizeVector(float *data, int count, double min, double max);
     19
    1720extern float *
    1821computeGradient(float *data,
  • nanovis/branches/1.1/RegularVolumeShader.cpp

    r4889 r4904  
    1919void RegularVolumeShader::init()
    2020{
    21     loadFragmentProgram("one_volume.cg", "main");
     21    loadFragmentProgram("one_volume.cg");
    2222}
    2323
    2424void RegularVolumeShader::bind(unsigned int tfID, Volume *volume,
    25                                  int sliceMode, float sampleRatio)
     25                               int sliceMode, float sampleRatio)
    2626{
    2727    //regular cubic volume
  • nanovis/branches/1.1/RenderVertexArray.h

    r4889 r4904  
    2323    void loadData(void *data);  // load vertex data from memory
    2424
    25     void read(/*GLenum buffer,*/ int w, int h);   // read vertex data from
    26                                                   // frame buffer
     25    void read(int w, int h);   // read vertex data from frame buffer
     26
    2727    void setPointer(GLuint index);
    2828
  • nanovis/branches/1.1/Shader.cpp

    r4889 r4904  
    2222CGcontext Shader::_cgContext = NULL;
    2323
    24 void Shader::initCg(CGprofile defaultVertexProfile,
    25                     CGprofile defaultFragmentProfile)
     24void Shader::init()
    2625{
    27     _defaultVertexProfile = defaultVertexProfile;
    28     _defaultFragmentProfile = defaultFragmentProfile;
    2926    _cgContext = cgCreateContext();
    3027}
    3128
    32 void Shader::exitCg()
     29void Shader::exit()
    3330{
    3431    setErrorCallback(NULL);
     
    9491}
    9592
    96 void Shader::loadVertexProgram(const char *fileName, const char *entryPoint)
     93void Shader::loadVertexProgram(const char *fileName)
    9794{
    9895    if (_cgVP != NULL) {
     
    10097    }
    10198    _cgVP = loadCgSourceProgram(_cgContext, fileName,
    102                                 _vertexProfile, entryPoint);
     99                                _vertexProfile, "main");
    103100    _vpFile = fileName;
    104101}
    105102
    106 void Shader::loadFragmentProgram(const char *fileName, const char *entryPoint)
     103void Shader::loadFragmentProgram(const char *fileName)
    107104{
    108105    if (_cgFP != NULL) {
     
    110107    }
    111108    _cgFP = loadCgSourceProgram(_cgContext, fileName,
    112                                 _fragmentProfile, entryPoint);
     109                                _fragmentProfile, "main");
    113110    _fpFile = fileName;
    114111}
     
    127124}
    128125
    129 void Shader::setErrorCallback(CgCallbackFunction callback)
     126void Shader::setErrorCallback(ShaderCallbackFunction callback)
    130127{
    131128    TRACE("Shader setting error callback to: %p", callback);
  • nanovis/branches/1.1/Shader.h

    r4889 r4904  
    3131    };
    3232
    33     typedef void CgCallbackFunction(void);
     33    typedef void (*ShaderCallbackFunction)(void);
    3434
    3535    Shader();
     
    3838
    3939    /**
    40      * @brief create a Cg vertex program and load it
    41      * @param fileName the name of Cg program file
    42      * @param entryPoint a entry point of the Cg program
     40     * \brief Load and compile a vertex shader
     41     * \param fileName the name of the shader source file
    4342     */
    44     void loadVertexProgram(const char *fileName, const char *entryPoint);
     43    void loadVertexProgram(const char *fileName);
    4544
    4645    /**
    47      * @brief create a Cg fragment program and load it
    48      * @param fileName the name of Cg program file
    49      * @param entryPoint a entry point of the Cg program
     46     * \brief Load and compile a fragment shader
     47     * \param fileName the name of the shader source file
    5048     */
    51     void loadFragmentProgram(const char *fileName, const char *entryPoint);
    52 
    53     CGparameter getNamedParameterFromFP(const char *paramName)
    54     {
    55         if (_cgFP) {
    56             return cgGetNamedParameter(_cgFP, paramName);
    57         }
    58         ERROR("Unknown fragment program parameter: %s", paramName);
    59         return 0;
    60     }
    61 
    62     CGparameter getNamedParameterFromVP(const char *paramName)
    63     {
    64         if (_cgVP) {
    65             return cgGetNamedParameter(_cgVP, paramName);
    66         }
    67         ERROR("Unknown vertex program parameter: %s", paramName);
    68         return 0;
     49    void loadFragmentProgram(const char *fileName);
     50
     51    bool isVertexProgramLoaded()
     52    {
     53        return (getVP() == NULL);
     54    }
     55
     56    bool isFragmentProgramLoaded()
     57    {
     58        return (getFP() == NULL);
    6959    }
    7060
    7161    void setVPParameter1f(const char *name, float val)
    7262    {
    73         CGparameter param = getVPParam(name);
     63        Parameter param = getVPParam(name);
    7464        if (param == NULL)
    7565            return;
     
    7969    void setFPParameter1f(const char *name, float val)
    8070    {
    81         CGparameter param = getFPParam(name);
     71        Parameter param = getFPParam(name);
    8272        if (param == NULL)
    8373            return;
     
    8777    void setVPParameter2f(const char *name, float val1, float val2)
    8878    {
    89         CGparameter param = getVPParam(name);
     79        Parameter param = getVPParam(name);
    9080        if (param == NULL)
    9181            return;
     
    9585    void setFPParameter2f(const char *name, float val1, float val2)
    9686    {
    97         CGparameter param = getFPParam(name);
     87        Parameter param = getFPParam(name);
    9888        if (param == NULL)
    9989            return;
     
    10393    void setVPParameter3f(const char *name, float val1, float val2, float val3)
    10494    {
    105         CGparameter param = getVPParam(name);
     95        Parameter param = getVPParam(name);
    10696        if (param == NULL)
    10797            return;
     
    111101    void setFPParameter3f(const char *name, float val1, float val2, float val3)
    112102    {
    113         CGparameter param = getFPParam(name);
     103        Parameter param = getFPParam(name);
    114104        if (param == NULL)
    115105            return;
     
    119109    void setVPParameter4f(const char *name, float val1, float val2, float val3, float val4)
    120110    {
    121         CGparameter param = getVPParam(name);
     111        Parameter param = getVPParam(name);
    122112        if (param == NULL)
    123113            return;
     
    127117    void setFPParameter4f(const char *name, float val1, float val2, float val3, float val4)
    128118    {
    129         CGparameter param = getFPParam(name);
     119        Parameter param = getFPParam(name);
    130120        if (param == NULL)
    131121            return;
     
    135125    void setVPMatrixParameterf(const char *name, float *mat)
    136126    {
    137         CGparameter param = getVPParam(name);
     127        Parameter param = getVPParam(name);
    138128        if (param == NULL)
    139129            return;
     
    143133    void setFPMatrixParameterf(const char *name, float *mat)
    144134    {
    145         CGparameter param = getFPParam(name);
     135        Parameter param = getFPParam(name);
    146136        if (param == NULL)
    147137            return;
     
    151141    void setVPTextureParameter(const char *name, GLuint texobj, bool enable = true)
    152142    {
    153         CGparameter param = getVPParam(name);
     143        Parameter param = getVPParam(name);
    154144        if (param == NULL)
    155145            return;
     
    161151    void setFPTextureParameter(const char *name, GLuint texobj, bool enable = true)
    162152    {
    163         CGparameter param = getFPParam(name);
     153        Parameter param = getFPParam(name);
    164154        if (param == NULL)
    165155            return;
     
    171161    void enableVPTextureParameter(const char *name)
    172162    {
    173         CGparameter param = getVPParam(name);
     163        Parameter param = getVPParam(name);
    174164        if (param == NULL)
    175165            return;
     
    179169    void enaableFPTextureParameter(const char *name)
    180170    {
    181         CGparameter param = getFPParam(name);
     171        Parameter param = getFPParam(name);
    182172        if (param == NULL)
    183173            return;
     
    187177    void disableVPTextureParameter(const char *name)
    188178    {
    189         CGparameter param = getVPParam(name);
     179        Parameter param = getVPParam(name);
    190180        if (param == NULL)
    191181            return;
     
    195185    void disableFPTextureParameter(const char *name)
    196186    {
    197         CGparameter param = getFPParam(name);
     187        Parameter param = getFPParam(name);
    198188        if (param == NULL)
    199189            return;
     
    204194                                     GLMatrixType type = MATRIX_IDENTITY)
    205195    {
    206         CGparameter param = getVPParam(name);
     196        Parameter param = getVPParam(name);
    207197        if (param == NULL)
    208198            return;
     
    213203                                     GLMatrixType type = MATRIX_IDENTITY)
    214204    {
    215         CGparameter param = getFPParam(name);
     205        Parameter param = getFPParam(name);
    216206        if (param == NULL)
    217207            return;
     
    239229    }
    240230
    241     void enableVertexProfile()
    242     {
    243         cgGLEnableProfile(_vertexProfile);
    244     }
    245 
    246     void disableVertexProfile()
    247     {
    248         cgGLDisableProfile(_vertexProfile);
    249     }
    250 
    251     void enableFragmentProfile()
    252     {
    253         cgGLEnableProfile(_fragmentProfile);
    254     }
    255 
    256     void disableFragmentProfile()
    257     {
    258         cgGLDisableProfile(_fragmentProfile);
    259     }
    260 
    261     static void initCg(CGprofile defaultVertexProfile = CG_PROFILE_VP40,
    262                        CGprofile defaultFragmentProfile = CG_PROFILE_FP40);
    263 
    264     static void exitCg();
     231    static void init();
     232
     233    static void exit();
    265234
    266235    static bool printErrorInfo();
    267236
    268     static void setErrorCallback(CgCallbackFunction callback);
     237    static void setErrorCallback(ShaderCallbackFunction callback);
    269238
    270239    static CGcontext getCgContext()
     
    274243
    275244protected:
    276     typedef std::tr1::unordered_map<std::string, CGparameter> ParameterHashmap;
    277 
    278     CGprogram getVP()
    279     {
    280         return _cgVP;
    281     }
    282 
    283     CGprogram getFP()
    284     {
    285         return _cgFP;
    286     }
    287 
    288     CGparameter getVPParam(const char *name)
    289     {
    290         CGparameter param;
     245    typedef CGparameter Parameter;
     246    typedef std::tr1::unordered_map<std::string, Parameter> ParameterHashmap;
     247
     248    Parameter getNamedParameterFromFP(const char *paramName)
     249    {
     250        if (_cgFP) {
     251            return cgGetNamedParameter(_cgFP, paramName);
     252        }
     253        ERROR("Unknown fragment program parameter: %s", paramName);
     254        return 0;
     255    }
     256
     257    Parameter getNamedParameterFromVP(const char *paramName)
     258    {
     259        if (_cgVP) {
     260            return cgGetNamedParameter(_cgVP, paramName);
     261        }
     262        ERROR("Unknown vertex program parameter: %s", paramName);
     263        return 0;
     264    }
     265
     266    Parameter getVPParam(const char *name)
     267    {
     268        Parameter param;
    291269        ParameterHashmap::iterator itr = _vpParams.find(name);
    292270        if (itr == _vpParams.end()) {
     
    302280    }
    303281
    304     CGparameter getFPParam(const char *name)
    305     {
    306         CGparameter param;
     282    Parameter getFPParam(const char *name)
     283    {
     284        Parameter param;
    307285        ParameterHashmap::iterator itr = _fpParams.find(name);
    308286        if (itr == _fpParams.end()) {
     
    320298    void resetPrograms();
    321299
     300    CGprogram getVP()
     301    {
     302        return _cgVP;
     303    }
     304
     305    CGprogram getFP()
     306    {
     307        return _cgFP;
     308    }
     309
     310    void enableVertexProfile()
     311    {
     312        cgGLEnableProfile(_vertexProfile);
     313    }
     314
     315    void disableVertexProfile()
     316    {
     317        cgGLDisableProfile(_vertexProfile);
     318    }
     319
     320    void enableFragmentProfile()
     321    {
     322        cgGLEnableProfile(_fragmentProfile);
     323    }
     324
     325    void disableFragmentProfile()
     326    {
     327        cgGLDisableProfile(_fragmentProfile);
     328    }
     329
     330    std::string _vpFile;
     331    std::string _fpFile;
     332
     333    ParameterHashmap _vpParams;
     334    ParameterHashmap _fpParams;
     335
    322336    CGprofile _vertexProfile;
    323337    CGprofile _fragmentProfile;
    324     std::string _vpFile;
     338
    325339    CGprogram _cgVP;
    326     std::string _fpFile;
    327340    CGprogram _cgFP;
    328     ParameterHashmap _vpParams;
    329     ParameterHashmap _fpParams;
    330341
    331342    static CGprofile _defaultVertexProfile;
  • nanovis/branches/1.1/StdVertexShader.cpp

    r4889 r4904  
    1919void StdVertexShader::init()
    2020{
    21     loadVertexProgram("vertex_std.cg", "main");
     21    loadVertexProgram("vertex_std.cg");
    2222}
    2323
     
    2727        setVPMatrixParameterf("modelViewProjMatrix", mvp);
    2828    } else {
    29         setGLStateMatrixVPParameter("modelViewProjMatrix", MODELVIEW_PROJECTION_MATRIX);
     29        setGLStateMatrixVPParameter("modelViewProjMatrix",
     30                                    MODELVIEW_PROJECTION_MATRIX);
    3031    }
    3132    if (mvInv != NULL) {
    3233        setVPMatrixParameterf("modelViewInv", mvInv);
    3334    } else {
    34         setGLStateMatrixVPParameter("modelViewInv", MODELVIEW_MATRIX, MATRIX_INVERSE);
     35        setGLStateMatrixVPParameter("modelViewInv",
     36                                    MODELVIEW_MATRIX, MATRIX_INVERSE);
    3537    }
    3638
  • nanovis/branches/1.1/Unirect.cpp

    r4893 r4904  
    55 * Author: George A. Howlett <gah@purdue.edu>
    66 */
     7
     8#include <assert.h>
     9#include <string.h>
     10#include <math.h>
    711#include <float.h>
     12#include <ctype.h> // For isspace()
    813
    914#include <tcl.h>
    10 
    11 #include <RpField1D.h>
    12 #include <RpFieldRect3D.h>
    1315
    1416#include "Command.h"
     
    4547
    4648int
    47 nv::Unirect2d::parseBuffer(Tcl_Interp *interp, Rappture::Buffer &buf)
    48 {
    49     Tcl_Obj *objPtr = Tcl_NewStringObj(buf.bytes(), buf.size());
     49nv::Unirect2d::parseBuffer(Tcl_Interp *interp, const char *bytes, size_t len)
     50{
     51    Tcl_Obj *objPtr = Tcl_NewStringObj(bytes, len);
    5052    Tcl_Obj **objv;
    5153    int objc;
     
    6264
    6365int
    64 nv::Unirect3d::parseBuffer(Tcl_Interp *interp, Rappture::Buffer &buf)
    65 {
    66     Tcl_Obj *objPtr = Tcl_NewStringObj(buf.bytes(), buf.size());
     66nv::Unirect3d::parseBuffer(Tcl_Interp *interp, const char *bytes, size_t len)
     67{
     68    Tcl_Obj *objPtr = Tcl_NewStringObj(bytes, len);
    6769    Tcl_Obj **objv;
    6870    int objc;
     
    488490
    489491bool
    490 nv::Unirect3d::importDx(Rappture::Outcome &result, size_t nComponents,
     492nv::Unirect3d::importDx(size_t nComponents,
    491493                        size_t length, char *string)
    492494{
     
    511513                   &nx, &ny, &nz) == 3) {
    512514            if ((nx < 0) || (ny < 0) || (nz < 0)) {
    513                 result.addError("invalid grid size: x=%d, y=%d, z=%d",
    514                         nx, ny, nz);
     515                ERROR("invalid grid size: x=%d, y=%d, z=%d",
     516                      nx, ny, nz);
    515517                return false;
    516518            }
     
    529531                " rank 1 items %d data follows", &npts) == 1) {
    530532            if (npts < 0) {
    531                 result.addError("bad # points %d", npts);
     533                ERROR("bad # points %d", npts);
    532534                return false;
    533535            }
    534536            TRACE("#points=%d", npts);
    535537            if (npts != nx*ny*nz) {
    536                 result.addError("inconsistent data: expected %d points"
    537                                 " but found %d points", nx*ny*nz, npts);
     538                ERROR("inconsistent data: expected %d points"
     539                      " but found %d points", nx*ny*nz, npts);
    538540                return false;
    539541            }
     
    542544                " times %d data follows", &npts) == 1) {
    543545            if (npts != nx*ny*nz) {
    544                 result.addError("inconsistent data: expected %d points"
    545                                 " but found %d points", nx*ny*nz, npts);
     546                ERROR("inconsistent data: expected %d points"
     547                      " but found %d points", nx*ny*nz, npts);
    546548                return false;
    547549            }
     
    550552    }
    551553    if (npts != nx*ny*nz) {
    552         result.addError("inconsistent data: expected %d points"
    553                         " but found %d points", nx*ny*nz, npts);
     554        ERROR("inconsistent data: expected %d points"
     555              " but found %d points", nx*ny*nz, npts);
    554556        return false;
    555557    }
     
    606608    /* Make sure that we read all of the expected points. */
    607609    if (_nValues != (size_t)npts) {
    608         result.addError("inconsistent data: expected %d points"
    609                         " but found %d points", npts, _nValues);
     610        ERROR("inconsistent data: expected %d points"
     611              " but found %d points", npts, _nValues);
    610612        free(_values);
    611613        _values = NULL;
     
    629631    }
    630632#endif
    631     return true;
    632 }
    633 
    634 bool
    635 nv::Unirect3d::resample(Rappture::Outcome &result, size_t nSamples)
    636 {
    637     Rappture::Mesh1D xgrid(_xMin, _xMax, _xNum);
    638     Rappture::Mesh1D ygrid(_yMin, _yMax, _yNum);
    639     Rappture::Mesh1D zgrid(_zMin, _zMax, _zNum);
    640     Rappture::FieldRect3D xfield(xgrid, ygrid, zgrid);
    641     Rappture::FieldRect3D yfield(xgrid, ygrid, zgrid);
    642     Rappture::FieldRect3D zfield(xgrid, ygrid, zgrid);
    643 
    644     size_t i, j;
    645     for (i = 0, j = 0; i < _nValues; i += _nComponents, j++) {
    646         double vx, vy, vz;
    647 
    648         vx = _values[i];
    649         vy = _values[i+1];
    650         vz = _values[i+2];
    651        
    652         xfield.define(j, vx);
    653         yfield.define(j, vy);
    654         zfield.define(j, vz);
    655     }
    656     // Figure out a good mesh spacing
    657     double dx, dy, dz;
    658     double lx, ly, lz;
    659     lx = xfield.rangeMax(Rappture::xaxis) - xfield.rangeMin(Rappture::xaxis);
    660     ly = xfield.rangeMax(Rappture::yaxis) - xfield.rangeMin(Rappture::yaxis);
    661     lz = xfield.rangeMax(Rappture::zaxis) - xfield.rangeMin(Rappture::zaxis);
    662 
    663     double dmin;
    664     dmin = pow((lx*ly*lz)/((nSamples-1)*(nSamples-1)*(nSamples-1)), 0.333);
    665 
    666     /* Recompute new number of points for each axis. */
    667     _xNum = (size_t)ceil(lx/dmin);
    668     _yNum = (size_t)ceil(ly/dmin);
    669     _zNum = (size_t)ceil(lz/dmin);
    670 
    671 #ifndef HAVE_NPOT_TEXTURES
    672     // must be an even power of 2 for older cards
    673     _xNum = (int)pow(2.0, ceil(log10((double)_xNum)/log10(2.0)));
    674     _yNum = (int)pow(2.0, ceil(log10((double)_yNum)/log10(2.0)));
    675     _zNum = (int)pow(2.0, ceil(log10((double)_zNum)/log10(2.0)));
    676 #endif
    677 
    678     dx = lx/(double)(_xNum-1);
    679     dy = ly/(double)(_yNum-1);
    680     dz = lz/(double)(_zNum-1);
    681 
    682     TRACE("lx:%lf ly:%lf lz:%lf dmin:%lf dx:%lf dy:%lf dz:%lf", lx, ly, lz, dmin, dx, dy, dz);
    683 
    684     size_t n = _nComponents * _xNum * _yNum * _zNum;
    685     _values = (float *)realloc(_values, sizeof(float) * n);
    686     memset(_values, 0, sizeof(float) * n);
    687 
    688     // Generate the uniformly sampled rectangle that we need for a volume
    689     float *destPtr = _values;
    690     for (size_t i = 0; i < _zNum; i++) {
    691         double z;
    692 
    693         z = _zMin + (i * dx);
    694         for (size_t j = 0; j < _yNum; j++) {
    695             double y;
    696                
    697             y = _yMin + (j * dy);
    698             for (size_t k = 0; k < _xNum; k++) {
    699                 double x;
    700 
    701                 x = _xMin + (k * dz);
    702                 destPtr[0] = xfield.value(x, y, z);
    703                 destPtr[1] = yfield.value(x, y, z);
    704                 destPtr[2] = zfield.value(x, y, z);
    705             }
    706         }
    707     }
    708     _nValues = _xNum * _yNum * _zNum * _nComponents;
    709633    return true;
    710634}
  • nanovis/branches/1.1/Unirect.h

    r4893 r4904  
    99
    1010#include <float.h>
     11#include <stdlib.h>
    1112
    1213#include <tcl.h>
    1314
    14 #include <rappture.h>
     15#include <vrmath/Vector3f.h>
    1516
    1617#include "Trace.h"
     
    197198    }
    198199
     200    void getBounds(vrmath::Vector3f& bboxMin,
     201                   vrmath::Vector3f& bboxMax) const
     202    {
     203        bboxMin.set(_xMin, _yMin, _zMin);
     204        bboxMax.set(_xMax, _yMax, _zMax);
     205    }
     206
    199207    const float *SaveValues()
    200208    {
     
    213221    int loadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
    214222
    215     int parseBuffer(Tcl_Interp *interp, Rappture::Buffer &buf);
    216 
    217     bool importDx(Rappture::Outcome &result, size_t nComponents,
    218                   size_t length, char *string);
     223    int parseBuffer(Tcl_Interp *interp, const char *bytes, size_t len);
     224
     225    bool importDx(size_t nComponents, size_t length, char *string);
    219226
    220227    bool convert(Unirect2d *dataPtr);
    221 
    222     bool resample(Rappture::Outcome &context, size_t nSamples = 30);
    223228
    224229    bool isInitialized()
     
    238243    float _zValueMin, _zValueMax;
    239244    double _magMin, _magMax;                /* Range of magnitudes of vector
    240                                          * data. */
     245                                             * data. */
    241246    char *_xUnits;
    242247    char *_yUnits;
     
    352357    }
    353358
     359    void getBounds(vrmath::Vector3f& bboxMin,
     360                   vrmath::Vector3f& bboxMax) const
     361    {
     362        bboxMin.set(_xMin, _yMin, 0);
     363        bboxMax.set(_xMax, _yMax, 0);
     364    }
     365
    354366    float *transferValues()
    355367    {
     
    368380    int loadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
    369381
    370     int parseBuffer(Tcl_Interp *interp, Rappture::Buffer &buf);
     382    int parseBuffer(Tcl_Interp *interp, const char *bytes, size_t len);
    371383
    372384    bool isInitialized()
  • nanovis/branches/1.1/VelocityArrowsSlice.cpp

    r4889 r4904  
    44 *
    55 */
    6 #include "nvconf.h"
    76
    87#include <math.h>
     
    3837VelocityArrowsSlice::VelocityArrowsSlice() :
    3938    _vectorFieldGraphicsID(0),
    40     _vfXscale(0),
    41     _vfYscale(0),
    42     _vfZscale(0),
    4339    _slicePos(0.5f),
    44     _axis(2),
     40    _axis(AXIS_Z),
    4541    _fbo(0),
    4642    _tex(0),
     
    5753    _maxVelocityScale(1, 1, 1),
    5854    _arrowColor(1, 1, 0),
    59     _enabled(false),
     55    _visible(false),
    6056    _dirty(true),
    6157    _vertexBufferGraphicsID(0),
     
    6359    _renderMode(LINES)
    6460{
    65     axis(2);
    66 
    67     _queryVelocityFP.loadFragmentProgram("queryvelocity.cg", "main");
    68 
    69     _particleShader.loadVertexProgram("velocityslicevp.cg", "vpmain");
    70     _particleShader.loadFragmentProgram("velocityslicefp.cg", "fpmain");
     61    setSliceAxis(_axis);
     62
     63    _queryVelocityFP.loadFragmentProgram("queryvelocity.cg");
     64
     65    _particleShader.loadVertexProgram("velocityslicevp.cg");
     66    _particleShader.loadFragmentProgram("velocityslicefp.cg");
    7167
    7268    createRenderTarget();
     
    175171}
    176172
    177 void VelocityArrowsSlice::axis(int axis)
     173void VelocityArrowsSlice::setSliceAxis(FlowSliceAxis axis)
    178174{
    179175    _axis = axis;
    180176    switch (_axis) {
    181     case 0:
     177    case AXIS_X:
    182178        _projectionVector.x = 0;
    183179        _projectionVector.y = 1;
    184180        _projectionVector.z = 1;
    185181        break;
    186     case 1 :
     182    case AXIS_Y:
    187183        _projectionVector.x = 1;
    188184        _projectionVector.y = 0;
    189185        _projectionVector.z = 1;
    190186        break;
    191     case 2:
     187    case AXIS_Z:
    192188        _projectionVector.x = 1;
    193189        _projectionVector.y = 1;
     
    200196void VelocityArrowsSlice::queryVelocity()
    201197{
    202     if (!_enabled) return;
    203 
    204198    glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
    205199    int fboOrig;
     
    223217    glBegin(GL_QUADS);
    224218    switch (_axis) {
    225     case 0:
     219    case AXIS_X:
    226220        glTexCoord3f(_slicePos, 0, 0); glVertex2i(0,                  0);
    227221        glTexCoord3f(_slicePos, 1, 0); glVertex2i(_renderTargetWidth, 0);
     
    229223        glTexCoord3f(_slicePos, 0, 1); glVertex2i(0,                  _renderTargetHeight);
    230224        break;
    231     case 1:
     225    case AXIS_Y:
    232226        glTexCoord3f(0, _slicePos, 0); glVertex2i(0,                  0);
    233227        glTexCoord3f(1, _slicePos, 0); glVertex2i(_renderTargetWidth, 0);
     
    235229        glTexCoord3f(0, _slicePos, 1); glVertex2i(0,                  _renderTargetHeight);
    236230        break;
    237     case 2:
     231    case AXIS_Z:
    238232    default:
    239233        glTexCoord3f(0, 0, _slicePos); glVertex2i(0,                  0);
     
    260254}
    261255
    262 static void drawLineArrow(int axis)
     256static void drawLineArrow(FlowSliceAxis axis)
    263257{
    264258    glBegin(GL_LINES);
    265259    switch (axis) {
    266     case 0: // ZY plane
     260    case AXIS_X: // ZY plane
    267261        glVertex3f(0.0, 0.0, 0.0);
    268262        glVertex3f(0.0, 0.0, 1.0);
     
    274268        glVertex3f(0.0, -0.25, 0.75);
    275269        break;
    276     case 1: // XZ plane
     270    case AXIS_Y: // XZ plane
    277271        glVertex3f(0.0, 0.0, 0.0);
    278272        glVertex3f(1.0, 0.0, 0.0);
     
    284278        glVertex3f(0.75, 0.0, -0.25);
    285279        break;
    286     case 2: // XY plane
     280    case AXIS_Z: // XY plane
    287281    default:
    288282        glVertex3f(0.0, 0.0, 0.0);
     
    301295void VelocityArrowsSlice::render()
    302296{
    303     if (!_enabled)
     297    if (!_visible)
    304298        return;
    305299
     
    310304    }
    311305
    312     TRACE("_vf: %g %g %g", _vfXscale,_vfYscale, _vfZscale);
     306    TRACE("_scale: %g %g %g", _scale.x, _scale.y, _scale.z);
    313307    TRACE("_maxVelocityScale: %g %g %g",
    314308          _maxVelocityScale.x, _maxVelocityScale.y, _maxVelocityScale.z);
     
    319313    glPushMatrix();
    320314
    321     glScalef(_vfXscale,_vfYscale, _vfZscale);
     315    glScalef(_scale.x, _scale.y, _scale.z);
    322316    glTranslatef(-0.5f, -0.5f, -0.5f);
    323317
     
    336330        int index = 0, icount, jcount;
    337331        switch (_axis) {
    338         case 0:
     332        case AXIS_X:
    339333            icount = _tickCountZ;
    340334            jcount = _tickCountY;
    341335            refVec.set(0, 0, 1);
    342336            break;
    343         case 1:
     337        case AXIS_Y:
    344338            icount = _tickCountZ;
    345339            jcount = _tickCountX;
    346340            refVec.set(1, 0, 0);
    347341            break;
    348         case 2:
     342        case AXIS_Z:
    349343        default:
    350344            icount = _tickCountY;
     
    366360                    continue;
    367361                }
    368                 if (length > 1.0e-6) {
     362                if (length > 0.0) {
    369363                    Vector3f vnorm = vel.normalize();
    370364                    Vector3f rotationAxis = refVec.cross(vnorm);
     
    409403        _arrowsTex->activate();
    410404        glEnable(GL_TEXTURE_2D);
    411         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
     405        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    412406
    413407        GLfloat atten[] = {1, 0, 0};
     
    416410        glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f);
    417411        glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, _maxPointSize);
    418         glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
     412        glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    419413
    420414        _particleShader.bind();
     
    422416        _particleShader.setFPTextureParameter("arrows", _arrowsTex->id());
    423417        _particleShader.setVPParameter1f("tanHalfFOV",
    424                                          tan(NanoVis::getCamera()->fov() * 0.5) * NanoVis::winHeight * 0.5);
     418                                         tan(NanoVis::getCamera()->getFov() * 0.5) * NanoVis::winHeight * 0.5);
    425419        _particleShader.setGLStateMatrixVPParameter("modelview",
    426420                                                    Shader::MODELVIEW_MATRIX,
     
    448442
    449443        glActiveTexture(GL_TEXTURE0);
    450         glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE);
     444        glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE);
    451445        _arrowsTex->deactivate();
    452446    }
     
    461455{
    462456    _vectorFieldGraphicsID = vfGraphicsID;
    463     _vfXscale = xScale;
    464     _vfYscale = yScale;
    465     _vfZscale = zScale;
     457    _scale.set(xScale, yScale, zScale);
    466458
    467459    _dirty = true;
     
    470462void VelocityArrowsSlice::computeSamplingTicks()
    471463{
    472     if (_vfXscale < _vfYscale) {
    473         if (_vfXscale < _vfZscale || _vfZscale == 0.0) {
    474             // vfXscale
     464    if (_scale.x < _scale.y) {
     465        if (_scale.x < _scale.z || _scale.z == 0.0) {
     466            // _scale.x
    475467            _tickCountX = _tickCountForMinSizeAxis;
    476468
    477             float step = _vfXscale / (_tickCountX + 1);
    478 
    479             _tickCountY = (int)(_vfYscale/step);
    480             _tickCountZ = (int)(_vfZscale/step);
     469            float step = _scale.x / (_tickCountX + 1);
     470            _tickCountY = (int)(_scale.y/step);
     471            _tickCountZ = (int)(_scale.z/step);
    481472        } else {
    482             // vfZscale
     473            // _scale.z
    483474            _tickCountZ = _tickCountForMinSizeAxis;
    484475
    485             float step = _vfZscale / (_tickCountZ + 1);
    486             _tickCountX = (int)(_vfXscale/step);
    487             _tickCountY = (int)(_vfYscale/step);
     476            float step = _scale.z / (_tickCountZ + 1);
     477            _tickCountX = (int)(_scale.x/step);
     478            _tickCountY = (int)(_scale.y/step);
    488479        }
    489480    } else {
    490         if (_vfYscale < _vfZscale || _vfZscale == 0.0) {
    491             // _vfYscale
     481        if (_scale.y < _scale.z || _scale.z == 0.0) {
     482            // _scale.y
    492483            _tickCountY = _tickCountForMinSizeAxis;
    493484
    494             float step = _vfYscale / (_tickCountY + 1);
    495             _tickCountX = (int)(_vfXscale/step);
    496             _tickCountZ = (int)(_vfZscale/step);
     485            float step = _scale.y / (_tickCountY + 1);
     486            _tickCountX = (int)(_scale.x/step);
     487            _tickCountZ = (int)(_scale.z/step);
    497488        } else {
    498             // vfZscale
     489            // _scale.z
    499490            _tickCountZ = _tickCountForMinSizeAxis;
    500491
    501             float step = _vfZscale / (_tickCountZ + 1);
    502             _tickCountX = (int)(_vfXscale/step);
    503             _tickCountY = (int)(_vfYscale/step);
     492            float step = _scale.z / (_tickCountZ + 1);
     493            _tickCountX = (int)(_scale.x/step);
     494            _tickCountY = (int)(_scale.y/step);
    504495        }
    505496    }
    506497
    507498    switch (_axis) {
    508     case 0:
     499    case AXIS_X:
    509500        _tickCountX = 1;
    510501        _renderTargetWidth = _tickCountY;
    511502        _renderTargetHeight = _tickCountZ;
    512503        break;
    513     case 1:
     504    case AXIS_Y:
    514505        _tickCountY = 1;
    515506        _renderTargetWidth = _tickCountX;
     
    517508        break;
    518509    default:
    519     case 2:
     510    case AXIS_Z:
    520511        _tickCountZ = 1;
    521512        _renderTargetWidth = _tickCountX;
     
    546537    }
    547538
    548     if (_axis == 2) {
     539    if (_axis == AXIS_Z) {
    549540        for (int y = 1; y <= _tickCountY; ++y) {
    550541            for (int x = 1; x <= _tickCountX; ++x) {
     
    560551            }
    561552        }
    562     } else if (_axis == 1) {
     553    } else if (_axis == AXIS_Y) {
    563554        for (int z = 1; z <= _tickCountZ; ++z) {
    564555            for (int x = 1; x <= _tickCountX; ++x) {
     
    574565            }
    575566        }
    576     } else if (_axis == 0) {
     567    } else if (_axis == AXIS_X) {
    577568        for (int z = 1; z <= _tickCountZ; ++z) {
    578569            for (int y = 1; y <= _tickCountY; ++y) {
  • nanovis/branches/1.1/VelocityArrowsSlice.h

    r4889 r4904  
    1111#include <vrmath/Vector3f.h>
    1212
     13#include "FlowTypes.h"
    1314#include "Texture2D.h"
    1415#include "Shader.h"
     
    3132                        float xScale, float yScale, float zScale, float max);
    3233
    33     void axis(int axis);
     34    void setSliceAxis(FlowSliceAxis axis);
    3435
    35     int axis() const
     36    int getSliceAxis() const
    3637    {
    3738        return _axis;
    3839    }
    3940
    40     void slicePos(float pos)
     41    void setSlicePosition(float pos)
    4142    {
    4243        _slicePos = pos;
     
    4445    }
    4546
    46     float slicePos() const
     47    float getSlicePosition() const
    4748    {
    4849        return _slicePos;
    4950    }
    5051
    51     void queryVelocity();
    52 
    5352    void render();
    5453
    55     void enabled(bool enabled)
     54    void visible(bool visible)
    5655    {
    57         _enabled = enabled;
     56        _visible = visible;
    5857    }
    5958
    60     bool enabled() const
     59    bool visible() const
    6160    {
    62         return _enabled;
     61        return _visible;
    6362    }
    6463
     
    9089
    9190private:
     91    void queryVelocity();
     92
    9293    void createRenderTarget();
    9394
     
    9596
    9697    unsigned int _vectorFieldGraphicsID;
    97     float _vfXscale;
    98     float _vfYscale;
    99     float _vfZscale;
     98    vrmath::Vector3f _scale;
     99
    100100    float _slicePos;
    101     int _axis;
     101    FlowSliceAxis _axis;
    102102
    103103    unsigned int _fbo;
     
    124124    vrmath::Vector3f _arrowColor;
    125125
    126     bool _enabled;
     126    bool _visible;
    127127    bool _dirty;
    128128    bool _dirtySamplingPosition;
  • nanovis/branches/1.1/Volume.cpp

    r4889 r4904  
    3232
    3333Volume::Volume(float x, float y, float z,
    34                int w, int h, int d,
    35                int n, float *data,
    36                double v0, double v1, double nonZeroMin) :
     34               int width, int height, int depth,
     35               int numComponents, float *data,
     36               double vmin, double vmax, double nonZeroMin) :
    3737    _id(0),
    38     _width(w),
    39     _height(h),
    40     _depth(d),
     38    _width(width),
     39    _height(height),
     40    _depth(depth),
    4141    _transferFunc(NULL),
    4242    _ambient(0.6f),
     
    4747    _opacityScale(0.5f),
    4848    _data(NULL),
    49     _numComponents(n),
     49    _numComponents(numComponents),
    5050    _nonZeroMin(nonZeroMin),
    5151    _cutplanesVisible(true),
    5252    _tex(NULL),
    53     _location(x, y, z),
     53    _position(x, y, z),
     54    _scale(1, 1, 1),
    5455    _numSlices(512),
    5556    _enabled(true),
     
    6364    _outlineColor[0] = _outlineColor[1] = _outlineColor[2] = 1.0f;
    6465
    65     _tex = new Texture3D(_width, _height, _depth, GL_FLOAT, GL_LINEAR, n);
     66    _tex = new Texture3D(_width, _height, _depth, GL_FLOAT, GL_LINEAR, _numComponents);
    6667    int fcount = _width * _height * _depth * _numComponents;
    6768    _data = new float[fcount];
    6869    if (data != NULL) {
    69         TRACE("data is copied");
    7070        memcpy(_data, data, fcount * sizeof(float));
    71         _tex->initialize(_data);
    7271    } else {
    73         TRACE("data is null");
    74         memset(_data, 0, sizeof(_width * _height * _depth * _numComponents *
    75                                 sizeof(float)));
    76         _tex->initialize(_data);
     72        TRACE("data is NULL");
     73        memset(_data, 0, fcount * sizeof(float));
    7774    }
    78 
     75    _tex->initialize(_data);
    7976    _id = _tex->id();
    8077
    81     wAxis.setRange(v0, v1);
     78    wAxis.setRange(vmin, vmax);
    8279
    8380    //Add cut planes. We create 3 default cut planes facing x, y, z directions.
    8481    //The default location of cut plane is in the middle of the data.
    8582    _plane.clear();
    86     addCutplane(1, 0.5f);
    87     addCutplane(2, 0.5f);
    88     addCutplane(3, 0.5f);
     83    addCutplane(CutPlane::X_AXIS, 0.5f);
     84    addCutplane(CutPlane::Y_AXIS, 0.5f);
     85    addCutplane(CutPlane::Z_AXIS, 0.5f);
    8986
    9087    TRACE("Leave");
     
    104101
    105102    Matrix4x4d mat;
    106     mat.makeTranslation(_location);
     103    mat.makeTranslation(_position);
    107104    Matrix4x4d mat2;
    108105    mat2.makeScale(scale);
  • nanovis/branches/1.1/Volume.h

    r4889 r4904  
    2121namespace nv {
    2222
    23 struct CutPlane {
    24     /// orientation - 1: xy slice, 2: yz slice, 3: xz slice
    25     int orient;
    26     float offset;       ///< normalized offset [0,1] in the volume
    27     bool enabled;
    28 
    29     CutPlane(int _orient, float _offset) :
     23class CutPlane {
     24public:
     25    enum Axis {
     26        X_AXIS = 1,
     27        Y_AXIS = 2,
     28        Z_AXIS = 3
     29    };
     30
     31    CutPlane(Axis _orient, float _offset) :
    3032        orient(_orient),
    3133        offset(_offset),
     
    3335    {
    3436    }
     37
     38    Axis orient;
     39    float offset;       ///< normalized offset [0,1] in the volume
     40    bool enabled;
    3541};
    3642
     
    98104    }
    99105
    100     void location(const vrmath::Vector3f& loc)
    101     {
    102         _location = loc;
    103     }
    104 
    105     vrmath::Vector3f location() const
    106     {
    107         return _location;
    108     }
    109 
    110106    int isosurface() const
    111107    {
     
    155151    // methods related to cutplanes
    156152    /// add a plane and returns its index
    157     int addCutplane(int orientation, float location);
     153    int addCutplane(CutPlane::Axis orientation, float location);
    158154
    159155    void enableCutplane(int index);
     
    171167    }
    172168
    173     void moveCutplane(int index, float location);
     169    void setCutplanePosition(int index, float location);
    174170
    175171    CutPlane *getCutplane(int index);
     
    292288
    293289    void getOutlineColor(float *rgb);
     290
     291    void setPosition(const vrmath::Vector3f& pos)
     292    {
     293        _position = pos;
     294    }
     295
     296    const vrmath::Vector3f& getPosition() const
     297    {
     298        return _position;
     299    }
    294300
    295301    vrmath::Vector3f getPhysicalScaling() const
     
    300306        scale.z = zAxis.length() / xAxis.length();
    301307        return scale;
     308    }
     309
     310    void setScale(const vrmath::Vector3f& scale)
     311    {
     312        _scale = scale;
     313    }
     314
     315    const vrmath::Vector3f& getScale() const
     316    {
     317        return _scale;
    302318    }
    303319
     
    380396    /**
    381397     * The scale multiplied to the opacity assigned by the
    382      * transfer function. Rule of thumb: higher opacity_scale
    383      * the object is to appear like plastic
     398     * transfer function.
    384399     */
    385400    float _opacityScale;
     
    398413    Texture3D *_tex;            ///< OpenGL texture storing the volume
    399414
    400     vrmath::Vector3f _location;
     415    vrmath::Vector3f _position;
     416    vrmath::Vector3f _scale;
    401417
    402418    /**
     
    414430
    415431inline int
    416 Volume::addCutplane(int orientation, float location)
     432Volume::addCutplane(CutPlane::Axis orientation, float location)
    417433{
    418434    _plane.push_back(CutPlane(orientation, location));
     
    435451
    436452inline void
    437 Volume::moveCutplane(int index, float location)
     453Volume::setCutplanePosition(int index, float position)
    438454{
    439455    //assert(index < plane.size());
    440     _plane[index].offset = location;
     456    _plane[index].offset = position;
    441457}
    442458
  • nanovis/branches/1.1/VolumeInterpolator.cpp

    r4889 r4904  
    3131void VolumeInterpolator::start()
    3232{
    33     if (_volumes.size() > 0) {
     33    if (!_volumes.empty()) {
    3434        TRACE("Volume Interpolation Started");
    3535        _started = true;
     
    127127VolumeInterpolator::addVolume(Volume *volume)
    128128{
    129     if (_volumes.size() != 0) {
     129    if (!_volumes.empty()) {
    130130        if (_volumes[0]->width() != volume->width() ||
    131131            _volumes[0]->height() != volume->height() ||   
     
    139139        _numComponents = volume->numComponents();
    140140        _numBytes = _dataCount * _numComponents * sizeof(float);
    141         Vector3f loc = volume->location();
    142         _volume = new Volume(loc.x, loc.y, loc.z,
     141        Vector3f pos = volume->getPosition();
     142        _volume = new Volume(pos.x, pos.y, pos.z,
    143143                             volume->width(),
    144144                             volume->height(),
     
    151151
    152152        _volume->numSlices(256-1);
     153        _volume->setPosition(volume->getPosition());
     154        _volume->setScale(volume->getScale());
    153155        _volume->disableCutplane(0);
    154156        _volume->disableCutplane(1);
     
    162164        _volume->opacityScale(volume->opacityScale());
    163165        _volume->isosurface(0);
    164         TRACE("VOL : location %f %f %f\n\tid : %s", loc.x, loc.y, loc.z,
    165                volume->name());
    166166    }
    167167    _volumes.push_back(_volume);
    168     TRACE("a Volume[%s] is added to VolumeInterpolator", volume->name());
     168    TRACE("Volume \"%s\" is added to VolumeInterpolator", volume->name());
    169169}
    170170
  • nanovis/branches/1.1/VolumeInterpolator.h

    r4889 r4904  
    4040private:
    4141    Volume *_volume;
    42 
    43     std::vector<Volume*> _volumes;
     42    std::vector<Volume *> _volumes;
    4443
    4544    double _interval;
  • nanovis/branches/1.1/VolumeRenderer.cpp

    r4889 r4904  
    5454{
    5555    _cutplaneShader = new Shader();
    56     _cutplaneShader->loadVertexProgram("cutplane_vp.cg", "main");
    57     _cutplaneShader->loadFragmentProgram("cutplane_fp.cg", "main");
     56    _cutplaneShader->loadVertexProgram("cutplane_vp.cg");
     57    _cutplaneShader->loadFragmentProgram("cutplane_fp.cg");
    5858
    5959    //standard vertex program
     
    6767    //A sim has S, P, D, SS orbitals. thus a full rendering requires 4 zincblende orbital volumes.
    6868    //A zincblende orbital volume is decomposed into 2 "interlocking" cubic 4-component volumes and passed to the shader.
    69     //We render each orbital with a independent transfer functions then blend the result.
     69    //We render each orbital with independent transfer functions then blend the result.
    7070    //
    7171    //The engine is already capable of rendering multiple volumes and combine them. Thus, we just invoke this shader on
     
    143143        }
    144144
    145         //volume start location
    146         Vector3f volPos = volume->location();
    147         Vector3f volScaling = volume->getPhysicalScaling();
     145        // Get any additional transforms on Volume
     146        Vector3f volPos = volume->getPosition();
     147        Vector3f volScale = volume->getPhysicalScaling();
     148        // Get world coords of volume bbox
     149        double x0 = 0;
     150        double y0 = 0;
     151        double z0 = 0;
     152        double x1 = x0 + 1;
     153        double y1 = y0 + 1;
     154        double z1 = z0 + 1;
     155
     156        Matrix4x4d model_view_no_trans, model_view_trans;
     157        Matrix4x4d model_view_no_trans_inverse, model_view_trans_inverse;
     158
     159        //initialize volume plane with world coordinates
     160        nv::Plane volume_planes[6];
     161        volume_planes[0].setCoeffs( 1,  0,  0, -x0);
     162        volume_planes[1].setCoeffs(-1,  0,  0,  x1);
     163        volume_planes[2].setCoeffs( 0,  1,  0, -y0);
     164        volume_planes[3].setCoeffs( 0, -1,  0,  y1);
     165        volume_planes[4].setCoeffs( 0,  0,  1, -z0);
     166        volume_planes[5].setCoeffs( 0,  0, -1,  z1);
    148167
    149168        TRACE("VOL POS: %g %g %g",
    150169              volPos.x, volPos.y, volPos.z);
    151170        TRACE("VOL SCALE: %g %g %g",
    152               volScaling.x, volScaling.y, volScaling.z);
    153 
    154         double x0 = 0;
    155         double y0 = 0;
    156         double z0 = 0;
    157 
    158         Matrix4x4d model_view_no_trans, model_view_trans;
    159         Matrix4x4d model_view_no_trans_inverse, model_view_trans_inverse;
    160 
    161         //initialize volume plane with world coordinates
    162         nv::Plane volume_planes[6];
    163         volume_planes[0].setCoeffs( 1,  0,  0, -x0);
    164         volume_planes[1].setCoeffs(-1,  0,  0,  x0+1);
    165         volume_planes[2].setCoeffs( 0,  1,  0, -y0);
    166         volume_planes[3].setCoeffs( 0, -1,  0,  y0+1);
    167         volume_planes[4].setCoeffs( 0,  0,  1, -z0);
    168         volume_planes[5].setCoeffs( 0,  0, -1,  z0+1);
     171              volScale.x, volScale.y, volScale.z);
    169172
    170173        //get modelview matrix with no translation
    171174        glPushMatrix();
    172         glScalef(volScaling.x, volScaling.y, volScaling.z);
     175        glScalef(volScale.x, volScale.y, volScale.z);
    173176
    174177        glEnable(GL_DEPTH_TEST);
     
    185188        glPushMatrix();
    186189        glTranslatef(volPos.x, volPos.y, volPos.z);
    187         glScalef(volScaling.x, volScaling.y, volScaling.z);
     190        glScalef(volScale.x, volScale.y, volScale.z);
    188191
    189192        GLdouble mv_trans[16];
     
    200203            float olcolor[3];
    201204            volume->getOutlineColor(olcolor);
    202             drawBoundingBox(x0, y0, z0, x0+1, y0+1, z0+1,
    203                 (double)olcolor[0], (double)olcolor[1], (double)olcolor[2],
    204                 1.5);
     205            drawBoundingBox(x0, y0, z0, x1, y1, z1,
     206                            olcolor[0], olcolor[1], olcolor[2],
     207                            1.5);
    205208        }
    206209        glPopMatrix();
     
    212215            volume_planes[j].transform(model_view_no_trans);
    213216        }
    214         double eyeMinX, eyeMaxX, eyeMinY, eyeMaxY, zNear, zFar;
     217        double eyeMinX, eyeMaxX, eyeMinY, eyeMaxY;
     218        double zNear, zFar;
    215219        getEyeSpaceBounds(model_view_no_trans,
    216220                          eyeMinX, eyeMaxX,
     
    249253                continue;
    250254            }
     255            Vector4f texcoord1, texcoord2, texcoord3, texcoord4;
    251256            float offset = volume->getCutplane(j)->offset;
    252257            int axis = volume->getCutplane(j)->orient;
    253258
    254259            switch (axis) {
    255             case 1:
     260            case CutPlane::X_AXIS: // YZ plane
    256261                vert1 = Vector4f(offset, 0, 0, 1);
    257262                vert2 = Vector4f(offset, 1, 0, 1);
    258263                vert3 = Vector4f(offset, 1, 1, 1);
    259264                vert4 = Vector4f(offset, 0, 1, 1);
     265                texcoord1 = Vector4f(offset, 0, 0, 1);
     266                texcoord2 = Vector4f(offset, 1, 0, 1);
     267                texcoord3 = Vector4f(offset, 1, 1, 1);
     268                texcoord4 = Vector4f(offset, 0, 1, 1);
    260269                break;
    261             case 2:
     270            case CutPlane::Y_AXIS: // XZ plane
    262271                vert1 = Vector4f(0, offset, 0, 1);
    263272                vert2 = Vector4f(1, offset, 0, 1);
    264273                vert3 = Vector4f(1, offset, 1, 1);
    265274                vert4 = Vector4f(0, offset, 1, 1);
     275                texcoord1 = Vector4f(0, offset, 0, 1);
     276                texcoord2 = Vector4f(1, offset, 0, 1);
     277                texcoord3 = Vector4f(1, offset, 1, 1);
     278                texcoord4 = Vector4f(0, offset, 1, 1);
    266279                break;
    267             case 3:
     280            case CutPlane::Z_AXIS: // XY plane
    268281            default:
    269282                vert1 = Vector4f(0, 0, offset, 1);
     
    271284                vert3 = Vector4f(1, 1, offset, 1);
    272285                vert4 = Vector4f(0, 1, offset, 1);
     286                texcoord1 = Vector4f(0, 0, offset, 1);
     287                texcoord2 = Vector4f(1, 0, offset, 1);
     288                texcoord3 = Vector4f(1, 1, offset, 1);
     289                texcoord4 = Vector4f(0, 1, offset, 1);
    273290                break;
    274291            }
    275 
    276             Vector4f texcoord1 = vert1;
    277             Vector4f texcoord2 = vert2;
    278             Vector4f texcoord3 = vert3;
    279             Vector4f texcoord4 = vert4;
    280292
    281293            _cutplaneShader->bind();
     
    285297            glPushMatrix();
    286298            glTranslatef(volPos.x, volPos.y, volPos.z);
    287             glScalef(volScaling.x, volScaling.y, volScaling.z);
     299            glScalef(volScale.x, volScale.y, volScale.z);
    288300            _cutplaneShader->setGLStateMatrixVPParameter("modelViewProjMatrix",
    289301                                                         Shader::MODELVIEW_PROJECTION_MATRIX);
     
    384396
    385397    for (size_t i = 0; i < total_rendered_slices; i++) {
    386         Volume *volume = NULL;
    387 
    388         int volume_index = slices[i].volumeId;
    389         int slice_index = slices[i].sliceId;
    390         ConvexPolygon *currentSlice = polys[volume_index][slice_index];
    391         float z_step = z_steps[volume_index];
    392 
    393         volume = volumes[volume_index];
    394 
    395         Vector3f volScaling = volume->getPhysicalScaling();
     398        int volIdx = slices[i].volumeId;
     399        int sliceIdx = slices[i].sliceId;
     400        ConvexPolygon *currentSlice = polys[volIdx][sliceIdx];
     401
     402        Volume *volume = volumes[volIdx];
     403        Vector3f volScale = volume->getPhysicalScaling();
    396404
    397405        glPushMatrix();
    398         glScalef(volScaling.x, volScaling.y, volScaling.z);
    399 
     406        glScalef(volScale.x, volScale.y, volScale.z);
     407
     408        float z_step = z_steps[volIdx];
    400409        // FIXME: compute view-dependent volume sample distance
    401         double avgSampleDistance = 1.0 / pow(volume->width() * volScaling.x *
    402                                              volume->height() * volScaling.y *
    403                                              volume->depth() * volScaling.z, 1.0/3.0);
     410        double avgSampleDistance = 1.0 / pow(volume->width() * volScale.x *
     411                                             volume->height() * volScale.y *
     412                                             volume->depth() * volScale.z, 1.0/3.0);
    404413        float sampleRatio = z_step / avgSampleDistance;
    405414
    406415#ifdef notdef
    407416        TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d z_step=%g avgSD=%g",
    408               volume->name(), volume, slice_index, volume_index, z_step, avgSampleDistance);
     417              volume->name(), volume, sliceIdx, volIdx, z_step, avgSampleDistance);
    409418#endif
    410419        activateVolumeShader(volume, false, sampleRatio);
     
    439448                                float x1, float y1, float z1,
    440449                                float r, float g, float b,
    441                                 float line_width)
     450                                float lineWidth)
    442451{
    443452    glPushAttrib(GL_ENABLE_BIT);
     
    451460
    452461    glColor4d(r, g, b, 1.0);
    453     glLineWidth(line_width);
     462    glLineWidth(lineWidth);
    454463
    455464    glBegin(GL_LINE_LOOP);
     
    494503
    495504void
    496 VolumeRenderer::activateVolumeShader(Volume *volume, bool sliceMode,
     505VolumeRenderer::activateVolumeShader(Volume *volume,
     506                                     bool sliceMode,
    497507                                     float sampleRatio)
    498508{
  • nanovis/branches/1.1/VtkReader.cpp

    r4889 r4904  
    88#include <float.h>
    99
    10 #include <RpOutcome.h>
    1110#include <RpField1D.h>
    1211#include <RpFieldRect3D.h>
     
    1615#include "ReaderCommon.h"
    1716
     17#include "config.h"
    1818#include "nanovis.h"
    1919#include "VtkReader.h"
     
    183183
    184184Volume *
    185 nv::load_vtk_volume_stream(Rappture::Outcome& result, const char *tag, std::iostream& fin)
     185nv::load_vtk_volume_stream(const char *tag, std::iostream& fin)
    186186{
    187187    TRACE("Enter tag:%s", tag);
     
    207207        fin.getline(line, sizeof(line) - 1);
    208208        if (fin.fail()) {
    209             result.error("Error in data stream");
     209            ERROR("Error in data stream");
    210210            return NULL;
    211211        }
     
    222222                    isRect = 1;
    223223                } else {
    224                     result.addError("Unsupported DataSet type '%s'", str);
     224                    ERROR("Unsupported DataSet type '%s'", str);
    225225                    return NULL;
    226226                }
    227227            } else if (sscanf(start, "DIMENSIONS %d %d %d", &nx, &ny, &nz) == 3) {
    228228                if (nx <= 0 || ny <= 0 || nz <= 0) {
    229                     result.error("Found non-positive dimensions");
     229                    ERROR("Found non-positive dimensions");
    230230                    return NULL;
    231231                }
     
    235235            } else if (sscanf(start, "SPACING %lg %lg %lg", &dx, &dy, &dz) == 3) {
    236236                if ((nx > 1 && dx == 0.0) || (ny > 1 && dy == 0.0) || (nz > 1 && dz == 0.0)) {
    237                     result.error("Found zero spacing for dimension");
     237                    ERROR("Found zero spacing for dimension");
    238238                    return NULL;
    239239                }
     
    241241            } else if (sscanf(start, "POINT_DATA %d", &npts) == 1) {
    242242                if (npts < 1 || npts != nx * ny * nz) {
    243                     result.addError("Error in data stream: unexpected number of point data: %d", npts);
     243                    ERROR("Error in data stream: unexpected number of point data: %d", npts);
    244244                    return NULL;
    245245                }
    246246                if (isBinary < 0 || fin.eof()) {
    247247                    // Should know if ASCII or BINARY by now
    248                     result.error("Error in data stream");
     248                    ERROR("Error in data stream");
    249249                    return NULL;
    250250                }
    251251                fin.getline(line, sizeof(line) - 1);
    252252                if (fin.fail()) {
    253                     result.error("Error in data stream");
     253                    ERROR("Error in data stream");
    254254                    return NULL;
    255255                }
     
    257257                    ;  // skip leading blanks
    258258                if (sscanf(start, "SCALARS %s %s", str, type) != 2) {
    259                     result.error("Error in data stream");
     259                    ERROR("Error in data stream");
    260260                    return NULL;
    261261                }
     
    267267                    ftype = UCHAR;
    268268                    if (!isBinary) {
    269                         result.addError("unsigned char only supported in binary VTK files");
     269                        ERROR("unsigned char only supported in binary VTK files");
    270270                        return NULL;
    271271                    }
     
    279279                    ftype = UINT;
    280280                } else {
    281                     result.addError("Unsupported scalar type: '%s'", type);
     281                    ERROR("Unsupported scalar type: '%s'", type);
    282282                    return NULL;
    283283                }
    284284                if (fin.eof()) {
    285                     result.error("Error in data stream");
     285                    ERROR("Error in data stream");
    286286                    return NULL;
    287287                }
    288288                fin.getline(line, sizeof(line) - 1);
    289289                if (fin.fail()) {
    290                     result.error("Error in data stream");
     290                    ERROR("Error in data stream");
    291291                    return NULL;
    292292                }
     
    296296                    // skip lookup table, but don't read ahead
    297297                    if (fin.eof()) {
    298                         result.error("Error in data stream");
     298                        ERROR("Error in data stream");
    299299                        return NULL;
    300300                    }
    301301                } else {
    302302                    // Lookup table line is required
    303                     result.error("Missing LOOKUP_TABLE");
     303                    ERROR("Missing LOOKUP_TABLE");
    304304                    return NULL;
    305305                }
     
    310310                    if (fin.fail()) {
    311311                        deleteFieldData(fieldData, ftype);
    312                         result.error("Error in data stream");
     312                        ERROR("Error in data stream");
    313313                        return NULL;
    314314                    }
     
    320320                        if (fin.fail()) {
    321321                            deleteFieldData(fieldData, ftype);
    322                             result.error("Error in data stream");
     322                            ERROR("Error in data stream");
    323323                            return NULL;
    324324                        }
     
    333333    if (isRect < 0 || numRead != npts || npts < 1) {
    334334        deleteFieldData(fieldData, ftype);
    335         result.error("Error in data stream");
     335        ERROR("Error in data stream");
    336336        return NULL;
    337337    }
     
    468468    } else {
    469469        deleteFieldData(fieldData, ftype);
    470         result.error("Unsupported DataSet");
     470        ERROR("Unsupported DataSet");
    471471        return NULL;
    472472    }
     
    495495    float dz0 = -0.5*lz/lx;
    496496    if (volume) {
    497         volume->location(vrmath::Vector3f(dx0, dy0, dz0));
    498         TRACE("Set volume location to %g %g %g", dx0, dy0, dz0);
     497        volume->setPosition(vrmath::Vector3f(dx0, dy0, dz0));
     498        TRACE("Set volume position to %g %g %g", dx0, dy0, dz0);
    499499    }
    500500    return volume;
  • nanovis/branches/1.1/VtkReader.h

    r4889 r4904  
    99#include <iostream>
    1010
    11 namespace Rappture {
    12 class Outcome;
    13 }
    14 
    1511namespace nv {
    1612
     
    1814
    1915extern Volume *
    20 load_vtk_volume_stream(Rappture::Outcome& status, const char *tag, std::iostream& fin);
     16load_vtk_volume_stream(const char *tag, std::iostream& fin);
    2117
    2218}
  • nanovis/branches/1.1/ZincBlendeReconstructor.cpp

    r4889 r4904  
    6262    do {
    6363        getLine(stream);
    64         if (buff[0] == '#') {
     64        if (_buff[0] == '#') {
    6565            continue;
    66         } else if (strstr((const char*) buff, "object") != 0) {
     66        } else if (strstr((const char*) _buff, "object") != 0) {
    6767            TRACE("VERSION 1");
    6868            version = 1;
    6969            break;
    70         } else if (strstr(buff, "record format") != 0) {
     70        } else if (strstr(_buff, "record format") != 0) {
    7171            TRACE("VERSION 2");
    7272            version = 2;
     
    7878        float dummy;
    7979
    80         sscanf(buff, "%s%s%s%s%s%d%d%d", str[0], str[1], str[2], str[3], str[4], &width, &height, &depth);
    81         getLine(stream);
    82         sscanf(buff, "%s%f%f%f", str[0], &(origin.x), &(origin.y), &(origin.z));
    83         getLine(stream);
    84         sscanf(buff, "%s%f%f%f", str[0], &(delta.x), &dummy, &dummy);
    85         getLine(stream);
    86         sscanf(buff, "%s%f%f%f", str[0], &dummy, &(delta.y), &dummy);
    87         getLine(stream);
    88         sscanf(buff, "%s%f%f%f", str[0], &dummy, &dummy, &(delta.z));
     80        sscanf(_buff, "%s%s%s%s%s%d%d%d", str[0], str[1], str[2], str[3], str[4], &width, &height, &depth);
     81        getLine(stream);
     82        sscanf(_buff, "%s%f%f%f", str[0], &(origin.x), &(origin.y), &(origin.z));
     83        getLine(stream);
     84        sscanf(_buff, "%s%f%f%f", str[0], &(delta.x), &dummy, &dummy);
     85        getLine(stream);
     86        sscanf(_buff, "%s%f%f%f", str[0], &dummy, &(delta.y), &dummy);
     87        getLine(stream);
     88        sscanf(_buff, "%s%f%f%f", str[0], &dummy, &dummy, &(delta.z));
    8989        do {
    9090            getLine(stream);
    91         } while (strcmp(buff, "<\\HDR>") != 0);
     91        } while (strcmp(_buff, "<\\HDR>") != 0);
    9292
    9393        width = width / 4;
     
    112112        do {
    113113            getLine(stream);
    114             if ((pt = strstr(buff, "delta")) != 0) {
     114            if ((pt = strstr(_buff, "delta")) != 0) {
    115115                sscanf(pt, "%s%f%f%f", str[0], &(delta.x), &(delta.y), &(delta.z));
    116116#ifdef _LOADER_DEBUG_
    117117                TRACE("delta : %f %f %f", delta.x, delta.y, delta.z);
    118118#endif
    119             } else if ((pt = strstr(buff, "datacount")) != 0) {
     119            } else if ((pt = strstr(_buff, "datacount")) != 0) {
    120120                sscanf(pt, "%s%d", str[0], &datacount);
    121121#ifdef _LOADER_DEBUG_
    122122                TRACE("datacount = %d", datacount);
    123123#endif
    124             } else if ((pt = strstr(buff, "datatype")) != 0) {
     124            } else if ((pt = strstr(_buff, "datatype")) != 0) {
    125125                sscanf(pt, "%s%s", str[0], str[1]);
    126126                if (strcmp(str[1], "double64")) {
    127127                }
    128             } else if ((pt = strstr(buff, "count")) != 0) {
     128            } else if ((pt = strstr(_buff, "count")) != 0) {
    129129                sscanf(pt, "%s%d%d%d", str[0], &width, &height, &depth);
    130130#ifdef _LOADER_DEBUG_
    131131                TRACE("width height depth %d %d %d", width, height, depth);
    132132#endif
    133             } else if ((pt = strstr(buff, "emptymark")) != 0) {
     133            } else if ((pt = strstr(_buff, "emptymark")) != 0) {
    134134                sscanf(pt, "%s%lf", str[0], &emptyvalue);
    135135#ifdef _LOADER_DEBUG_
    136136                TRACE("emptyvalue %lf", emptyvalue);
    137137#endif
    138             } else if ((pt = strstr(buff, "emprymark")) != 0) {
    139                 sscanf(pt, "%s%lf", str[0], &emptyvalue);
    140 #ifdef _LOADER_DEBUG_
    141                 TRACE("emptyvalue %lf", emptyvalue);
    142 #endif
    143138            }
    144         } while (strcmp(buff, "<\\HDR>") != 0 && strcmp(buff, "</HDR>") != 0);
     139        } while (strcmp(_buff, "<\\HDR>") != 0 && strcmp(_buff, "</HDR>") != 0);
    145140
    146141        data = malloc(width * height * depth * 8 * 4 * sizeof(double));
     
    358353        sin.get(ch);
    359354        if (ch == '\n') break;
    360         buff[index++] = ch;
     355        _buff[index++] = ch;
    361356        if (ch == '>') {
    362             if (buff[1] == '\\')
     357            if (_buff[1] == '\\')
    363358                break;
    364359        }
    365360    } while (!sin.eof());
    366361
    367     buff[index] = '\0';
    368 
    369 #ifdef _LOADER_DEBUG_
    370     TRACE("%s", buff);
     362    _buff[index] = '\0';
     363
     364#ifdef _LOADER_DEBUG_
     365    TRACE("%s", _buff);
    371366#endif
    372367}
     
    385380    do {
    386381        getLine(stream);
    387         if (buff[0] == '#') {
     382        if (_buff[0] == '#') {
    388383            continue;
    389         } else if (strstr((const char *)buff, "object") != 0) {
     384        } else if (strstr((const char *)_buff, "object") != 0) {
    390385            TRACE("VERSION 1");
    391386            version = 1;
    392387            break;
    393         } else if (strstr(buff, "record format") != 0) {
     388        } else if (strstr(_buff, "record format") != 0) {
    394389            TRACE("VERSION 2");
    395390            version = 2;
     
    401396        float dummy;
    402397
    403         sscanf(buff, "%s%s%s%s%s%d%d%d", str[0], str[1], str[2], str[3], str[4],&width, &height, &depth);
    404         getLine(stream);
    405         sscanf(buff, "%s%f%f%f", str[0], &(origin.x), &(origin.y), &(origin.z));
    406         getLine(stream);
    407         sscanf(buff, "%s%f%f%f", str[0], &(delta.x), &dummy, &dummy);
    408         getLine(stream);
    409         sscanf(buff, "%s%f%f%f", str[0], &dummy, &(delta.y), &dummy);
    410         getLine(stream);
    411         sscanf(buff, "%s%f%f%f", str[0], &dummy, &dummy, &(delta.z));
     398        sscanf(_buff, "%s%s%s%s%s%d%d%d", str[0], str[1], str[2], str[3], str[4],&width, &height, &depth);
     399        getLine(stream);
     400        sscanf(_buff, "%s%f%f%f", str[0], &(origin.x), &(origin.y), &(origin.z));
     401        getLine(stream);
     402        sscanf(_buff, "%s%f%f%f", str[0], &(delta.x), &dummy, &dummy);
     403        getLine(stream);
     404        sscanf(_buff, "%s%f%f%f", str[0], &dummy, &(delta.y), &dummy);
     405        getLine(stream);
     406        sscanf(_buff, "%s%f%f%f", str[0], &dummy, &dummy, &(delta.z));
    412407        do {
    413408            getLine(stream);
    414         } while (strcmp(buff, "<\\HDR>") != 0);
     409        } while (strcmp(_buff, "<\\HDR>") != 0);
    415410
    416411        width = width / 4;
     
    430425        do {
    431426            getLine(stream);
    432             if ((pt = strstr(buff, "delta")) != 0) {   
     427            if ((pt = strstr(_buff, "delta")) != 0) {   
    433428                sscanf(pt, "%s%f%f%f", str[0], &(delta.x), &(delta.y), &(delta.z));
    434429#ifdef _LOADER_DEBUG_
    435430                TRACE("delta : %f %f %f", delta.x, delta.y, delta.z);
    436431#endif
    437             } else if ((pt = strstr(buff, "datacount")) != 0) {
     432            } else if ((pt = strstr(_buff, "datacount")) != 0) {
    438433                sscanf(pt, "%s%d", str[0], &datacount);
    439434                TRACE("datacount = %d", datacount);
    440             } else if ((pt = strstr(buff, "datatype")) != 0) {
     435            } else if ((pt = strstr(_buff, "datatype")) != 0) {
    441436                sscanf(pt, "%s%s", str[0], str[1]);
    442437                if (strcmp(str[1], "double64")) {
    443438                }
    444             } else if ((pt = strstr(buff, "count")) != 0) {
     439            } else if ((pt = strstr(_buff, "count")) != 0) {
    445440                sscanf(pt, "%s%d%d%d", str[0], &width, &height, &depth);
    446441#ifdef _LOADER_DEBUG_
    447442                TRACE("width height depth %d %d %d", width, height, depth);
    448443#endif
    449             } else if ((pt = strstr(buff, "emptymark")) != 0) {
     444            } else if ((pt = strstr(_buff, "emptymark")) != 0) {
    450445                sscanf(pt, "%s%lf", str[0], &emptyvalue);
    451446#ifdef _LOADER_DEBUG_
    452447                TRACE("emptyvalue %lf", emptyvalue);
    453448#endif
    454             } else if ((pt = strstr(buff, "emprymark")) != 0) {
    455                 sscanf(pt, "%s%lf", str[0], &emptyvalue);
    456 #ifdef _LOADER_DEBUG_
    457                 TRACE("emptyvalue %lf", emptyvalue);
    458 #endif
    459449            }
    460         } while (strcmp(buff, "<\\HDR>") != 0 && strcmp(buff, "</HDR>") != 0);
     450        } while (strcmp(_buff, "<\\HDR>") != 0 && strcmp(_buff, "</HDR>") != 0);
    461451
    462452        if (datacount == -1) datacount = width * height * depth;
     
    481471        ++stream;
    482472        if (ch == '\n') break;
    483         buff[index++] = ch;
     473        _buff[index++] = ch;
    484474        if (ch == '>') {
    485             if (buff[1] == '\\')
     475            if (_buff[1] == '\\')
    486476                break;
    487477        }
    488478    } while (1);
    489479
    490     buff[index] = '\0';
    491 
    492 #ifdef _LOADER_DEBUG_
    493     TRACE("%s", buff);
    494 #endif
    495 }
     480    _buff[index] = '\0';
     481
     482#ifdef _LOADER_DEBUG_
     483    TRACE("%s", _buff);
     484#endif
     485}
  • nanovis/branches/1.1/ZincBlendeReconstructor.h

    r4889 r4904  
    6666    void getLine(const unsigned char*& stream);
    6767
    68     char buff[255];
     68    char _buff[255];
    6969
    7070    /// A ZincBlendeReconstructor Singleton instance
  • nanovis/branches/1.1/ZincBlendeVolume.cpp

    r4889 r4904  
    2525
    2626ZincBlendeVolume::ZincBlendeVolume(float x, float y, float z,
    27                                    int w, int h, int d, int n,
     27                                   int width, int height, int depth,
     28                                   int numComponents,
    2829                                   float *dataVolumeA, float *dataVolumeB,
    29                                    double v0, double v1, double non_zeromin,
     30                                   double vmin, double vmax, double nonZeroMin,
    3031                                   const Vector3f& cellSz) :
    31     Volume(x, y, z, w, h, d, n, dataVolumeA, v0, v1, non_zeromin),
     32    Volume(x, y, z, width, height, depth, numComponents, dataVolumeA, vmin, vmax, nonZeroMin),
    3233    cellSize(cellSz)
    3334{
     
    3536    _volumeType = ZINCBLENDE;
    3637
    37     //store member tex initialize in Volume() as zincblende_tex[0]
     38    //store member tex initialize in Volume() as zincblendeTex[0]
    3839    assert(_tex);
    3940    zincblendeTex[0] = _tex;
    4041
    41     //now add another tex as zincblende_tex[1]
    42     Texture3D *secondTex = new Texture3D(w, h, d, GL_FLOAT, GL_LINEAR, n);
     42    //now add another tex as zincblendeTex[1]
     43    Texture3D *secondTex = new Texture3D(width, height, depth, GL_FLOAT, GL_LINEAR, numComponents);
    4344    assert(secondTex);
    4445    secondTex->initialize(dataVolumeB);
     
    4950ZincBlendeVolume::~ZincBlendeVolume()
    5051{
    51     // This data will be deleted in a destrutor of Volume class
    52     //if (zincblende_tex[0])
    53     //  delete zincblende_tex[0];
     52    // First texture will be deleted in ~Volume()
    5453    if (zincblendeTex[1])
    5554        delete zincblendeTex[1];
  • nanovis/branches/1.1/ZincBlendeVolumeShader.cpp

    r4889 r4904  
    2121void ZincBlendeVolumeShader::init()
    2222{
    23     loadFragmentProgram("zincblende_volume.cg", "main");
     23    loadFragmentProgram("zincblende_volume.cg");
    2424}
    2525
  • nanovis/branches/1.1/configure

    r4600 r4904  
    635635CG_INC_SPEC
    636636FFMPEG
     637AVCONV
    637638EGREP
    638639GREP
     
    699700with_rappture
    700701with_ffmpeg
     702with_avconv
    701703with_statsdir
    702704'
     
    13271329                          include/rappture.h [default=/usr]
    13281330  --with-ffmpeg=DIR       location of ffmpeg [default=yes]
     1331  --with-avconv=DIR       location of avconv [default=yes]
    13291332  --with-statsdir=DIR     Write statistics in DIR
    13301333
     
    22602263
    22612264
     2265# Check whether --with-avconv was given.
     2266if test "${with_avconv+set}" = set; then :
     2267  withval=$with_avconv;
     2268else
     2269  with_avconv=yes
     2270fi
     2271
     2272
     2273
    22622274# Check whether --with-statsdir was given.
    22632275if test "${with_statsdir+set}" = set; then :
     
    47224734
    47234735#--------------------------------------------------------------------
     4736# search for avconv executable
     4737#--------------------------------------------------------------------
     4738if test "${with_avconv}" != "no" ; then
     4739  if test "${with_avconv}" = "yes" ; then
     4740    # Extract the first word of "avconv", so it can be a program name with args.
     4741set dummy avconv; ac_word=$2
     4742{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     4743$as_echo_n "checking for $ac_word... " >&6; }
     4744if ${ac_cv_path_AVCONV+:} false; then :
     4745  $as_echo_n "(cached) " >&6
     4746else
     4747  case $AVCONV in
     4748  [\\/]* | ?:[\\/]*)
     4749  ac_cv_path_AVCONV="$AVCONV" # Let the user override the test with a path.
     4750  ;;
     4751  *)
     4752  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4753for as_dir in $PATH
     4754do
     4755  IFS=$as_save_IFS
     4756  test -z "$as_dir" && as_dir=.
     4757    for ac_exec_ext in '' $ac_executable_extensions; do
     4758  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     4759    ac_cv_path_AVCONV="$as_dir/$ac_word$ac_exec_ext"
     4760    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     4761    break 2
     4762  fi
     4763done
     4764  done
     4765IFS=$as_save_IFS
     4766
     4767  ;;
     4768esac
     4769fi
     4770AVCONV=$ac_cv_path_AVCONV
     4771if test -n "$AVCONV"; then
     4772  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AVCONV" >&5
     4773$as_echo "$AVCONV" >&6; }
     4774else
     4775  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4776$as_echo "no" >&6; }
     4777fi
     4778
     4779
     4780  else
     4781    # Extract the first word of "avconv", so it can be a program name with args.
     4782set dummy avconv; ac_word=$2
     4783{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     4784$as_echo_n "checking for $ac_word... " >&6; }
     4785if ${ac_cv_path_AVCONV+:} false; then :
     4786  $as_echo_n "(cached) " >&6
     4787else
     4788  case $AVCONV in
     4789  [\\/]* | ?:[\\/]*)
     4790  ac_cv_path_AVCONV="$AVCONV" # Let the user override the test with a path.
     4791  ;;
     4792  *)
     4793  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4794as_dummy="${with_avconv}/bin:${with_avconv}"
     4795for as_dir in $as_dummy
     4796do
     4797  IFS=$as_save_IFS
     4798  test -z "$as_dir" && as_dir=.
     4799    for ac_exec_ext in '' $ac_executable_extensions; do
     4800  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     4801    ac_cv_path_AVCONV="$as_dir/$ac_word$ac_exec_ext"
     4802    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     4803    break 2
     4804  fi
     4805done
     4806  done
     4807IFS=$as_save_IFS
     4808
     4809  ;;
     4810esac
     4811fi
     4812AVCONV=$ac_cv_path_AVCONV
     4813if test -n "$AVCONV"; then
     4814  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AVCONV" >&5
     4815$as_echo "$AVCONV" >&6; }
     4816else
     4817  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4818$as_echo "no" >&6; }
     4819fi
     4820
     4821
     4822  fi
     4823  if test "${AVCONV}x" != "x" ; then
     4824
     4825$as_echo "#define HAVE_AVCONV 1" >>confdefs.h
     4826
     4827  fi
     4828fi
     4829
     4830#--------------------------------------------------------------------
    47244831# search for ffmpeg executable
    47254832#--------------------------------------------------------------------
     
    48764983  LD_RPATH="$loader_run_path:${CG_LIB_DIR}"
    48774984fi
     4985
    48784986
    48794987
  • nanovis/branches/1.1/configure.in

    r4600 r4904  
    2424    [],
    2525    [with_ffmpeg=yes])
     26
     27AC_ARG_WITH(
     28    [avconv],
     29    [AS_HELP_STRING([--with-avconv[=DIR]],
     30      [location of avconv @<:@default=yes@:>@])],
     31    [],
     32    [with_avconv=yes])
    2633
    2734AC_ARG_WITH(
     
    148155
    149156#--------------------------------------------------------------------
     157# search for avconv executable
     158#--------------------------------------------------------------------
     159if test "${with_avconv}" != "no" ; then
     160  if test "${with_avconv}" = "yes" ; then
     161    AC_PATH_PROG(AVCONV, avconv)
     162  else
     163    AC_PATH_PROG(AVCONV, avconv, [], [${with_avconv}/bin:${with_avconv}])
     164  fi
     165  if test "${AVCONV}x" != "x" ; then
     166    AC_DEFINE(HAVE_AVCONV, 1, [nanovis can use avconv to create videos.])
     167  fi
     168fi
     169
     170#--------------------------------------------------------------------
    150171# search for ffmpeg executable
    151172#--------------------------------------------------------------------
     
    208229AC_SUBST(CG_INC_SPEC)
    209230AC_SUBST(CG_LIB_SPEC)
     231AC_SUBST(AVCONV)
    210232AC_SUBST(FFMPEG)
    211233AC_SUBST(LD_RPATH)
  • nanovis/branches/1.1/dxReader.cpp

    r4889 r4904  
    2929#include <string>
    3030
    31 #include <RpOutcome.h>
    32 #include <RpField1D.h>
     31#include <RpMesh1D.h>
    3332#include <RpFieldRect3D.h>
    3433#include <RpFieldPrism3D.h>
     
    5857 */
    5958Volume *
    60 nv::load_dx_volume_stream(Rappture::Outcome& result, const char *tag,
    61                           std::iostream& fin)
     59nv::load_dx_volume_stream(const char *tag, std::iostream& fin)
    6260{
    6361    TRACE("Enter tag:%s", tag);
     
    8381        fin.getline(line, sizeof(line) - 1);
    8482        if (fin.fail()) {
    85             result.error("error in data stream");
     83            ERROR("error in data stream");
    8684            return NULL;
    8785        }
     
    158156                    ftri.close();
    159157                } else {
    160                     result.error("triangularization failed");
     158                    ERROR("triangularization failed");
    161159                    return NULL;
    162160                }
     
    183181                }
    184182                if (count > 1) {
    185                     result.addError("don't know how to handle multiple non-zero"
    186                                     " delta values");
     183                    ERROR("don't know how to handle multiple non-zero"
     184                          " delta values");
    187185                    return NULL;
    188186                }
     
    190188                              &dummy, type, &npts) == 3) {
    191189                if (isrect && (npts != nx*ny*nz)) {
    192                     result.addError("inconsistent data: expected %d points"
    193                                     " but found %d points", nx*ny*nz, npts);
     190                    ERROR("inconsistent data: expected %d points"
     191                          " but found %d points", nx*ny*nz, npts);
    194192                    return NULL;
    195193                } else if (!isrect && (npts != nxy*nz)) {
    196                     result.addError("inconsistent data: expected %d points"
    197                                     " but found %d points", nxy*nz, npts);
     194                    ERROR("inconsistent data: expected %d points"
     195                          " but found %d points", nxy*nz, npts);
    198196                    return NULL;
    199197                }
     
    202200                              &dummy, type, &npts) == 3) {
    203201                if (npts != nx*ny*nz) {
    204                     result.addError("inconsistent data: expected %d points"
    205                                     " but found %d points", nx*ny*nz, npts);
     202                    ERROR("inconsistent data: expected %d points"
     203                          " but found %d points", nx*ny*nz, npts);
    206204                    return NULL;
    207205                }
     
    220218    // read data points
    221219    if (fin.eof()) {
    222         result.error("data not found in stream");
     220        ERROR("data not found in stream");
    223221        return NULL;
    224222    }
     
    247245            fin.getline(line,sizeof(line)-1);
    248246            if (fin.fail()) {
    249                 result.addError("error reading data points");
     247                ERROR("error reading data points");
    250248                return NULL;
    251249            }
     
    287285        // make sure that we read all of the expected points
    288286        if (nread != npts) {
    289             result.addError("inconsistent data: expected %d points"
    290                             " but found %d points", npts, nread);
     287            ERROR("inconsistent data: expected %d points"
     288                  " but found %d points", npts, nread);
    291289            return NULL;
    292290        }
     
    390388            fin >> dval;
    391389            if (fin.fail()) {
    392                 result.addError("after %d of %d points: can't read number",
    393                                 nread, npts);
     390                ERROR("after %d of %d points: can't read number",
     391                      nread, npts);
    394392                return NULL;
    395393            } else {
     
    407405        // make sure that we read all of the expected points
    408406        if (nread != npts) {
    409             result.addError("inconsistent data: expected %d points"
    410                             " but found %d points", npts, nread);
     407            ERROR("inconsistent data: expected %d points"
     408                  " but found %d points", npts, nread);
    411409            return NULL;
    412410        }
     
    495493    float dz0 = -0.5*lz/lx;
    496494    if (volume) {
    497         volume->location(vrmath::Vector3f(dx0, dy0, dz0));
    498         TRACE("Set volume location to %g %g %g", dx0, dy0, dz0);
     495        volume->setPosition(vrmath::Vector3f(dx0, dy0, dz0));
     496        TRACE("Set volume position to %g %g %g", dx0, dy0, dz0);
    499497    }
    500498    return volume;
  • nanovis/branches/1.1/dxReader.h

    r4889 r4904  
    99#include <iostream>
    1010
    11 namespace Rappture {
    12 class Outcome;
    13 }
    14 
    1511namespace nv {
    1612
     
    1814
    1915extern Volume *
    20 load_dx_volume_stream(Rappture::Outcome& status, const char *tag,
    21                       std::iostream& fin);
     16load_dx_volume_stream(const char *tag, std::iostream& fin);
    2217
    2318}
  • nanovis/branches/1.1/graphics/Makefile.in

    r3470 r4904  
    5959
    6060clean:
    61         $(RM) $(NVGRAPHICSLIB) $(OBJS)
     61        $(RM) *.a *.o
    6262
    6363distclean: clean
  • nanovis/branches/1.1/imgLoaders/Makefile.in

    r3470 r4904  
    5959
    6060clean:
    61         $(RM) $(IMGLIB) $(OBJS)
     61        $(RM) *.a *.o
    6262
    6363distclean: clean
  • nanovis/branches/1.1/nanovis.cpp

    r4893 r4904  
    2222
    2323#include <cassert>
     24#include <cerrno>
    2425#include <cstdlib>
    2526#include <cstdio>
     
    7374Tcl_Interp *NanoVis::interp = NULL;
    7475
    75 unsigned int NanoVis::flags = 0;
     76bool NanoVis::redrawPending = false;
    7677bool NanoVis::debugFlag = false;
    7778bool NanoVis::axisOn = true;
     
    8384Texture2D *NanoVis::legendTexture = NULL;
    8485Fonts *NanoVis::fonts;
    85 int NanoVis::updir = Y_POS;
    86 Camera *NanoVis::cam = NULL;
     86Camera *NanoVis::_camera = NULL;
    8787RenderContext *NanoVis::renderContext = NULL;
    8888
     
    110110Grid *NanoVis::grid = NULL;
    111111
    112 // Image based flow visualization slice location
    113 // FLOW
    114 float NanoVis::_licSlice = 0.5f;
    115 int NanoVis::_licAxis = 2; // z axis
    116 
    117112//frame buffer for final rendering
    118113GLuint NanoVis::_finalFbo = 0;
     
    121116
    122117// Default camera location.
    123 float def_eye_x = 0.0f;
    124 float def_eye_y = 0.0f;
    125 float def_eye_z = 2.5f;
     118Vector3f def_eye(0.0f, 0.0f, 2.5f);
    126119
    127120void
     
    129122{
    130123    TRACE("Enter");
     124
    131125    if (grid != NULL) {
    132126        TRACE("Deleting grid");
    133127        delete grid;
    134128    }
    135     if (cam != NULL) {
    136         TRACE("Deleting cam");
    137         delete cam;
     129    if (_camera != NULL) {
     130        TRACE("Deleting camera");
     131        delete _camera;
    138132    }
    139133    if (volRenderer != NULL) {
     
    175169}
    176170
    177 void
    178 NanoVis::eventuallyRedraw(unsigned int flag)
    179 {
    180     if (flag) {
    181         flags |= flag;
    182     }
    183     if ((flags & REDRAW_PENDING) == 0) {
     171void
     172NanoVis::eventuallyRedraw()
     173{
     174    if (!redrawPending) {
    184175        glutPostRedisplay();
    185         flags |= REDRAW_PENDING;
    186     }
    187 }
    188 
    189 void
    190 NanoVis::pan(float dx, float dy)
     176        redrawPending = true;
     177    }
     178}
     179
     180void
     181NanoVis::panCamera(float dx, float dy)
    191182{
    192183    /* Move the camera and its target by equal amounts along the x and y
     
    194185    TRACE("pan: x=%f, y=%f", dx, dy);
    195186
    196     cam->x(def_eye_x - dx);
    197     cam->y(def_eye_y + dy);
    198     TRACE("set eye to %f %f", cam->x(), cam->y());
    199 }
    200 
    201 void
    202 NanoVis::zoom(float z)
     187    _camera->x(def_eye.x - dx);
     188    _camera->y(def_eye.y + dy);
     189    TRACE("set eye to %f %f", _camera->x(), _camera->y());
     190}
     191
     192void
     193NanoVis::zoomCamera(float z)
    203194{
    204195    /* Move the camera and its target by equal amounts along the x and y
     
    206197    TRACE("zoom: z=%f", z);
    207198
    208     cam->z(def_eye_z / z);
     199    _camera->z(def_eye.z / z);
    209200
    210201    collectBounds();
    211     cam->resetClippingRange(sceneMin, sceneMax);
    212 
    213     TRACE("set cam z to %f", cam->z());
     202    _camera->resetClippingRange(sceneMin, sceneMax);
     203
     204    TRACE("set camera z to %f", _camera->z());
     205}
     206
     207void
     208NanoVis::rotateCamera(float phi, float theta, float psi)
     209{
     210    _camera->orient(phi, theta, psi);
     211}
     212
     213void
     214NanoVis::orientCamera(double *quat)
     215{
     216    _camera->orient(quat);
     217}
     218
     219void
     220NanoVis::setCameraPosition(Vector3f pos)
     221{
     222    _camera->setPosition(pos);
     223}
     224
     225void
     226NanoVis::setCameraUpdir(Camera::AxisDirection dir)
     227{
     228    _camera->setUpdir(dir);
    214229}
    215230
     
    220235
    221236    collectBounds();
    222     cam->reset(sceneMin, sceneMax, resetOrientation);
    223 
    224     def_eye_x = cam->x();
    225     def_eye_y = cam->y();
    226     def_eye_z = cam->z();
     237    _camera->reset(sceneMin, sceneMax, resetOrientation);
     238
     239    def_eye = _camera->getPosition();
    227240}
    228241
     
    456469    TRACE("change camera");
    457470    //change the camera setting
    458     cam->setScreenSize(0, 0, winWidth, winHeight);
     471    _camera->setViewport(0, 0, winWidth, winHeight);
    459472    planeRenderer->setScreenSize(winWidth, winHeight);
    460473
    461474    TRACE("Leave (%d, %d)", w, h);
    462475    return true;
    463 }
    464 
    465 static
    466 void cgErrorCallback(void)
    467 {
    468     if (!Shader::printErrorInfo()) {
    469         TRACE("Cg error, exiting...");
    470         exit(1);
    471     }
    472476}
    473477
     
    541545    ImageLoaderFactory::getInstance()->addLoaderImpl("bmp", new BMPImageLoaderImpl());
    542546
    543     Shader::initCg();
    544     Shader::setErrorCallback(cgErrorCallback);
    545 
    546     fonts = new Fonts();
    547     fonts->addFont("verdana", "verdana.fnt");
    548     fonts->setFont("verdana");
    549 
    550     velocityArrowsSlice = new VelocityArrowsSlice;
    551     licRenderer = new LIC(NMESH, NPIX, NPIX, _licAxis, _licSlice);
    552 
    553     grid = new Grid();
    554     grid->setFont(fonts);
    555 
    556547    return true;
    557548}
     
    570561
    571562    //create the camera with default setting
    572     cam = new Camera(0, 0, winWidth, winHeight,
    573                      def_eye_x, def_eye_y, def_eye_z);
     563    _camera = new Camera(0, 0, winWidth, winHeight);
     564    _camera->setPosition(def_eye);
    574565
    575566    glEnable(GL_TEXTURE_2D);
     
    583574    GLfloat mat_shininess[] = {30.0};
    584575    GLfloat white_light[] = {1.0, 1.0, 1.0, 1.0};
    585     GLfloat green_light[] = {0.1, 0.5, 0.1, 1.0};
    586576
    587577    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
     
    589579    glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);
    590580    glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);
    591     glLightfv(GL_LIGHT1, GL_DIFFUSE, green_light);
     581    glLightfv(GL_LIGHT1, GL_DIFFUSE, white_light);
    592582    glLightfv(GL_LIGHT1, GL_SPECULAR, white_light);
    593583
     
    597587    }
    598588
     589    fonts = new Fonts();
     590    fonts->addFont("verdana", "verdana.fnt");
     591    fonts->setFont("verdana");
     592
     593    renderContext = new RenderContext();
     594
    599595    volRenderer = new VolumeRenderer();
    600596
    601     renderContext = new RenderContext();
    602 
    603597    planeRenderer = new PlaneRenderer(winWidth, winHeight);
     598
     599    velocityArrowsSlice = new VelocityArrowsSlice();
     600
     601    licRenderer = new LIC();
     602
     603    grid = new Grid();
     604    grid->setFont(fonts);
    604605
    605606    //assert(glGetError()==0);
     
    869870NanoVis::draw3dAxis()
    870871{
     872    if (!axisOn)
     873        return;
     874
    871875    glPushAttrib(GL_ENABLE_BIT);
    872876
     
    10941098NanoVis::collectBounds(bool onlyVisible)
    10951099{
    1096     if (flags & MAP_FLOWS) {
    1097         mapFlows();
     1100    if (Flow::updatePending) {
     1101        setFlowRanges();
    10981102        grid->xAxis.setScale(xMin, xMax);
    10991103        grid->yAxis.setScale(yMin, yMax);
     
    12761280
    12771281bool
    1278 NanoVis::mapFlows()
     1282NanoVis::setFlowRanges()
    12791283{
    12801284    TRACE("Enter");
    1281 
    1282     flags &= ~MAP_FLOWS;
    12831285
    12841286    /*
     
    12861288     *         flow vectors.
    12871289     */
    1288     magMin = DBL_MAX, magMax = -DBL_MAX;
     1290    magMin = DBL_MAX;
     1291    magMax = -DBL_MAX;
    12891292
    12901293    for (FlowHashmap::iterator itr = flowTable.begin();
     
    13421345        }
    13431346        // FIXME: This doesn't work when there is more than one flow.
    1344         licRenderer->setOffset(flow->getRelativePosition());
    1345         velocityArrowsSlice->slicePos(flow->getRelativePosition());
     1347        licRenderer->setSlicePosition(flow->getRelativePosition());
     1348        velocityArrowsSlice->setSlicePosition(flow->getRelativePosition());
    13461349    }
    13471350    advectFlows();
     1351
     1352    Flow::updatePending = false;
    13481353    return true;
    13491354}
     
    13751380        }
    13761381    }
    1377     flags &= ~REDRAW_PENDING;
    13781382}
    13791383
     
    13811385NanoVis::resetFlows()
    13821386{
    1383     if (licRenderer->active()) {
    1384         NanoVis::licRenderer->reset();
    1385     }
     1387    NanoVis::licRenderer->reset();
    13861388    for (FlowHashmap::iterator itr = flowTable.begin();
    13871389         itr != flowTable.end(); ++itr) {
    13881390        Flow *flow = itr->second;
    1389         if (flow->isDataLoaded() && flow->visible()) {
     1391        if (flow->isDataLoaded()) {
    13901392            flow->resetParticles();
    13911393        }
     
    13991401         itr != flowTable.end(); ++itr) {
    14001402        Flow *flow = itr->second;
    1401         if (flow->isDataLoaded() && flow->visible()) {
     1403        if (flow->isDataLoaded()) {
    14021404            flow->advect();
    14031405        }
     
    14101412    TRACE("Enter");
    14111413
    1412     if (flags & MAP_FLOWS) {
    1413 #ifdef notdef
    1414         xMin = yMin = zMin = wMin = FLT_MAX, magMin = DBL_MAX;
    1415         xMax = yMax = zMax = wMax = -FLT_MAX, magMax = -DBL_MAX;
    1416 #endif
    1417         mapFlows();
     1414    if (Flow::updatePending) {
     1415        setFlowRanges();
    14181416        grid->xAxis.setScale(xMin, xMax);
    14191417        grid->yAxis.setScale(yMin, yMax);
    14201418        grid->zAxis.setScale(zMin, zMax);
    14211419    }
    1422     //assert(glGetError()==0);
    14231420    if (HeightMap::updatePending) {
    14241421        setHeightmapRanges();
     
    14281425    }
    14291426
    1430     //start final rendering
     1427    // Start final rendering
    14311428
    14321429    // Need to reset fbo since it may have been changed to default (0)
    14331430    bindOffscreenBuffer();
    14341431
    1435     //clear screen
     1432    // Clear screen
    14361433    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    14371434
     
    14391436    glEnable(GL_COLOR_MATERIAL);
    14401437
    1441     //camera setting activated
    1442     cam->initialize();
    1443 
    1444     //set up the orientation of items in the scene.
     1438    // Emit modelview and projection matrices
     1439    _camera->initialize();
     1440
     1441    // Rotate for updir if required
    14451442    glPushMatrix();
    14461443
    1447     switch (updir) {
    1448     case X_POS:
     1444    switch (_camera->getUpdir()) {
     1445    case Camera::X_POS:
    14491446        glRotatef(90, 0, 0, 1);
    14501447        glRotatef(90, 1, 0, 0);
    14511448        break;
    1452     case Y_POS:
     1449    case Camera::Y_POS:
    14531450        // this is the default
    14541451        break;
    1455     case Z_POS:
     1452    case Camera::Z_POS:
    14561453        glRotatef(-90, 1, 0, 0);
    14571454        glRotatef(-90, 0, 0, 1);
    14581455        break;
    1459     case X_NEG:
     1456    case Camera::X_NEG:
    14601457        glRotatef(-90, 0, 0, 1);
    14611458        break;
    1462     case Y_NEG:
     1459    case Camera::Y_NEG:
    14631460        glRotatef(180, 0, 0, 1);
    14641461        glRotatef(-90, 0, 1, 0);
    14651462        break;
    1466     case Z_NEG:
     1463    case Camera::Z_NEG:
    14671464        glRotatef(90, 1, 0, 0);
    14681465        break;
    14691466    }
    14701467
    1471     //now render things in the scene
    1472     if (axisOn) {
    1473         draw3dAxis();
    1474     }
     1468    // Now render things in the scene
     1469
     1470    draw3dAxis();
     1471
    14751472    grid->render();
    1476     if ((licRenderer != NULL) && (licRenderer->active())) {
    1477         licRenderer->render();
    1478     }
    1479     if ((velocityArrowsSlice != NULL) && (velocityArrowsSlice->enabled())) {
    1480         velocityArrowsSlice->render();
    1481     }
     1473
     1474    licRenderer->render();
     1475
     1476    velocityArrowsSlice->render();
     1477
    14821478    renderFlows();
    14831479
    14841480    volRenderer->renderAll();
    14851481
    1486     HeightMapHashmap::iterator itr;
    1487     for (itr = heightMapTable.begin();
     1482    for (HeightMapHashmap::iterator itr = heightMapTable.begin();
    14881483         itr != heightMapTable.end(); ++itr) {
    1489         HeightMap *heightMap = itr->second;
    1490         if (heightMap->isVisible()) {
    1491             heightMap->render(renderContext);
    1492         }
     1484        itr->second->render(renderContext);
    14931485    }
    14941486    glPopMatrix();
     
    14961488    CHECK_FRAMEBUFFER_STATUS();
    14971489    TRACE("Leave");
    1498 }
    1499 
     1490    redrawPending = false;
     1491}
  • nanovis/branches/1.1/nanovis.h

    r4889 r4904  
    2828
    2929#include "config.h"
     30#include "Camera.h"
    3031
    3132//defines for the image based flow visualization
     
    4142}
    4243
    43 class Camera;
    4444class Flow;
    4545class Grid;
     
    5656{
    5757public:
    58     enum AxisDirections {
    59         X_POS = 1,
    60         Y_POS = 2,
    61         Z_POS = 3,
    62         X_NEG = -1,
    63         Y_NEG = -2,
    64         Z_NEG = -3
    65     };
    66 
    67     enum NanoVisFlags {
    68         REDRAW_PENDING = (1 << 0),
    69         MAP_FLOWS = (1 << 1)
    70     };
    71 
    7258    typedef std::string TransferFunctionId;
    7359    typedef std::string VolumeId;
     
    9177    static const Camera *getCamera()
    9278    {
    93         return cam;
     79        return _camera;
    9480    }
    95     static void pan(float dx, float dy);
    96     static void zoom(float z);
     81    static void panCamera(float dx, float dy);
     82    static void zoomCamera(float z);
     83    static void rotateCamera(float phi, float theta, float psi);
     84    static void orientCamera(double *quat);
     85    static void setCameraPosition(vrmath::Vector3f pos);
     86    static void setCameraUpdir(Camera::AxisDirection dir);
    9787    static void resetCamera(bool resetOrientation = false);
    9888
    99     static void eventuallyRedraw(unsigned int flag = 0);
     89    static void eventuallyRedraw();
    10090
    10191    static void ppmWrite(const char *prefix);
     
    129119    static void setVolumeRanges();
    130120    static void setHeightmapRanges();
     121    static bool setFlowRanges();
    131122
    132123    static Flow *getFlow(const char *name);
     
    134125    static void deleteFlows(Tcl_Interp *interp);
    135126    static void deleteFlow(const char *name);
    136     static bool mapFlows();
    137127    static void getFlowBounds(vrmath::Vector3f& min,
    138128                              vrmath::Vector3f& max,
     
    145135    static Tcl_Interp *interp;
    146136
    147     static unsigned int flags;
     137    static bool redrawPending;
    148138    static bool debugFlag;
    149139    static bool axisOn;
     
    155145    static Texture2D *legendTexture;
    156146    static util::Fonts *fonts;
    157     static int updir;
    158     static Camera *cam;
    159147    static graphics::RenderContext *renderContext;
    160148
     
    177165    static void collectBounds(bool onlyVisible = false);
    178166
    179     static float _licSlice;  ///< Slice position [0,1]
    180     static int _licAxis;     ///< Slice axis: 0:x, 1:y, 2:z
     167    static Camera *_camera;
    181168
    182169    //frame buffer for final rendering
  • nanovis/branches/1.1/nanovisServer.cpp

    r4889 r4904  
    1616#include <sys/time.h>
    1717#include <sys/times.h>
    18 #include <sys/types.h> // for pid_t
    1918#include <sys/uio.h> // for readv/writev
    2019#include <unistd.h>
     
    334333    NanoVis::removeAllData();
    335334
    336     Shader::exitCg();
     335    Shader::exit();
    337336
    338337    //close log file
     
    377376    int ret = 0;
    378377    int status = TCL_OK;
    379     NanoVis::flags &= ~NanoVis::REDRAW_PENDING;
    380378
    381379    Tcl_DString cmdbuffer;
     
    637635    }
    638636
     637    Shader::init();
    639638    // Override callback with one that cleans up server on exit
    640639    Shader::setErrorCallback(shaderErrorCallback);
  • nanovis/branches/1.1/newmat11/Makefile.in

    r3470 r4904  
    7373
    7474clean:
    75         $(RM) $(MATLIB) $(OBJS)
     75        $(RM) *.a *.o
    7676
    7777distclean: clean
  • nanovis/branches/1.1/nvconf.h.in

    r3559 r4904  
    1 /* nanovis/nvconf.h.in.  Generated from configure.in by autoheader.  */
     1/* nvconf.h.in.  Generated from configure.in by autoheader.  */
    22
    33/* Define if building universal (internal helper macro) */
     
    99/* Define to 1 if you have the <arpa/inet.h> header file. */
    1010#undef HAVE_ARPA_INET_H
     11