void
SoXipComposeVec6::evaluate()
{
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, setNum(6));
// intersection of plane and volume
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(0, xmin.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(1, xmax.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(2, ymin.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(3, ymax.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(4, zmin.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(5, zmax.getValue()) );
// Reset outputs
SO_ENGINE_OUTPUT( numSlices, SoSFShort, setValue(0) );
SO_ENGINE_OUTPUT( output, SoXipSFDataImage, setValue(0) );
SoXipDataImage* imageData = image.getValue();
if( mImageData != imageData )
{
mImageData = image.getValue();
// Reset previous outputs
mOutputs.setNum(0);
if( mImageData )
{
SbXipImage* image = mImageData->get();
if( !image )
return ;
// Initialize outputs
unsigned int numSlices = image->getDimStored()[2];
mOutputs.setNum( numSlices );
for( unsigned int i = 0; i < numSlices; ++ i )
mOutputs.set1Value( i, 0 );
}
}
if( imageData )
{
SbXipImage* image = mImageData->get();
if( !image )
return ;
SbXipImageDimensions dimensions = image->getDimStored();
SbXipImageDimensions sliceDimensions = dimensions;
sliceDimensions[2] = 1;
int sliceIndex = this->sliceIndex.getValue();
if( sliceIndex < 0 || sliceIndex >= dimensions[2] )
return ;
if( mOutputs[sliceIndex] == 0 )
{
// Compute the model matrix of the selected frame
SbMatrix sliceModelMatrix = image->getModelMatrix();
sliceModelMatrix[2][0] /= dimensions[2];
sliceModelMatrix[2][1] /= dimensions[2];
sliceModelMatrix[2][2] /= dimensions[2];
sliceModelMatrix[3][0] += sliceIndex * sliceModelMatrix[2][0];
sliceModelMatrix[3][1] += sliceIndex * sliceModelMatrix[2][1];
sliceModelMatrix[3][2] += sliceIndex * sliceModelMatrix[2][2];
// Pointer to the selected slice
char* imagePtr = (char *) image->refBufferPtr();
unsigned int cellSize;
switch( image->getType() )
{
case SbXipImage::UNSIGNED_BYTE: cellSize = sizeof(unsigned char); break ;
case SbXipImage::BYTE: cellSize = sizeof(char); break ;
case SbXipImage::UNSIGNED_SHORT: cellSize = sizeof(unsigned short); break ;
case SbXipImage::SHORT: cellSize = sizeof(short); break ;
case SbXipImage::UNSIGNED_INT: cellSize = sizeof(unsigned int); break ;
case SbXipImage::INT: cellSize = sizeof(int); break ;
case SbXipImage::FLOAT: cellSize = sizeof(float); break ;
case SbXipImage::DOUBLE: cellSize = sizeof(double); break ;
}
void* slicePtr = imagePtr + cellSize * image->getComponents() * dimensions[0] * dimensions[1] * sliceIndex;
SbXipImage* slice = new SbXipImage( sliceDimensions, image->getType(), image->getBitsStored(), slicePtr,
image->getComponents(), image->getComponentType(), image->getComponentLayoutType(), sliceModelMatrix,
image->getLineAlignment() );
image->unrefBufferPtr();
SoXipDataImage* output = new SoXipDataImage();
output->ref();
output->set( slice );
output->addRef( imageData );
mOutputs.set1Value( sliceIndex, output );
}
SO_ENGINE_OUTPUT( output, SoXipSFDataImage, setValue(mOutputs[sliceIndex]) );
}
}
void SoXipCPUMprRender::readyBuffers(SoState *state)
{
SbXipImageDimensions dim(0, 0, 0);
SoXipDataImage *imgData = 0;
SbXipImage *image = 0;
// Volume
imgData = volume.getValue();
dim = SbXipImageDimensions(0,0,0);
if (imgData && (image = imgData->get()))
{
// If data has changed, update MPR
if (imgData->getDataId() != mVolDataId)
{
mVolDataId = imgData->getDataId();
mUpdateFlag |= UPDATE_MPR;
}
if (mVolDataType != image->getType() || mVolBitsUsed != image->getBitsStored())
{
mVolDataType = image->getType();
mVolBitsUsed = image->getBitsStored();
mMPRSize = SbVec2s(-1, -1); // force buffer resizing
}
mVolBuf = image->refBufferPtr();
dim = imgData->get()->getDimAllocated();
// If dimensions have changed, update Cache
if (dim != mVolDim)
{
mVolDim = dim;
mUpdateFlag |= UPDATE_MPRCACHE;
}
}
else
{
mVolBuf = 0;
mVolDim = dim;
mVolDataId = 0;
}
// Transfer function LUT
imgData = (SoXipDataImage *) SoXipLutElement::get(state);
if (imgData && (image = imgData->get()) &&
image->getType() == SbXipImage::FLOAT &&
image->getComponentLayoutType() == SbXipImage::RGBA)
{
// If there was no LUT before, resize buffers
if (!mLutBuf)
mMPRSize = SbVec2s(-1, -1);
mLutSize = image->getDimStored()[0];
mLutBuf = (float*) image->refBufferPtr();
// If data has changed, update MPR
if (imgData->getDataId() != mLutDataId)
{
mLutDataId = imgData->getDataId();
mUpdateFlag |= UPDATE_MPR;
}
}
else
{
// If there was a LUT before, force resizing
if (mLutBuf)
mMPRSize = SbVec2s(-1, -1);
mLutBuf = 0;
mLutSize = 0;
mLutDataId = 0;
}
}