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; } }