void
SoXipImageOverlayManager::loadOverlays()
{
// When the patient changes
clearClipboard();
// Remove all the geometries from the switch
mShapeSwitch->removeAllChildren();
mShapeSwitch->whichChild.setValue(-1);
mCurrentSlice = -1;
if( mImageData )
{
SbString overlayStr = mImageData->getProperty( "overlays" );
SoNodeList nodes = XipOverlayUtils::loadOverlaysFromString( overlayStr.getString(), overlayStr.getLength(), TRUE );
for( int i = 0; i < nodes.getLength(); ++ i )
{
if( !nodes[i]->isOfType( SoXipShapeList::getClassTypeId() ) )
{
SoDebugError::post( __FILE__, "Invalid overlay node found in Dicom. Ignored." );
continue ;
}
mShapeSwitch->addChild( nodes[i] );
}
}
updateSliceMap();
}
SbBool
SoXipOverlayTransformBoxManip::computeSelectionXBoundingBox( SoGLRenderAction* action )
{
mXBoundingBox.makeEmpty();
const SoFullPath* path = (SoFullPath *) action->getCurPath();
SoNode* searchRoot = path->getNodeFromTail( numNodesUpToContainer.getValue() );
SoNodeList shapes = XipOverlayUtils::getManipulableShapes( searchRoot, TRUE );
int numShapes = shapes.getLength();
// Don't display if the shape the transformBox is applied to is filtered
if ( (numShapes == 1) &&
!SoXipOverlayFilterElement::isOn( action->getState(), ((SoXipManipulableShape *)shapes[0])->label ) )
{
return mXBoundingBox.isEmpty();
}
for( int i = 0; i < numShapes; ++ i )
{
SoXipManipulableShape* shape = (SoXipManipulableShape *) shapes[i];
SbXfBox3f newbox;
shape->computeXBoundingBox( newbox );
mXBoundingBox.extendBy( newbox );
}
return !mXBoundingBox.isEmpty();
}
void
ModList::refresh(bool fetchFlag)
{
for (int i = 0; i < _list.size(); i++)
_list[i]->refresh(fetchFlag);
for (int n=elementalNodeList.getLength()-1; n >= 0; n--) {
elementalNodeList[n]->doAction(_viewer->getGLRenderAction());
}
}
SoSeparator * Renderer::getOrAddSeparator(SoSeparator * ivRoot, SbName & childName)
{
SoNodeList children = getChildByName(ivRoot, childName);
if(children.getLength())
return static_cast<SoSeparator *>(children[0]);
else
{
SoSeparator * newChild = new SoSeparator();
newChild->setName(childName);
ivRoot->addChild(newChild);
return newChild;
}
}
void
SoXipImageOverlayManager::updateOverlays( SoAction* action )
{
if( imageChanged( action ) )
{
this->saveOverlays();
if( mImageData )
{
mImageData->unref();
mImageData = 0;
}
SoXipDataImage* eltData = SoXipDataImageElement::get( action->getState() );
// Reset the current slice to force the update
mCurrentSlice = -1;
if( eltData )
{
// Get reference image
SoXipDataImage* refData = 0;
SoXipDataImage* eltData = SoXipDataImageElement::get( action->getState() );
while( (refData = (SoXipDataImage *) eltData->getRefByType( SoXipDataImage::getClassTypeId() )) )
eltData = refData;
mImageData = eltData;
mImageData->ref();
// retrieve ROI overlay from Dicom
this->loadOverlays();
}
}
int sliceIndex = SoXipDataImageElement::getSliceIndex( action->getState() );
if( sliceIndex != mCurrentSlice )
{
// When switching to a different slice, unselect all the shapes that were
// previously selected.
SoNodeList selection = XipOverlayUtils::getTopLevelShapes( mShapeSwitch, TRUE );
for( int i = 0; i < selection.getLength(); ++ i )
((SoXipShape *) selection[i])->select( FALSE );
mSelection.truncate(0);
SoXipShapeList* sliceShapeList = mSliceMap[ sliceIndex ];
if( sliceShapeList )
{
mShapeSwitch->whichChild.setValue( mShapeSwitch->findChild( sliceShapeList ) );
}
else
{
sliceShapeList = new SoXipShapeList;
sliceShapeList->label.setValue( SbString( sliceIndex ) );
mShapeSwitch->addChild( sliceShapeList );
mShapeSwitch->whichChild.setValue( mShapeSwitch->getNumChildren() - 1 );
mSliceMap[ sliceIndex ] = sliceShapeList;
}
mCurrentSlice = sliceIndex;
}
}
static float
timeRendering(Options &options,
const SbViewportRegion &vpr,
SoSeparator *&root)
//
//////////////////////////////////////////////////////////////
{
SbTime timeDiff, startTime;
int frameIndex;
SoTransform *sceneTransform;
SoGLRenderAction ra(vpr);
SoNodeList noCacheList;
SoSeparator *newRoot;
// clear the window
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
// reset autocaching threshold before each experiment
// done by replacing every separator in the scene graph
// with a new one
//
newRoot = (SoSeparator *) replaceSeparators(root);
newRoot->ref();
newRoot->renderCaching = SoSeparator::OFF;
// get a list of separators marked as being touched by the application
newRoot->getByName(NO_CACHE_NAME, noCacheList);
// find the transform node that spins the scene
SoNodeList xformList;
newRoot->getByName(SCENE_XFORM_NAME, xformList);
sceneTransform = (SoTransform *) xformList[0];
if (options.noMaterials) { // nuke material node
removeNodes(newRoot, SoMaterial::getClassTypeId());
removeNodes(newRoot, SoPackedColor::getClassTypeId());
removeNodes(newRoot, SoBaseColor::getClassTypeId());
}
if (options.noXforms) { // nuke transforms
removeNodes(newRoot, SoTransformation::getClassTypeId());
}
if (options.noTextures || options.oneTexture) { // override texture node
removeNodes(newRoot, SoTexture2::getClassTypeId());
if (options.oneTexture) {
// texture node with simple texture
static unsigned char img[] = {
255, 255, 0, 0,
255, 255, 0, 0,
0, 0, 255, 255,
0, 0, 255, 255
};
SoTexture2 *overrideTex = new SoTexture2;
overrideTex->image.setValue(SbVec2s(4, 4), 1, img);
newRoot->insertChild(overrideTex, 1);
}
}
if (options.noFill) { // draw as points
SoDrawStyle *overrideFill = new SoDrawStyle;
overrideFill->style.setValue(SoDrawStyle::POINTS);
overrideFill->lineWidth.setIgnored(TRUE);
overrideFill->linePattern.setIgnored(TRUE);
overrideFill->setOverride(TRUE);
newRoot->insertChild(overrideFill, 0);
// cull backfaces so that extra points don't get drawn
SoShapeHints *cullBackfaces = new SoShapeHints;
cullBackfaces->shapeType = SoShapeHints::SOLID;
cullBackfaces->vertexOrdering = SoShapeHints::COUNTERCLOCKWISE;
cullBackfaces->setOverride(TRUE);
newRoot->insertChild(cullBackfaces, 0);
}
if (options.noVtxXforms) { // draw invisible
SoDrawStyle *overrideVtxXforms = new SoDrawStyle;
overrideVtxXforms->style.setValue(SoDrawStyle::INVISIBLE);
overrideVtxXforms->setOverride(TRUE);
newRoot->insertChild(overrideVtxXforms, 0);
}
if (options.noLights) { // set lighting model to base color
SoLightModel *baseColor = new SoLightModel;
baseColor->model = SoLightModel::BASE_COLOR;
newRoot->insertChild(baseColor, 0);
}
for (frameIndex = 0; ; frameIndex++) {
// wait till autocaching has kicked in then start timing
if (frameIndex == NUM_FRAMES_AUTO_CACHING)
startTime = SbTime::getTimeOfDay();
// stop timing and exit loop when requisite number of
// frames have been drawn
if (frameIndex == options.numFrames + NUM_FRAMES_AUTO_CACHING) {
glFinish();
timeDiff = SbTime::getTimeOfDay() - startTime;
break;
}
// if not frozen, update realTime and destroy labelled caches
if (! options.freeze) {
// update realTime
SoSFTime *realTime = (SoSFTime *) SoDB::getGlobalField("realTime");
realTime->setValue(SbTime::getTimeOfDay());
// touch the separators marked NoCache
for (int i=0; i<noCacheList.getLength(); i++)
((SoSeparator *) noCacheList[i])->getChild(0)->touch();
}
// Rotate the scene
sceneTransform->rotation.setValue(SbVec3f(1, 1, 1),
frameIndex * 2 * M_PI / options.numFrames);
if (! options.noClear)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
ra.apply(newRoot);
}
// Get rid of newRoot
newRoot->unref();
return (timeDiff.getValue() / options.numFrames);
}
