source: trunk/packages/vizservers/nanovis/dxReader2.cpp @ 1049

#include "RpDX.h"
#include "dxReaderCommon.h"

#include <stdio.h>
#include <iostream>
#include <fstream>

// nanovis headers
#include "Nv.h"
#include "nanovis.h"

// rappture headers
#include "RpEncode.h"

/* Load a 3D volume from a dx-format file the new way
 */
Rappture::Outcome
load_volume_stream_odx(int index, const char *buf, int nBytes)
{
    Rappture::Outcome outcome;

    char dxfilename[128];

    if (nBytes == 0) {
        return outcome.error("data not found in stream");
    }

    // write the dx file to disk, because DXImportDX takes a file name
    // george suggested using a pipe here

    // You can do it like this.  Give 
    sprintf(dxfilename, "/tmp/dx%d.dx", getpid());

    FILE *f;

    f = fopen(dxfilename, "w");
    fwrite(buf, sizeof(char), nBytes, f);
    fclose(f);

    Rappture::DX dxObj(dxfilename, &outcome);

    if (remove(dxfilename) != 0) {
        fprintf(stderr, "Error deleting dx file: %s\n", dxfilename);
        fflush(stderr);
    }

    int nx = dxObj.axisLen()[0];
    int ny = dxObj.axisLen()[1];
    int nz = dxObj.axisLen()[2];
    float dx = nx;
    float dy = ny;
    float dz = nz;

    const float* data1 = dxObj.data();
    float *data = new float[nx*ny*nz*4];
    memset(data, 0, nx*ny*nz*4);
    int iz=0, ix=0, iy=0;
    float dv = dxObj.dataMax() - dxObj.dataMin();
    float vmin = dxObj.dataMin();

    for (int i=0; i < nx*ny*nz; i++) {
        int nindex = (iz*nx*ny + iy*nx + ix) * 4;
        float v = data1[i];

        // scale all values [0-1], -1 => out of bounds
        v = (isnan(v)) ? -1.0 : (v - vmin)/dv;

        // place the value in the correct index in cdata
        data[nindex] = v;

        // calculate next x,y,z coordinate
        if (++iz >= nz) {
            iz = 0;
            if (++iy >= ny) {
                iy = 0;
                ++ix;
            }
        }
    }

    computeSimpleGradient(data, nx, ny, nz);

    fprintf(stdout,"End Data Stats index = %i\n",index);
    fprintf(stdout,"nx = %i ny = %i nz = %i\n",nx,ny,nz);
    fprintf(stdout,"dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
    fprintf(stdout,"dataMin = %lg\tdataMax = %lg\tnzero_min = %lg\n", dxObj.dataMin(),dxObj.dataMax(),dxObj.nzero_min());
    fflush(stdout);

    Volume *volPtr;
    volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data,
                                  dxObj.dataMin(), dxObj.dataMax(), dxObj.nzero_min());
    const float *origin = dxObj.origin();
    const float *max = dxObj.max();

    volPtr->xAxis.SetRange(origin[0], max[0]);
    volPtr->yAxis.SetRange(origin[1], max[1]);
    volPtr->zAxis.SetRange(origin[2], max[2]);
    volPtr->wAxis.SetRange(dxObj.dataMin(), dxObj.dataMax());
    volPtr->update_pending = true;

    delete [] data; 

    //
    // Center this new volume on the origin.
    //
    float dx0 = -0.5;
    float dy0 = -0.5*dy/dx;
    float dz0 = -0.5*dz/dx;
    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));

    return outcome;
}