bool
avtVolumeRenderer::GetScalars(vtkDataSet *ds, vtkDataArray *&d, vtkDataArray *&o)
{
return VolumeGetScalars(atts, ds, d, o);
}
void
avtVolumeRenderer::Render(vtkDataSet *ds)
{
StackTimer t("avtVolumeRenderer::Render");
if (!currentRendererIsValid || !rendererImplementation)
{
delete rendererImplementation;
if (atts.GetRendererType() == VolumeAttributes::Splatting)
{
debug5 << "Creating a Splatting renderer." << std::endl;
rendererImplementation = new avtOpenGLSplattingVolumeRenderer;
}
#ifdef HAVE_LIBSLIVR
else if(atts.GetRendererType() == VolumeAttributes::SLIVR)
{
debug5 << "Creating a SLIVR renderer." << std::endl;
rendererImplementation = new avtOpenGLSLIVRVolumeRenderer;
}
#endif
#ifdef USE_TUVOK
else if(atts.GetRendererType() == VolumeAttributes::Tuvok)
{
debug5 << "Creating a Tuvok renderer." << std::endl;
rendererImplementation = new avtOpenGLTuvokVolumeRenderer;
}
#endif
else // it == VolumeAttributes::Texture3D
{
debug5 << "Creating a 3DTexture renderer." << std::endl;
rendererImplementation = new avtOpenGL3DTextureVolumeRenderer;
}
currentRendererIsValid = true;
}
if (!initialized)
{
Initialize(ds);
}
vtkDataArray *data = NULL;
vtkDataArray *opac = NULL;
bool haveScalars = VolumeGetScalars(atts, ds, data, opac);
if (haveScalars)
{
int *sz = VTKRen->GetRenderWindow()->GetSize();
avtVolumeRendererImplementation::RenderProperties props;
double bg[3];
VTKRen->GetBackground(bg);
props.backgroundColor[0] = bg[0];
props.backgroundColor[1] = bg[1];
props.backgroundColor[2] = bg[2];
props.windowSize[0] = sz[0];
props.windowSize[1] = sz[1];
props.view = view;
props.atts = atts;
props.reducedDetail = reducedDetail;
avtVolumeRendererImplementation::VolumeData vd;
vd.grid = ds;
vd.data.data = data;
vd.data.min = vmin;
vd.data.max = vmax;
vd.data.size = vsize;
vd.opacity.data = opac;
vd.opacity.min = omin;
vd.opacity.max = omax;
vd.opacity.size = osize;
vd.gx = gx;
vd.gy = gy;
vd.gz = gz;
vd.gm = gm;
vd.gmn = gmn;
vd.gm_max = gm_max;
vd.hs_min = hs_min;
vd.hs = hs;
StackTimer t2("Implementation Render");
rendererImplementation->Render(props, vd);
vd.data.data->Delete();
vd.opacity.data->Delete();
}
}
void
avtVolumeRenderer::Initialize(vtkDataSet *ds)
{
StackTimer t("avtVolumeRenderer::Initialize");
vtkDataArray *data = 0, *opac = 0;
if(!VolumeGetScalars(atts, ds, data, opac))
return;
VolumeGetVariableExtents(atts, data,
this->varmin, this->varmax,
this->vmin, this->vmax, this->vsize);
// Get the opacity variable's extents.
VolumeGetOpacityExtents(atts, opac,
this->omin, this->omax, this->osize);
// calculate gradient
if (ds->GetDataObjectType() == VTK_RECTILINEAR_GRID)
{
if (atts.GetLightingFlag() && gm == NULL) // make sure the gradient was invalidated first
{
vtkRectilinearGrid *grid = (vtkRectilinearGrid*)ds;
int dims[3];
grid->GetDimensions(dims);
int nels = dims[0] * dims[1] * dims[2];
gx = new float[nels];
gy = new float[nels];
gz = new float[nels];
gm = new float[nels];
gmn = new float[nels];
hs = NULL;
float ghostval = omax+osize;
gm_max = VolumeCalculateGradient(atts, grid, opac, gx, gy, gz, gm, gmn, ghostval);
}
}
else
{
// If we have a lighting+no gradient then calculate the gradient.
// Also do it if we have a default compact variable name since setting
// the hs variable happens in that case and its generation is tied to
// gradient calculation.
if(gm == NULL)
{
int nels = ds->GetNumberOfPoints();
gx = new float[nels];
gy = new float[nels];
gz = new float[nels];
gm = new float[nels];
gmn = new float[nels];
hs = new float[nels];
float ghostval = omax+osize;
bool calcHS = atts.GetCompactVariable() == "default";
if(!calcHS)
{
vtkDataArray *compactSupport =
VolumeGetScalar(ds, atts.GetCompactVariable().c_str());
if (compactSupport != NULL)
{ //assign h values
for (int i = 0; i<nels; i++)
hs[i] = fabs(compactSupport->GetTuple1(i));
}
else
calcHS = true;
}
gm_max = VolumeCalculateGradient_SPH(ds, opac,
gx, gy, gz, gm, gmn, hs, calcHS, ghostval);
//Set the extents for the compact support variables;
hs_size = nels;
hs_min = hs[0]; hs_max = hs[0];
for (int i = 0; i < nels; i++)
{
if ( hs[i] < hs_min )
hs_min = hs[i];
if ( hs[i] > hs_max )
hs_max = hs[i];
}
}
}
data->Delete();
opac->Delete();
initialized = true;
}
void
avtLowerResolutionVolumeFilter::CalculateHistograms(vtkDataSet *ds)
{
const char *mName = "avtLowerResolutionVolumeFilter::CalculateHistograms: ";
vtkDataArray *data = 0, *opac = 0;
if(VolumeGetScalars(atts, ds, data, opac))
{
debug5 << mName << "Computing histograms" << endl;
int nels = data->GetNumberOfTuples();
// Get the opacity variable's extents.
float omin = 0.f, omax = 0.f, osize = 0.f;
VolumeGetOpacityExtents(atts, opac, omin, omax, osize);
float ghostval = omax+osize;
//
// In this mode, we calculate "gm" so we can do the histogram and then
// we throw away "gm". It's not that big a deal anymore because the
// gradient calculation is much faster than it used to be.
//
vtkFloatArray *gm = vtkFloatArray::New();
gm->SetNumberOfTuples(nels);
gm->SetName("gm");
if(ds->GetDataObjectType() == VTK_RECTILINEAR_GRID)
{
VolumeCalculateGradient(atts, (vtkRectilinearGrid *)ds, opac,
0, // gx
0, // gy
0, // gz
(float *)gm->GetVoidPointer(0),
0, // gmn
ghostval);
}
else
{
// Since SPH gradient is slow, only calculate it when we have a
// 2D transfer function since that's the only time we need it for
// histogram calculation.
if(atts.GetTransferFunctionDim() == 1)
{
memset(gm->GetVoidPointer(0), 0, sizeof(float)*nels);
}
else
{
VolumeCalculateGradient_SPH(ds, opac,
0, // gx
0, // gy
0, // gz
(float *)gm->GetVoidPointer(0),
0, // gmn
0, // hs
true,
ghostval);
}
}
if(hist2 != 0)
delete [] hist2;
hist2 = new float[hist_size * hist_size];
if(hist == 0)
delete [] hist;
hist = new float[hist_size];
VolumeHistograms(atts, data, gm, hist, hist2, hist_size);
gm->Delete();
data->Delete();
opac->Delete();
}
else
{
debug5 << mName << "Could not get scalars or opacity needed to "
"calculate the histogram"
<< endl;
}
}
