void VolumeRaycaster::interactionModeToggled() {
VolumeRenderer::interactionModeToggled();
// make sure, we re-render with full resolution after switching out of interaction mode
if (!interactionMode())
invalidate();
}
void DepthDarkening::process() {
privatePort_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (!interactionMode())
analyzeDepthBuffer(&inport_);
// since the blurring is implemented as a separable filter,
// two rendering passes are needed
// first horizontal pass
TextureUnit colorUnit, depthUnit0, depthUnit1;
inport_.bindTextures(colorUnit.getEnum(), depthUnit0.getEnum());
inport_.bindDepthTexture(depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
program_->setUniform("sigma_", sigma_.get());
program_->setUniform("lambda_", lambda_.get());
program_->setUniform("minDepth_", minDepth_.get());
program_->setUniform("maxDepth_", maxDepth_.get());
program_->setUniform("dir_", tgt::vec2(1.0,0.0));
renderQuad();
program_->deactivate();
LGL_ERROR;
// second vertical pass
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
inport_.bindColorTexture(colorUnit.getEnum());
privatePort_.bindDepthTexture(depthUnit0.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
program_->setUniform("sigma_", sigma_.get());
program_->setUniform("lambda_", lambda_.get());
program_->setUniform("minDepth_", minDepth_.get());
program_->setUniform("maxDepth_", maxDepth_.get());
program_->setUniform("dir_", tgt::vec2(0.0,1.0));
renderQuad();
program_->deactivate();
outport_.deactivateTarget();
LGL_ERROR;
}
float VolumeRaycaster::getSamplingStepSize(const VolumeBase* vol) {
tgt::ivec3 dim = vol->getDimensions();
// use dimension with the highest resolution for calculating the sampling step size
float samplingStepSize = 1.f / (tgt::max(dim) * samplingRate_.get());
if (interactionMode())
samplingStepSize /= interactionQuality_.get();
return samplingStepSize;
}
/**
* Performs the raycasting.
*
* Initialize two texture units with the entry and exit params and renders
* a screen aligned quad.
*/
void IDRaycaster::process() {
if (!volumePort_.isReady())
return;
if(getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
idMapPort_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// don't render when in interaction mode
if (interactionMode()) {
idMapPort_.deactivateTarget();
TextureUnit::setZeroUnit();
return;
}
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit, firstHitPointUnit;
// bind entry params
entryPort_.bindTextures(entryUnit.getEnum(), entryDepthUnit.getEnum());
// bind first hit points
firstHitpointsPort_.bindColorTexture(firstHitPointUnit.getEnum());
// bind exit params
exitPort_.bindTextures(exitUnit.getEnum(), exitDepthUnit.getEnum());
// vector containing the volumes to bind
std::vector<VolumeStruct> volumes;
TextureUnit volUnit;
volumes.push_back(VolumeStruct(
volumePort_.getData(),
&volUnit,
"segmentation_","segmentationParameters_",
GL_CLAMP_TO_EDGE,
tgt::vec4(0.f),
GL_NEAREST)
);
// initialize shader
raycastPrg_->activate();
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(raycastPrg_, &cam);
bindVolumes(raycastPrg_, volumes, &cam, lightPosition_.get());
raycastPrg_->setUniform("entryPoints_", entryUnit.getUnitNumber());
raycastPrg_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "entryParameters_");
raycastPrg_->setUniform("firstHitPoints_", firstHitPointUnit.getUnitNumber());
firstHitpointsPort_.setTextureParameters(raycastPrg_, "firstHitParameters_");
raycastPrg_->setUniform("exitPoints_", exitUnit.getUnitNumber());
raycastPrg_->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "exitParameters_");
raycastPrg_->setUniform("penetrationDepth_", penetrationDepth_.get());
renderQuad();
raycastPrg_->deactivate();
idMapPort_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void Processor::interactionModeToggled() {
if (interactionMode())
LDEBUG(getID() << " interactionModeSwitched on");
else
LDEBUG(getID() << " interactionModeSwitched off");
}
void MultiVolumeRaycaster::process() {
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
// bind transfer function
TextureUnit transferUnit1, transferUnit2, transferUnit3, transferUnit4;
transferUnit1.activate();
if (transferFunc1_.get())
transferFunc1_.get()->bind();
transferUnit2.activate();
if (transferFunc2_.get())
transferFunc2_.get()->bind();
transferUnit3.activate();
if (transferFunc3_.get())
transferFunc3_.get()->bind();
transferUnit4.activate();
if (transferFunc4_.get())
transferFunc4_.get()->bind();
portGroup_.activateTargets();
portGroup_.clearTargets();
LGL_ERROR;
transferFunc1_.setVolumeHandle(volumeInport1_.getData());
transferFunc2_.setVolumeHandle(volumeInport2_.getData());
transferFunc3_.setVolumeHandle(volumeInport3_.getData());
transferFunc4_.setVolumeHandle(volumeInport4_.getData());
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
// bind entry params
entryPort_.bindTextures(entryUnit.getEnum(), entryDepthUnit.getEnum());
LGL_ERROR;
// bind exit params
exitPort_.bindTextures(exitUnit.getEnum(), exitDepthUnit.getEnum());
LGL_ERROR;
// vector containing the volumes to bind; is passed to bindVolumes()
std::vector<VolumeStruct> volumeTextures;
std::vector<const VolumeHandleBase*> volumeHandles;
// bind volumes
TextureUnit volUnit1, volUnit2, volUnit3, volUnit4;
if (volumeInport1_.isReady()) {
volumeInport1_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport1_.getData(),
&volUnit1,
"volumeStruct1_",
texClampMode1_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode1_.getValue())
);
volumeHandles.push_back(volumeInport1_.getData());
}
if (volumeInport2_.isReady()) {
volumeInport2_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport2_.getData(),
&volUnit2,
"volumeStruct2_",
texClampMode2_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode2_.getValue())
);
volumeHandles.push_back(volumeInport2_.getData());
}
if (volumeInport3_.isReady()) {
volumeInport3_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport3_.getData(),
&volUnit3,
"volumeStruct3_",
texClampMode3_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode3_.getValue())
);
volumeHandles.push_back(volumeInport3_.getData());
}
if (volumeInport4_.isReady()) {
volumeInport4_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport4_.getData(),
&volUnit4,
"volumeStruct4_",
texClampMode4_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode4_.getValue())
);
volumeHandles.push_back(volumeInport4_.getData());
}
// initialize shader
raycastPrg_->activate();
// set common uniforms used by all shaders
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(raycastPrg_, &cam);
// bind the volumes and pass the necessary information to the shader
bindVolumes(raycastPrg_, volumeTextures, &cam, lightPosition_.get());
// pass the remaining uniforms to the shader
raycastPrg_->setUniform("entryPoints_", entryUnit.getUnitNumber());
raycastPrg_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "entryParameters_");
raycastPrg_->setUniform("exitPoints_", exitUnit.getUnitNumber());
raycastPrg_->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
exitPort_.setTextureParameters(raycastPrg_, "exitParameters_");
if (compositingMode_.get() == "iso" ||
compositingMode1_.get() == "iso" ||
compositingMode2_.get() == "iso")
raycastPrg_->setUniform("isoValue_", isoValue_.get());
if(volumeInport1_.isReady())
transferFunc1_.get()->setUniform(raycastPrg_, "transferFunc_", transferUnit1.getUnitNumber());
if(volumeInport2_.isReady())
transferFunc2_.get()->setUniform(raycastPrg_, "transferFunc2_", transferUnit2.getUnitNumber());
if(volumeInport3_.isReady())
transferFunc3_.get()->setUniform(raycastPrg_, "transferFunc3_", transferUnit3.getUnitNumber());
if(volumeInport4_.isReady())
transferFunc4_.get()->setUniform(raycastPrg_, "transferFunc4_", transferUnit4.getUnitNumber());
// determine ray step length in world coords
if (volumeTextures.size() > 0) {
float voxelSizeWorld = 999.f;
float voxelSizeTexture = 999.f;
for(size_t i=0; i<volumeHandles.size(); ++i) {
const VolumeHandleBase* volume = volumeHandles[i];
tgtAssert(volume, "No volume");
tgt::ivec3 volDim = volume->getDimensions();
tgt::vec3 cubeSizeWorld = volume->getCubeSize() * volume->getPhysicalToWorldMatrix().getScalingPart();
float tVoxelSizeWorld = tgt::max(cubeSizeWorld / tgt::vec3(volDim));
if (tVoxelSizeWorld < voxelSizeWorld) {
voxelSizeWorld = tVoxelSizeWorld;
voxelSizeTexture = tgt::max(1.f / tgt::vec3(volDim));
}
}
float samplingStepSizeWorld = voxelSizeWorld / samplingRate_.get();
float samplingStepSizeTexture = voxelSizeTexture / samplingRate_.get();
if (interactionMode()) {
samplingStepSizeWorld /= interactionQuality_.get();
samplingStepSizeTexture /= interactionQuality_.get();
}
raycastPrg_->setUniform("samplingStepSize_", samplingStepSizeWorld);
if (compositingMode_.isSelected("dvr") ||
(compositingMode1_.isSelected("dvr") && outport1_.isConnected()) ||
(compositingMode2_.isSelected("dvr") && outport2_.isConnected()) ) {
// adapts the compositing of the multivolume RC to the one of the singlevolume RC (see below).
raycastPrg_->setUniform("mvOpacityCorrectionFactor_", samplingStepSizeTexture / samplingStepSizeWorld);
}
LGL_ERROR;
}
LGL_ERROR;
renderQuad();
raycastPrg_->deactivate();
portGroup_.deactivateTargets();
if (outport_.isConnected())
outport_.validateResult();
if (outport1_.isConnected())
outport1_.validateResult();
if (outport2_.isConnected())
outport2_.validateResult();
glActiveTexture(GL_TEXTURE0);
LGL_ERROR;
}
