Changeset 827


Ignore:
Timestamp:
Dec 13, 2007 7:24:01 PM (13 years ago)
Author:
vrinside
Message:

Added color blending with point sprite texture

Location:
trunk/vizservers/nanovis
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/vizservers/nanovis/PCASplit.cpp

    r825 r827  
    9797                finalSize += data[i].size * sqrt(distance);
    9898                */
    99                 if (distance > finalSize) finalSize = distance;;
     99                if (distance > finalSize) finalSize = distance;
    100100        }
    101101
     
    103103        //finalSize = 0.5f * sqrt (finalSize) / (float) (count - 1) + maxSize;
    104104        finalSize = sqrt (finalSize) + maxSize;
    105        
    106105}
    107106       
     
    270269void PCASplit::analyze(ClusterListNode* clusterNode, Cluster* parent, int level, float limit)
    271270{
     271    fflush(stdout);
    272272        if (level > _maxLevel) return;
    273273        else if (level > _finalMaxLevel) _finalMaxLevel = level;
     
    335335                                                0.2);
    336336
    337             printf("CLUSTER points : %d\n", node->data->numOfPoints_t);
    338             fflush(stdout);
    339                                        
    340337                                        points[i].position = node->data->centroid_t;
    341338                                        points[i].color.set(1.0f, 1.0f, 1.0f, 0.2f);
     
    392389                                }
    393390
    394                                 printf("points %d\n", curClusterNodeCount);
    395391                        }
    396392                }
  • trunk/vizservers/nanovis/PCASplit.h

    r825 r827  
    1717    float value;
    1818public :
    19         Point() : size(1.0f) {}
     19        Point() : size(1.0f), value(0.0f) {}
    2020};
    2121
     
    125125public :
    126126        ClusterAccel* doIt(Point* data, int count);
     127    void setMinDistance(const float minDistance);
     128    void setMaxLevel(int maxLevel);
    127129
    128130private :       
     
    139141};     
    140142
     143inline void PCASplit::setMinDistance(const float minDistance)
     144{
     145    _minDistance = minDistance;
     146}
     147
     148inline void PCASplit::setMaxLevel(int maxLevel)
     149{
     150    _maxLevel = maxLevel;
     151}
     152
    141153};
    142154
  • trunk/vizservers/nanovis/PointSet.cpp

    r825 r827  
    22#include "PCASplit.h"
    33#include <stdlib.h>
     4#include <stdio.h>
    45
    56PointSet::PointSet()
    6 : _visible(false), _cluster(0), _sortLevel(4)
     7: _visible(false), _cluster(0), _sortLevel(4), _min(0.0f), _max(1.0f)
    78{
    89}
     
    1617}
    1718
    18 void PointSet::initialize(Vector4* values, const unsigned int count)
     19void PointSet::initialize(Vector4* values, const unsigned int count, const Vector3& scale, const Vector3& origin, float min, float max)
    1920{
    2021    PCA::PCASplit pcaSplit;
     22
     23    _scale = scale;
     24    _origin = origin;
     25    _min = min;
     26    _max = max;
    2127
    2228    PCA::Point* points = (PCA::Point*) malloc(sizeof(PCA::Point) * count);
     
    2430    {
    2531        points[i].position.set(values[i].x, values[i].y, values[i].z);
    26 
    27         // TBD
    2832        points[i].color.set(1.0f, 1.0f, 1.0f, 0.2f);
    29 
    3033        points[i].value = values[i].w;
     34        points[i].size = 0.001;
    3135    }
    3236
     
    3539        delete _cluster;
    3640    }
    37 
    3841   
     42    pcaSplit.setMinDistance(scale.length() / 3.0f);
    3943    _cluster = pcaSplit.doIt(points, count);
    4044}
    4145
    42 void PointSet::updateColor()
     46void PointSet::updateColor(float* color,  int colorCount)
    4347{
    44    
     48        if (_cluster == 0) return;
     49
     50    int level = 4;
     51
     52        PCA::Cluster* cluster = _cluster->startPointerCluster[level - 1];
     53        PCA::Cluster* c = &(cluster[0]);
     54        PCA::Cluster* end = &(cluster[_cluster->numOfClusters[level - 1] - 1]);
     55
     56        Vector3 pos;
     57       
     58    PCA::Point* points;
     59    Vector4* colors = (Vector4*) color;
     60        int numOfPoints;
     61    int index;
     62    float d = _max - _min;
     63        for (; c <= end; c = (PCA::Cluster*) ((int) c + sizeof(PCA::Cluster)))
     64        {
     65        points = c->points;
     66        numOfPoints = c->numOfPoints;
     67
     68        for (int i = 0; i < numOfPoints; ++i)
     69        {
     70            index = (points[i].value - _min) / d  * (colorCount - 1);
     71            if (index >= colorCount) index = colorCount - 1;
     72            //printf("TEST %f %d/%d -> %d (%f %f %f)\n", points[i].value, i, numOfPoints, index,
     73            //                                    colors[index].x, colors[index].y, colors[index].z);
     74            //fflush(stdout);
     75            points[i].color = colors[index];
     76        }
     77
     78        }
    4579}
    4680
  • trunk/vizservers/nanovis/PointSet.h

    r825 r827  
    44#include <PCASplit.h>
    55#include <Vector4.h>
     6#include <Vector3.h>
    67
    78class PointSet {
    89    unsigned int _sortLevel;
     10    PCA::ClusterAccel* _cluster;
     11
     12    Vector3 _scale;
     13    Vector3 _origin;
     14    float _max;
     15    float _min;
    916    bool _visible;
    10     PCA::ClusterAccel* _cluster;
    1117public :
    1218    PointSet();
     
    1420
    1521public :
    16     void initialize(Vector4* values, const unsigned int count);
     22    void initialize(Vector4* values, const unsigned int count, const Vector3& scale, const Vector3& origin, float min, float max);
    1723    bool isVisible() const;
    1824    void setVisible(bool visible);
    1925    unsigned int getSortLevel()const;
    2026    PCA::ClusterAccel* getCluster();
    21     void updateColor();
     27    void updateColor(float* color, int  count);
     28    const Vector3& getScale() const;
     29    Vector3& getScale();
     30    const Vector3& getOrigin() const;
     31    Vector3& getOrigin();
    2232};
    2333
     
    4252}
    4353
     54inline Vector3& PointSet::getScale()
     55{
     56    return _scale;
     57}
     58
     59inline const Vector3& PointSet::getScale() const
     60{
     61    return _scale;
     62}
     63
     64inline Vector3& PointSet::getOrigin()
     65{
     66    return _origin;
     67}
     68
     69inline const Vector3& PointSet::getOrigin() const
     70{
     71    return _origin;
     72}
    4473
    4574#endif //
  • trunk/vizservers/nanovis/PointSetRenderer.cpp

    r825 r827  
    88#include <stdio.h>
    99#include <R2/R2FilePath.h>
     10
     11#define USE_TEXTURE
     12//#define USE_SHADER
     13#define POINT_SIZE 5
    1014
    1115PointSetRenderer::PointSetRenderer()
     
    2226    ImageLoader* loader = ImageLoaderFactory::getInstance()->createLoader("bmp");
    2327    Image* image = loader->load(path, Image::IMG_RGBA);
     28
     29    unsigned char* bytes = (unsigned char*) image->getImageBuffer();
     30    if (bytes)
     31    {
     32        for (int y = 0; y < image->getHeight(); ++y)
     33           for (int x = 0; x < image->getWidth(); ++x, bytes +=4)
     34           {
     35                bytes[3] =  (bytes[0] == 0)? 0 : 255;
     36           }
     37    }
    2438
    2539    if (image)
     
    5468    float quadratic[] = { 1.0f, 0.0f, 0.01f };
    5569
    56 
     70    glEnable(GL_POINT_SPRITE_ARB);
    5771    glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic);
    5872    glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f);
    5973    glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f);
    6074    glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, 100);
     75#ifdef USE_TEXTURE
    6176    glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
     77#endif
    6278
    6379    glEnable(GL_POINT_SPRITE_ARB);
     
    7490            if (!setSize)
    7591            {
     92#ifdef USE_SHADER
    7693                _shader->setScale(p->data->points[0].size);
     94#endif
    7795                setSize = true;
    7896            }
     
    91109
    92110    glDisable(GL_POINT_SPRITE_ARB);
     111    glPointSize(1);
    93112
    94113}
    95114
    96 void PointSetRenderer::render(PCA::ClusterAccel* cluster, const Mat4x4& mat, int sortLevel)
     115void PointSetRenderer::render(PCA::ClusterAccel* cluster, const Mat4x4& mat, int sortLevel, const Vector3& scale, const Vector3& origin)
    97116{
    98117    _bucketSort->init();
    99118    _bucketSort->sort(cluster, mat, sortLevel);
    100119
     120    glDisable(GL_TEXTURE_2D);
     121
     122#ifdef USE_TEXTURE
    101123    _pointTexture->activate();
     124    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
     125#endif
     126
     127    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     128    //glBlendFunc(GL_SRC_ALPHA, GL_ONE);
     129    glEnable(GL_BLEND);
     130
     131    glDisable(GL_LIGHTING);
     132    glEnable(GL_COLOR_MATERIAL);
     133
     134    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
     135    glPushMatrix();
     136    float s = 1.0f / scale.x;
     137    Vector3 shift(origin.x + scale.x * 0.5, origin.x + scale.x * 0.5, origin.x + scale.x * 0.5);
     138    glScalef(s, scale.y / scale.x * s, scale.z / scale.x * s);
     139
     140    //glTranslatef(-shift.x, -shift.y, -shift.z);
     141   
     142#ifdef USE_SHADER
    102143    _shader->bind();
    103     glPushMatrix();
    104         glTranslatef(-0.5f, -0.5f, -0.5f);
     144#else
     145    glPointSize(POINT_SIZE);
     146#endif
    105147        renderCluster(_bucketSort->getBucket(), _bucketSort->getSize(), 4);
     148#ifdef USE_SHADER
     149    _shader->unbind();
     150#else
     151    glPointSize(1.0f);
     152#endif
     153   
    106154    glPopMatrix();
    107155
    108     _shader->unbind();
     156    glDisable(GL_COLOR_MATERIAL);
     157    glEnable(GL_LIGHTING);
     158    glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
     159    glDisable(GL_BLEND);
     160
     161#ifdef USE_TEXTURE
     162    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    109163    _pointTexture->deactivate();
     164#endif
    110165}
    111166
  • trunk/vizservers/nanovis/PointSetRenderer.h

    r825 r827  
    2121
    2222public :
    23     void render(PCA::ClusterAccel* cluster, const Mat4x4& mat, int sortLevel);
     23    void render(PCA::ClusterAccel* cluster, const Mat4x4& mat, int sortLevel, const Vector3& scale, const Vector3& origin);
    2424};
    2525
  • trunk/vizservers/nanovis/nanovis.cpp

    r825 r827  
    2828#include <signal.h>
    2929
     30
    3031#include "Nv.h"
    3132#include "PointSetRenderer.h"
    3233#include "PointSet.h"
     34#include "Util.h"
    3335
    3436#include "nanovis.h"
     
    5456
    5557//#define  _LOCAL_ZINC_TEST_
     58//
     59// FOR testing new functions
     60//#include "Test.h"
    5661
    5762// R2 headers
     
    918923                }
    919924            }
    920 /*
     925#ifdef __TEST_CODE__
    921926            else if (!strcmp(header, "<FET>"))
    922927            {
     
    925930                std::stringstream fdata;
    926931                fdata.write(buf.bytes(),buf.size());
    927                 //err = load_volume_stream3(n, fdata);
     932                err = load_volume_stream3(n, fdata);
    928933
    929934                if (err) {
     
    932937                }
    933938            }
    934 */
     939#endif
    935940            else
    936941            {
     
    14561461        "\": should be data, outline, shading, or state", (char*)NULL);
    14571462    return TCL_ERROR;
    1458 }
    1459 
    1460 int TestCmd _ANSI_ARGS_((ClientData cdata, Tcl_Interp *interp, int argc, CONST84 char *argv[]))
    1461 {
    1462     std::ifstream fin;
    1463     fin.open("/home/nanohub/vrinside/nv/data/fet/graph-finfet.txt", std::ios::binary);
    1464                 //std::stringstream fdata(std::ios_base::out|std::ios_base::in|std::ios_base::binary);
    1465 
    1466     if (!fin)
    1467     {
    1468         printf("file not found\n");
    1469         return TCL_OK;
    1470     }
    1471 
    1472     float temp1, temp2, temp3;
    1473     float vmin, vmax;
    1474     int count;
    1475     char* start;
    1476 
    1477     char line[128];
    1478     char temp[24];
    1479     float dx, dy, dz;
    1480     float x0, y0, z0;
    1481     do {
    1482         fin.getline(line,sizeof(line)-1);
    1483 
    1484         // skip leading blanks
    1485         for (start=&line[0]; *start == ' ' || *start == '\t'; start++);
    1486 
    1487         if (*start != '#')
    1488         { 
    1489             sscanf(start, "%s%f%f%f", temp, &temp1, &temp2, &temp3);
    1490             if (!strcmp(temp, "size"))
    1491             {
    1492                 dx = temp1;
    1493                 dy = temp2;
    1494                 dz = temp3;
    1495             }
    1496             else if (!strcmp(temp, "size"))
    1497             {
    1498                 x0 = temp1;
    1499                 y0 = temp2;
    1500                 z0 = temp3;
    1501             }
    1502             else if (!strcmp(temp, "minmax"))
    1503             {
    1504                 vmin = temp1;
    1505                 vmax = temp2;
    1506             }
    1507             else if (!strcmp(temp, "count"))
    1508             {
    1509                 count = temp1;
    1510             }
    1511             else if (!strcmp(temp, "</FET>"))
    1512             {
    1513                 break;
    1514             }
    1515         }
    1516     } while (!fin.eof());
    1517 
    1518     printf("data count %d \n", count);
    1519     fflush(stdout);
    1520 
    1521     Vector4* data = new Vector4[count];
    1522     memset(data, 0, sizeof(Vector4) * count);
    1523     float min = 1e21, max = 1e-21;
    1524     for (int i = 0; i < count; ++i)
    1525     {
    1526         fin.getline(line,sizeof(line)-1);
    1527         sscanf(line, "%f%f%f%f", &data[i].x, &data[i].y, &data[i].z, &data[i].w);
    1528 
    1529         if (data[i].w < min) min = data[i].w;
    1530         if (data[i].w > max) max = data[i].w;
    1531     }
    1532 
    1533     float d = max - min;
    1534     for (int i = 0; i < count; ++i)
    1535     {
    1536         data[i].w = (data[i].w - min) / d;
    1537     }
    1538 
    1539     PointSet* newPointSet = new PointSet();
    1540     newPointSet->initialize(data, count);
    1541     newPointSet->setVisible(true);
    1542     g_pointSet.push_back(newPointSet);
    1543    
    1544     return TCL_OK;
    15451463}
    15461464
     
    27242642}
    27252643
    2726 Rappture::Outcome
    2727 load_volume_stream3(int index, std::iostream& fin)
    2728 {
    2729     Rappture::Outcome result;
    2730 
    2731     Rappture::MeshTri2D xymesh;
    2732     int dummy, nx, ny, nz, nxy, npts;
    2733     double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
    2734     char line[128], type[128], *start;
    2735 
    2736     int isrect = 1;
    2737 
    2738     float temp1, temp2, temp3;
    2739     float vmin, vmax;
    2740     int count;
    2741 
    2742     char temp[24];
    2743     do {
    2744         fin.getline(line,sizeof(line)-1);
    2745 
    2746         // skip leading blanks
    2747         for (start=&line[0]; *start == ' ' || *start == '\t'; start++);
    2748 
    2749         if (*start != '#')
    2750         { 
    2751             sscanf(start, "%s%f%f%f", temp, &temp1, &temp2, &temp3);
    2752             if (!strcmp(temp, "size"))
    2753             {
    2754                 dx = temp1;
    2755                 dy = temp2;
    2756                 dz = temp3;
    2757             }
    2758             else if (!strcmp(temp, "size"))
    2759             {
    2760                 x0 = temp1;
    2761                 y0 = temp2;
    2762                 z0 = temp3;
    2763             }
    2764             else if (!strcmp(temp, "minmax"))
    2765             {
    2766                 vmin = temp1;
    2767                 vmax = temp2;
    2768             }
    2769             else if (!strcmp(temp, "count"))
    2770             {
    2771                 count = temp1;
    2772             }
    2773             else if (!strcmp(temp, "<FET>"))
    2774             {
    2775                 break;
    2776             }
    2777         }
    2778     } while (!fin.eof());
    2779 
    2780     // read data points
    2781     if (!fin.eof()) {
    2782         if (isrect) {
    2783             Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
    2784             Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
    2785             Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
    2786             Rappture::FieldRect3D field(xgrid, ygrid, zgrid);
    2787 
    2788             double dval[6];
    2789             int nread = 0;
    2790             int ix = 0;
    2791             int iy = 0;
    2792             int iz = 0;
    2793             while (!fin.eof() && nread < npts) {
    2794                 fin.getline(line,sizeof(line)-1);
    2795                 int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
    2796 
    2797                 for (int p=0; p < n; p++) {
    2798                     int nindex = iz*nx*ny + iy*nx + ix;
    2799                     field.define(nindex, dval[p]);
    2800                     nread++;
    2801                     if (++iz >= nz) {
    2802                         iz = 0;
    2803                         if (++iy >= ny) {
    2804                             iy = 0;
    2805                             ++ix;
    2806                         }
    2807                     }
    2808                 }
    2809             }
    2810 
    2811             // make sure that we read all of the expected points
    2812             if (nread != nx*ny*nz) {
    2813                 char mesg[256];
    2814                 sprintf(mesg,"inconsistent data: expected %d points but found %d points", nx*ny*nz, nread);
    2815                 result.error(mesg);
    2816                 return result;
    2817             }
    2818 
    2819             // figure out a good mesh spacing
    2820             int nsample = 30;
    2821             dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
    2822             dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
    2823             dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
    2824             double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
    2825 
    2826             nx = (int)ceil(dx/dmin);
    2827             ny = (int)ceil(dy/dmin);
    2828             nz = (int)ceil(dz/dmin);
    2829 
    2830 #ifndef NV40
    2831             // must be an even power of 2 for older cards
    2832                 nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    2833                 ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    2834                 nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    2835 #endif
    2836 
    2837             float *data = new float[4*nx*ny*nz];
    2838 
    2839             double vmin = field.valueMin();
    2840             double dv = field.valueMax() - field.valueMin();
    2841             if (dv == 0.0) { dv = 1.0; }
    2842 
    2843             // generate the uniformly sampled data that we need for a volume
    2844             int ngen = 0;
    2845             double nzero_min = 0.0;
    2846             for (int iz=0; iz < nz; iz++) {
    2847                 double zval = z0 + iz*dmin;
    2848                 for (int iy=0; iy < ny; iy++) {
    2849                     double yval = y0 + iy*dmin;
    2850                     for (int ix=0; ix < nx; ix++) {
    2851                         double xval = x0 + ix*dmin;
    2852                         double v = field.value(xval,yval,zval);
    2853 
    2854                         if (v != 0.0f && v < nzero_min)
    2855                         {
    2856                             nzero_min = v;
    2857                         }
    2858 
    2859                         // scale all values [0-1], -1 => out of bounds
    2860                         v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
    2861 
    2862                         data[ngen] = v;
    2863                         ngen += 4;
    2864                     }
    2865                 }
    2866             }
    2867 
    2868             // Compute the gradient of this data.  BE CAREFUL: center
    2869             // calculation on each node to avoid skew in either direction.
    2870             ngen = 0;
    2871             for (int iz=0; iz < nz; iz++) {
    2872                 for (int iy=0; iy < ny; iy++) {
    2873                     for (int ix=0; ix < nx; ix++) {
    2874                         // gradient in x-direction
    2875                         double valm1 = (ix == 0) ? 0.0 : data[ngen-4];
    2876                         double valp1 = (ix == nx-1) ? 0.0 : data[ngen+4];
    2877                         if (valm1 < 0 || valp1 < 0) {
    2878                             data[ngen+1] = 0.0;
    2879                         } else {
    2880                             data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
    2881                         }
    2882 
    2883                         // gradient in y-direction
    2884                         valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
    2885                         valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
    2886                         if (valm1 < 0 || valp1 < 0) {
    2887                             data[ngen+2] = 0.0;
    2888                         } else {
    2889                             //data[ngen+2] = valp1-valm1; // assume dy=1
    2890                             data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
    2891                         }
    2892 
    2893                         // gradient in z-direction
    2894                         valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
    2895                         valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
    2896                         if (valm1 < 0 || valp1 < 0) {
    2897                             data[ngen+3] = 0.0;
    2898                         } else {
    2899                             //data[ngen+3] = valp1-valm1; // assume dz=1
    2900                             data[ngen+3] = ((valp1-valm1) + 1) *  0.5; // assume dz=1
    2901                         }
    2902 
    2903                         ngen += 4;
    2904                     }
    2905                 }
    2906             }
    2907 
    2908             load_volume(index, nx, ny, nz, 4, data,
    2909                 field.valueMin(), field.valueMax(), nzero_min);
    2910 
    2911             delete [] data;
    2912 
    2913         } else {
    2914             Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
    2915             Rappture::FieldPrism3D field(xymesh, zgrid);
    2916 
    2917             double dval;
    2918             int nread = 0;
    2919             int ixy = 0;
    2920             int iz = 0;
    2921             while (!fin.eof() && nread < npts) {
    2922                 if (!(fin >> dval).fail()) {
    2923                     int nid = nxy*iz + ixy;
    2924                     field.define(nid, dval);
    2925 
    2926                     nread++;
    2927                     if (++iz >= nz) {
    2928                         iz = 0;
    2929                         ixy++;
    2930                     }
    2931                 }
    2932             }
    2933 
    2934             // make sure that we read all of the expected points
    2935             if (nread != nxy*nz) {
    2936                 char mesg[256];
    2937                 sprintf(mesg,"inconsistent data: expected %d points but found %d points", nxy*nz, nread);
    2938                 return result.error(mesg);
    2939             }
    2940 
    2941             // figure out a good mesh spacing
    2942             int nsample = 30;
    2943             x0 = field.rangeMin(Rappture::xaxis);
    2944             dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
    2945             y0 = field.rangeMin(Rappture::yaxis);
    2946             dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
    2947             z0 = field.rangeMin(Rappture::zaxis);
    2948             dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
    2949             double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
    2950 
    2951             nx = (int)ceil(dx/dmin);
    2952             ny = (int)ceil(dy/dmin);
    2953             nz = (int)ceil(dz/dmin);
    2954 #ifndef NV40
    2955             // must be an even power of 2 for older cards
    2956                 nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    2957                 ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    2958                 nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    2959 #endif
    2960             float *data = new float[4*nx*ny*nz];
    2961 
    2962             double vmin = field.valueMin();
    2963             double dv = field.valueMax() - field.valueMin();
    2964             if (dv == 0.0) { dv = 1.0; }
    2965 
    2966             // generate the uniformly sampled data that we need for a volume
    2967             int ngen = 0;
    2968             double nzero_min = 0.0;
    2969             for (iz=0; iz < nz; iz++) {
    2970                 double zval = z0 + iz*dmin;
    2971                 for (int iy=0; iy < ny; iy++) {
    2972                     double yval = y0 + iy*dmin;
    2973                     for (int ix=0; ix < nx; ix++) {
    2974                         double xval = x0 + ix*dmin;
    2975                         double v = field.value(xval,yval,zval);
    2976 
    2977                         if (v != 0.0f && v < nzero_min)
    2978                         {
    2979                             nzero_min = v;
    2980                         }
    2981                         // scale all values [0-1], -1 => out of bounds
    2982                         v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
    2983                         data[ngen] = v;
    2984 
    2985                         ngen += 4;
    2986                     }
    2987                 }
    2988             }
    2989 
    2990             // Compute the gradient of this data.  BE CAREFUL: center
    2991             // calculation on each node to avoid skew in either direction.
    2992             ngen = 0;
    2993             for (int iz=0; iz < nz; iz++) {
    2994                 for (int iy=0; iy < ny; iy++) {
    2995                     for (int ix=0; ix < nx; ix++) {
    2996                         // gradient in x-direction
    2997                         double valm1 = (ix == 0) ? 0.0 : data[ngen-1];
    2998                         double valp1 = (ix == nx-1) ? 0.0 : data[ngen+1];
    2999                         if (valm1 < 0 || valp1 < 0) {
    3000                             data[ngen+1] = 0.0;
    3001                         } else {
    3002                             //data[ngen+1] = valp1-valm1; // assume dx=1
    3003                             data[ngen+1] = ((valp1-valm1) + 1) *  0.5; // assume dx=1
    3004                         }
    3005 
    3006                         // gradient in y-direction
    3007                         valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
    3008                         valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
    3009                         if (valm1 < 0 || valp1 < 0) {
    3010                             data[ngen+2] = 0.0;
    3011                         } else {
    3012                             //data[ngen+2] = valp1-valm1; // assume dy=1
    3013                             data[ngen+2] = ((valp1-valm1) + 1) *  0.5; // assume dy=1
    3014                         }
    3015 
    3016                         // gradient in z-direction
    3017                         valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
    3018                         valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
    3019                         if (valm1 < 0 || valp1 < 0) {
    3020                             data[ngen+3] = 0.0;
    3021                         } else {
    3022                             //data[ngen+3] = valp1-valm1; // assume dz=1
    3023                             data[ngen+3] = ((valp1-valm1) + 1) *  0.5; // assume dz=1
    3024                         }
    3025 
    3026                         ngen += 4;
    3027                     }
    3028                 }
    3029             }
    3030 
    3031             load_volume(index, nx, ny, nz, 4, data,
    3032                 field.valueMin(), field.valueMax(), nzero_min);
    3033 
    3034             delete [] data;
    3035         }
    3036     } else {
    3037         return result.error("data not found in stream");
    3038     }
    3039 
    3040     //
    3041     // Center this new volume on the origin.
    3042     //
    3043     float dx0 = -0.5;
    3044     float dy0 = -0.5*dy/dx;
    3045     float dz0 = -0.5*dz/dx;
    3046     volume[index]->move(Vector3(dx0, dy0, dz0));
    3047 
    3048     return result;
    3049 }
    3050 
    30512644/* Load a 3D volume
    30522645 * index: the index into the volume array, which stores pointers to 3D volume instances
     
    30962689
    30972690  float data[256*4];
    3098   for(int i=0; i<256; i++){
     2691  for(int i=0; i<256; i++)
     2692  {
    30992693    data[4*i+0] = color_table[i][0];
    31002694    data[4*i+1] = color_table[i][1];
     
    33982992        (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
    33992993
     2994#ifdef __TEST_CODE__
    34002995    Tcl_CreateCommand(interp, "test", TestCmd,
    34012996        (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
     2997#endif
    34022998
    34032999    // create a default transfer function
     
    39883584
    39893585void draw_3d_axis()
    3990 {
     3586{ 
    39913587    glDisable(GL_TEXTURE_2D);
    39923588    glEnable(GL_DEPTH_TEST);
     
    39973593       
    39983594        glDepthFunc(GL_LESS);
     3595    glEnable(GL_COLOR_MATERIAL);
    39993596        glEnable(GL_DEPTH_TEST);
    40003597        glDisable(GL_BLEND);
     
    40303627        glEnable(GL_LIGHT0);
    40313628
    4032         glColor3f(0.2, 0.2, 0.8);
     3629        //glColor3f(0.2, 0.2, 0.8);
    40333630        glPushMatrix();
    40343631        glutSolidSphere(0.02, segments, segments );
     
    41993796            if (g_pointSet[i]->isVisible())
    42003797            {
    4201                 g_pointset_renderer->render(g_pointSet[i]->getCluster(), mat, g_pointSet[i]->getSortLevel());
     3798                g_pointset_renderer->render(g_pointSet[i]->getCluster(), mat, g_pointSet[i]->getSortLevel(),
     3799                                            g_pointSet[i]->getScale(),
     3800                                            g_pointSet[i]->getOrigin());
    42023801            }
    42033802        }
  • trunk/vizservers/nanovis/shaders/pointsvp.cg

    r821 r827  
    2828       
    2929       
    30         float tmp = posin.w * rsqrt(dot(eye.xyz, eye.xyz));
    31         psize = scale.x * max(tmp, 1.0);
     30//      float tmp = posin.w * rsqrt(dot(eye.xyz, eye.xyz));
     31//      psize = scale.x * max(tmp, 1.0);
    3232        psize = 10 * p.w / -p.z;
    3333       
Note: See TracChangeset for help on using the changeset viewer.