ImageTestData ImageTestData::initializeSecondaryData(vtkImageDataPtr source, QString filename)
{
ImageTestData retval;
QString colorFormat = "R";
if (source->GetNumberOfScalarComponents() == 3)
{
vtkSmartPointer < vtkImageLuminance > luminance = vtkSmartPointer < vtkImageLuminance > ::New();
luminance->SetInputData(source);
luminance->Update();
vtkImageDataPtr outData = luminance->GetOutput();
retval.mImageData = outData;
colorFormat = "R";
}
else if (source->GetNumberOfScalarComponents() == 4)
{
retval.mImageData = source;
colorFormat = "RGBA";
}
else if (source->GetNumberOfScalarComponents() == 1)
{
retval.mImageData = source;
colorFormat = "R";
}
retval.mRawUid = QString("uchar %1[%2]").arg(QFileInfo(filename).completeBaseName()).arg(colorFormat);
retval.mDataSource.reset(new SplitFramesContainer(retval.mImageData));
retval.mCurrentFrame = 0;
return retval;
}
void checkImagesEqual(vtkImageDataPtr input1, vtkImageDataPtr input2)
{
REQUIRE(input1.Get()!=(vtkImageData*)NULL);
REQUIRE(input2.Get()!=(vtkImageData*)NULL);
REQUIRE(input1->GetDataDimension() == input2->GetDataDimension());
REQUIRE(input1->GetScalarType() == input2->GetScalarType());
REQUIRE(input1->GetNumberOfScalarComponents() == input2->GetNumberOfScalarComponents());
REQUIRE(Eigen::Array3i(input1->GetDimensions()).isApprox(Eigen::Array3i(input2->GetDimensions())));
CHECK(Eigen::Array3d(input1->GetSpacing()).isApprox(Eigen::Array3d(input2->GetSpacing()), 1.0E-2));
CHECK(Eigen::Array3d(input1->GetOrigin()).isApprox(Eigen::Array3d(input2->GetOrigin())));
// check spacing, dim, type, origin
vtkImageMathematicsPtr diff = vtkImageMathematicsPtr::New();
diff->SetOperationToSubtract();
diff->SetInput1Data(input1);
diff->SetInput2Data(input2);
diff->Update();
vtkImageAccumulatePtr histogram = vtkImageAccumulatePtr::New();
histogram->SetInputData(0, diff->GetOutput());
histogram->Update();
Eigen::Array3d histogramRange = Eigen::Array3d(histogram->GetMax()) - Eigen::Array3d(histogram->GetMin());
for (int i=0; i<input1->GetNumberOfScalarComponents(); ++i)
{
CHECK(histogramRange[i] < 0.01);
CHECK(histogramRange[i] > -0.01);
}
}
vtkImageDataPtr IGTLinkConversionSonixCXLegacy::createFilterAny2RGB(int R, int G, int B, vtkImageDataPtr input)
{
if (input->GetNumberOfScalarComponents() == 1)
return input;
if (( input->GetNumberOfScalarComponents()==3 )&&( R==0 )&&( G==1 )&&( B==2 ))
return input;
vtkImageAppendComponentsPtr merger = vtkImageAppendComponentsPtr::New();
vtkImageExtractComponentsPtr splitterRGB = vtkImageExtractComponentsPtr::New();
splitterRGB->SetInputData(input);
splitterRGB->SetComponents(R, G, B);
merger->AddInputConnection(splitterRGB->GetOutputPort());
merger->Update();
return merger->GetOutput();
}
ImageTestData ImageTestData::initializePrimaryData(vtkImageDataPtr source, QString filename)
{
ImageTestData retval;
QString colorFormat = "R";
if (source->GetNumberOfScalarComponents() == 3)
{
vtkImageAppendComponentsPtr merger = vtkImageAppendComponentsPtr::New();
vtkImageExtractComponentsPtr splitterRGB = vtkImageExtractComponentsPtr::New();
splitterRGB->SetInputData(source);
splitterRGB->SetComponents(0, 1, 2);
// merger->AddInputConnection(0, splitterRGB->GetOutputPort());
merger->AddInputConnection(splitterRGB->GetOutputPort());
vtkImageExtractComponentsPtr splitterA = vtkImageExtractComponentsPtr::New();
splitterA->SetInputData(source);
splitterA->SetComponents(0);
merger->AddInputConnection(splitterA->GetOutputPort());
// merger->AddInputConnection(1, splitterA->GetOutputPort());
merger->Update();
retval.mImageData = merger->GetOutput();
colorFormat = "RGBA";
}
else if (source->GetNumberOfScalarComponents() == 4)
{
retval.mImageData = source;
colorFormat = "RGBA";
}
else if (source->GetNumberOfScalarComponents() == 1)
{
retval.mImageData = source;
colorFormat = "R";
}
retval.mRawUid = QString("%1 [%2]").arg(QFileInfo(filename).completeBaseName()).arg(colorFormat);
retval.mDataSource.reset(new SplitFramesContainer(retval.mImageData));
retval.mCurrentFrame = 0;
return retval;
}
/**Convert input to grayscale, and return a COPY of that volume ( in order to break the pipeline for memory purposes)
* ALSO: remove data in image outside extent - required by reconstruction.
* Convert to 8 bit as current US reconstruction algorithms only handles 8 bit
*/
vtkImageDataPtr USFrameData::to8bitGrayscaleAndEffectuateCropping(vtkImageDataPtr input) const
{
vtkImageDataPtr grayScaleData;
if (input->GetNumberOfScalarComponents() == 1) // already gray
{
// crop (slow)
grayScaleData = input;
// outData->Crop();
}
else
{
// convert and crop as side effect (optimization)
grayScaleData = convertImageDataToGrayScale(input);
}
vtkImageDataPtr outData = this->convertTo8bit(grayScaleData);
vtkImageDataPtr copy = vtkImageDataPtr::New();
copy->DeepCopy(outData);
return copy;
}
virtual void updateTexture()
{
if (mMTime == mTexture->GetMTime())
{
return;
}
mMTime = mTexture->GetMTime();
//vtkgl::ActiveTexture(getGLTextureForVolume(textureUnitIndex)); //TODO is this OK?
GLenum size,internalType;
boost::uint32_t dimx = mTexture ->GetDimensions( )[0];
boost::uint32_t dimy = mTexture ->GetDimensions( )[1];
boost::uint32_t dimz = mTexture ->GetDimensions( )[2];
mMemorySize = dimx * dimy * dimz;
glEnable( GL_TEXTURE_3D );
glBindTexture(GL_TEXTURE_3D, textureId);
report_gl_error();
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
switch (mTexture->GetScalarType())
{
case VTK_UNSIGNED_CHAR:
{
size = GL_UNSIGNED_BYTE;
internalType = GL_LUMINANCE;
}
break; //8UI_EXT; break;
case VTK_UNSIGNED_SHORT:
{
size = GL_UNSIGNED_SHORT;
internalType = GL_LUMINANCE16;
mMemorySize *= 2;
}
break; //16UI_EXT; break;
default:
size = 0;
internalType = 0;
std::cout << "Bit size not supported!" << std::endl;
QString dataType(mTexture->GetScalarTypeAsString());
CX_LOG_ERROR() << QString("Attempt to update 3D GL texture from type %1 failed. Only unsigned types supported").arg(dataType);
break;
}
if (mTexture->GetNumberOfScalarComponents()==1)
{
void* data = mTexture->GetPointData()->GetScalars()->GetVoidPointer(0);
glTexImage3D(GL_TEXTURE_3D, 0, internalType, dimx, dimy, dimz, 0, GL_LUMINANCE, size, data);
}
else if (mTexture->GetNumberOfScalarComponents()==3)
{
internalType = GL_RGB;
void* data = mTexture->GetPointData()->GetScalars()->GetVoidPointer(0);
glTexImage3D(GL_TEXTURE_3D, 0, internalType, dimx, dimy, dimz, 0, GL_RGB, size, data);
mMemorySize *= 3;
}
else
{
std::cout << "unsupported number of image components" << std::endl;
}
glDisable(GL_TEXTURE_3D);
report_gl_error();
}
vtkImageDataPtr USFrameData::useAngio(vtkImageDataPtr inData, vtkImageDataPtr grayFrame, int frameNum) const
{
// Some of the code here is borrowed from the vtk examples:
// http://public.kitware.com/cgi-bin/viewcvs.cgi/*checkout*/Examples/Build/vtkMy/Imaging/vtkImageFoo.cxx?root=VTK&content-type=text/plain
if (inData->GetNumberOfScalarComponents() != 3)
{
if(frameNum == 0) //Only report warning once
reportWarning("Angio requested for grayscale ultrasound");
return grayFrame;
}
vtkImageDataPtr outData = vtkImageDataPtr::New();
outData->DeepCopy(grayFrame);
// outData->Update(); // updates whole extent.
// printStuff("Clipped color in", inData);
// printStuff("Grayscale in", outData);
// int* inExt = inData->GetWholeExtent();
int* outExt = outData->GetExtent();
// Remember that the input might (and do due to vtkImageClip) contain leaps.
// This means that the wholeextent might be larger than the extent, thus
// we must use a startoffset and leaps between lines.
unsigned char *inPtr = static_cast<unsigned char*> (inData->GetScalarPointerForExtent(inData->GetExtent()));
unsigned char *outPtr = static_cast<unsigned char*> (outData->GetScalarPointerForExtent(outData->GetExtent()));
int maxX = outExt[1] - outExt[0];
int maxY = outExt[3] - outExt[2];
int maxZ = outExt[5] - outExt[4];
Eigen::Array<vtkIdType,3,1> inInc;
inData->GetContinuousIncrements(inData->GetExtent(), inInc[0], inInc[1], inInc[2]);
CX_ASSERT(inInc[0]==0);
// we assume (wholeextent == extent) for the outData in the algorithm below. assert here.
Eigen::Array<vtkIdType,3,1> outInc;
outData->GetContinuousIncrements(outData->GetExtent(), outInc[0], outInc[1], outInc[2]);
CX_ASSERT(outInc[0]==0);
CX_ASSERT(outInc[1]==0);
CX_ASSERT(outInc[2]==0);
for (int z=0; z<=maxZ; z++)
{
for (int y=0; y<=maxY; y++)
{
for (int x=0; x<=maxX; x++)
{
//Look at 3 scalar components at the same time (RGB),
//if color is grayscale or close to grayscale: set to zero.
if (((*inPtr) == (*(inPtr + 1))) && ((*inPtr) == (*(inPtr + 2))))
{
(*outPtr) = 0;
}
else
{
// strong check: look for near-gray values and remove them.
double r = inPtr[0];
double g = inPtr[1];
double b = inPtr[2];
int metric = (fabs(r-g) + fabs(r-b) + fabs(g-b)) / 3; // average absolute diff must be less than or equal to this
// std::cout << QString(" %1,%2,%3 \t %4, %5 -- %6").arg(int(inPtr[0])).arg(int(inPtr[1])).arg(int(inPtr[2])).arg(idxR).arg(idxY).arg(metric) << std::endl;
if (metric <= 3)
(*outPtr) = 0;
}
//Assume the outVolume is treated with the luminance filter first
outPtr++;
inPtr += 3;
}
inPtr += inInc[1];
}
inPtr += inInc[2];
}
return outData;
}