typename AstroStickModel< ScalarType >::PixelType AstroStickModel< ScalarType >::SimulateMeasurement()
{
PixelType signal;
signal.SetSize(this->m_GradientList.size());
double b = -m_BValue*m_Diffusivity;
if (m_RandomizeSticks)
m_NumSticks = 30 + m_RandGen->GetIntegerVariate()%31;
for( unsigned int i=0; i<this->m_GradientList.size(); i++)
{
GradientType g = this->m_GradientList[i];
double bVal = g.GetNorm(); bVal *= bVal;
if (bVal>0.0001)
{
for (int j=0; j<m_NumSticks; j++)
{
double dot = 0;
if(m_RandomizeSticks)
dot = GetRandomDirection()*g;
else
dot = m_Sticks[j]*g;
signal[i] += exp( b*bVal*dot*dot );
}
signal[i] /= m_NumSticks;
}
else
signal[i] = 1;
}
return signal;
}
typename TensorModel< ScalarType >::PixelType TensorModel< ScalarType >::SimulateMeasurement()
{
PixelType signal;
signal.SetSize(this->m_GradientList.size());
signal.Fill(0.0);
ItkTensorType tensor;
tensor.Fill(0.0);
this->m_FiberDirection.Normalize();
vnl_vector_fixed<double, 3> axis = itk::CrossProduct(m_KernelDirection, this->m_FiberDirection).GetVnlVector();
axis.normalize();
vnl_quaternion<double> rotation(axis, acos(m_KernelDirection*this->m_FiberDirection));
rotation.normalize();
vnl_matrix_fixed<double, 3, 3> matrix = rotation.rotation_matrix_transpose();
vnl_matrix_fixed<double, 3, 3> tensorMatrix = matrix.transpose()*m_KernelTensorMatrix*matrix;
tensor[0] = tensorMatrix[0][0];
tensor[1] = tensorMatrix[0][1];
tensor[2] = tensorMatrix[0][2];
tensor[3] = tensorMatrix[1][1];
tensor[4] = tensorMatrix[1][2];
tensor[5] = tensorMatrix[2][2];
for( unsigned int i=0; i<this->m_GradientList.size(); i++)
{
GradientType g = this->m_GradientList[i];
ScalarType bVal = g.GetNorm();
bVal *= bVal;
if (bVal>0.0001)
{
itk::DiffusionTensor3D< ScalarType > S;
S[0] = g[0]*g[0];
S[1] = g[1]*g[0];
S[2] = g[2]*g[0];
S[3] = g[1]*g[1];
S[4] = g[2]*g[1];
S[5] = g[2]*g[2];
ScalarType D = tensor[0]*S[0] + tensor[1]*S[1] + tensor[2]*S[2] +
tensor[1]*S[1] + tensor[3]*S[3] + tensor[4]*S[4] +
tensor[2]*S[2] + tensor[4]*S[4] + tensor[5]*S[5];
// check for corrupted tensor and generate signal
if (D>=0)
signal[i] = exp ( -m_BValue * bVal * D );
}
else
signal[i] = 1;
}
return signal;
}
double Image3D::GetMaximumNorm()
{
ImageVectorType::RegionType region = image_->GetLargestPossibleRegion();
itk::ImageRegionConstIterator<ImageVectorType> imageIterator(image_,region);
PixelType pixelGradient;
double max = 0.0, courant;
while(!imageIterator.IsAtEnd())
{
pixelGradient = imageIterator.Get();
courant = pixelGradient.GetNorm();
if (courant > max) max = courant;
++imageIterator;
}
return max;
}
typename BallModel< ScalarType >::PixelType BallModel< ScalarType >::SimulateMeasurement()
{
PixelType signal;
signal.SetSize(this->m_GradientList.size());
for( unsigned int i=0; i<this->m_GradientList.size(); i++)
{
GradientType g = this->m_GradientList[i];
if (g.GetNorm()>0.0001)
signal[i] = exp( -m_BValue * m_Diffusivity );
else
signal[i] = 1;
}
return signal;
}
bool writePixel(const PixelType& _pixel)
{
_UByteCV* ptr;
if (!ImageRowAccessor::accessPixel(ptr, 4))
return false;
return _pixel.pack(ptr[0], ptr[1], ptr[2], ptr[3]);
}
bool readPixel(PixelType& _pixel)
{
_UByteCV* ptr;
if (!ImageRowAccessor::accessPixel(ptr, 4))
return false;
return _pixel.unpack(ptr[0], ptr[1], ptr[2], ptr[3]);
}
void Image3D::DeleteHighVector()
{
double threshold = GetMaximumNorm()/3;
ImageVectorType::RegionType region = image_->GetLargestPossibleRegion();
itk::ImageRegionConstIterator<ImageVectorType> imageIterator(image_,region);
PixelType pixelGradient;
IndexType indexGradient;
while(!imageIterator.IsAtEnd())
{
indexGradient = imageIterator.GetIndex();
pixelGradient = imageIterator.Get();
if (pixelGradient.GetNorm() > threshold) {
pixelGradient[0] = 0.0; pixelGradient[1] = 0.0; pixelGradient[2] = 0.0;
image_->SetPixel(indexGradient,pixelGradient);
}
++imageIterator;
}
}
typename StickModel< ScalarType >::PixelType StickModel< ScalarType >::SimulateMeasurement(GradientType &fiberDirection)
{
PixelType signal;
signal.SetSize(this->m_GradientList.size());
for( unsigned int i=0; i<this->m_GradientList.size(); i++)
{
GradientType g = this->m_GradientList[i];
if (g.GetNorm()>0.0001)
{
ScalarType dot = fiberDirection*g;
signal[i] = std::exp( -this->m_BValue*m_Diffusivity*dot*dot ); // skip * bVal becaus bVal is already encoded in the dot product (norm of g encodes b-value relative to baseline b-value m_BValue)
}
else
signal[i] = 1;
}
return signal;
}
bool readPixel(PixelType& _pixel)
{
_UByteCV* ptr;
if (m_readParity)
{
if (!ImageRowAccessor::accessPixel(ptr, 4, 2)) // 4 bytes, 2 pixels
return false;
m_readParity = false;
return _pixel.unpack(ptr[2], ptr[1], ptr[3]);
}
else
{
if (!ImageRowAccessor::accessPixelDontMove(ptr, 4, 2)) // 4 bytes, 2 pixels
return false;
m_readParity = true;
return _pixel.unpack(ptr[0], ptr[1], ptr[3]);
}
}
bool writePixel(const PixelType& _pixel)
{
_UByteCV* ptr;
if (m_writeParity)
{
if (!ImageRowAccessor::accessPixel(ptr, 4, 2)) // 4 bytes, 2 pixels
return false;
m_writeParity = false;
return _pixel.pack(ptr[2], ptr[1], ptr[3], true);
}
else
{
if (!ImageRowAccessor::accessPixelDontMove(ptr, 4, 2)) // 4 bytes, 2 pixels
return false;
m_writeParity = true;
return _pixel.pack(ptr[0], ptr[1], ptr[3], false);
}
}
typename StickModel< ScalarType >::PixelType StickModel< ScalarType >::SimulateMeasurement()
{
PixelType signal;
signal.SetSize(this->m_GradientList.size());
for( unsigned int i=0; i<this->m_GradientList.size(); i++)
{
GradientType g = this->m_GradientList[i];
double bVal = g.GetNorm(); bVal *= bVal;
if (bVal>0.0001)
{
double dot = this->m_FiberDirection*g;
signal[i] = exp( -m_BValue * bVal * m_Diffusivity*dot*dot );
}
else
signal[i] = 1;
}
return signal;
}
void ComparePixels( itk::Image<itk::RGBPixel<TPixel>,VImageDimension>* image )
{
typedef itk::RGBPixel<TPixel> PixelType;
typedef itk::Image<PixelType, VImageDimension> ImageType;
typename ImageType::IndexType pixelIndex;
pixelIndex[0] = pos1.x;
pixelIndex[1] = pos1.y;
PixelType onePixel = image->GetPixel( pixelIndex );
MITK_TEST_CONDITION( color1[0] == onePixel.GetBlue(), "Testing if blue value (= " << static_cast<int>(color1[0]) << ") at postion "
<< pos1.x << ", " << pos1.y << " in OpenCV image is "
<< "equals the blue value (= " << static_cast<int>(onePixel.GetBlue()) << ")"
<< " in the generated mitk image");
pixelIndex[0] = pos2.x;
pixelIndex[1] = pos2.y;
onePixel = image->GetPixel( pixelIndex );
MITK_TEST_CONDITION( color2[1] == onePixel.GetGreen(), "Testing if green value (= " << static_cast<int>(color2[1]) << ") at postion "
<< pos2.x << ", " << pos2.y << " in OpenCV image is "
<< "equals the green value (= " << static_cast<int>(onePixel.GetGreen()) << ")"
<< " in the generated mitk image");
pixelIndex[0] = pos3.x;
pixelIndex[1] = pos3.y;
onePixel = image->GetPixel( pixelIndex );
MITK_TEST_CONDITION( color3[2] == onePixel.GetRed(), "Testing if red value (= " << static_cast<int>(color3[2]) << ") at postion "
<< pos3.x << ", " << pos3.y << " in OpenCV image is "
<< "equals the red value (= " << static_cast<int>(onePixel.GetRed()) << ")"
<< " in the generated mitk image");
}
void mitk::ImageVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
// Properties common for both images and segmentations
node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
node->AddProperty( "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "outline width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
node->AddProperty( "outline binary shadow", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "outline binary shadow color", ColorProperty::New(0.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "outline shadow width", mitk::FloatProperty::New( 1.5 ), renderer, overwrite );
if(image->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
node->AddProperty( "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) ); // set to user configurable default value (see global options)
node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
node->AddProperty( "Image Rendering.Mode", renderingModeProperty);
// Set default grayscale look-up table
mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
mitkLut->SetType(mitk::LookupTable::GRAYSCALE);
mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
mitkLutProp->SetLookupTable(mitkLut);
node->SetProperty("LookupTable", mitkLutProp);
std::string photometricInterpretation; // DICOM tag telling us how pixel values should be displayed
if ( node->GetStringProperty( "dicom.pixel.PhotometricInterpretation", photometricInterpretation ) )
{
// modality provided by DICOM or other reader
if ( photometricInterpretation.find("MONOCHROME1") != std::string::npos ) // meaning: display MINIMUM pixels as WHITE
{
// Set inverse grayscale look-up table
mitkLut->SetType(mitk::LookupTable::INVERSE_GRAYSCALE);
mitkLutProp->SetLookupTable(mitkLut);
node->SetProperty("LookupTable", mitkLutProp);
}
// Otherwise do nothing - the default grayscale look-up table has already been set
}
bool isBinaryImage(false);
if ( ! node->GetBoolProperty("binary", isBinaryImage) )
{
// ok, property is not set, use heuristic to determine if this
// is a binary image
mitk::Image::Pointer centralSliceImage;
ScalarType minValue = 0.0;
ScalarType maxValue = 0.0;
ScalarType min2ndValue = 0.0;
ScalarType max2ndValue = 0.0;
mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
sliceSelector->SetInput(image);
sliceSelector->SetSliceNr(image->GetDimension(2)/2);
sliceSelector->SetTimeNr(image->GetDimension(3)/2);
sliceSelector->SetChannelNr(image->GetDimension(4)/2);
sliceSelector->Update();
centralSliceImage = sliceSelector->GetOutput();
if ( centralSliceImage.IsNotNull() && centralSliceImage->IsInitialized() )
{
minValue = centralSliceImage->GetStatistics()->GetScalarValueMin();
maxValue = centralSliceImage->GetStatistics()->GetScalarValueMax();
min2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMin();
max2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMax();
}
if ((maxValue == min2ndValue && minValue == max2ndValue) || minValue == maxValue)
{
// centralSlice is strange, lets look at all data
minValue = image->GetStatistics()->GetScalarValueMin();
maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
}
isBinaryImage = ( maxValue == min2ndValue && minValue == max2ndValue );
}
// some more properties specific for a binary...
if (isBinaryImage)
{
node->AddProperty( "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite );
node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.selectedcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.selectedannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.hoveringcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.hoveringannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( true ), renderer, overwrite );
node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
}
else //...or image type object
{
node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
std::string className = image->GetNameOfClass();
if (className != "TensorImage" && className != "QBallImage")
{
PixelType pixelType = image->GetPixelType();
size_t numComponents = pixelType.GetNumberOfComponents();
if ((pixelType.GetPixelTypeAsString() == "vector" && numComponents > 1) || numComponents == 2 || numComponents > 4)
node->AddProperty("Image.Displayed Component", mitk::IntProperty::New(0), renderer, overwrite);
}
}
if(image.IsNotNull() && image->IsInitialized())
{
if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
{
/* initialize level/window from DICOM tags */
std::string sLevel;
std::string sWindow;
if ( image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
&& image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
{
float level = atof( sLevel.c_str() );
float window = atof( sWindow.c_str() );
mitk::LevelWindow contrast;
std::string sSmallestPixelValueInSeries;
std::string sLargestPixelValueInSeries;
if ( image->GetPropertyList()->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
&& image->GetPropertyList()->GetStringProperty( "dicom.series.LargestPixelValueInSeries", sLargestPixelValueInSeries ) )
{
float smallestPixelValueInSeries = atof( sSmallestPixelValueInSeries.c_str() );
float largestPixelValueInSeries = atof( sLargestPixelValueInSeries.c_str() );
contrast.SetRangeMinMax( smallestPixelValueInSeries-1, largestPixelValueInSeries+1 ); // why not a little buffer?
// might remedy some l/w widget challenges
}
else
{
contrast.SetAuto( static_cast<mitk::Image*>(node->GetData()), false, true ); // we need this as a fallback
}
contrast.SetLevelWindow( level, window, true );
node->SetProperty( "levelwindow", LevelWindowProperty::New( contrast ), renderer );
}
}
if(((overwrite) || (node->GetProperty("opaclevelwindow", renderer)==NULL))
&& (image->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA)
&& (image->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR) )
{
mitk::LevelWindow opaclevwin;
opaclevwin.SetRangeMinMax(0,255);
opaclevwin.SetWindowBounds(0,255);
mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
node->SetProperty( "opaclevelwindow", prop, renderer );
}
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
void operator() (PixelType& pixel) const
{
pixel.desaturate();
}
void operator() (PixelType& pixel) const
{
pixel.multiplyAlpha (alpha);
}
void MultiComponentImageDataComparisonFilter::GenerateData()
{
// check inputs
const Image* testInput = this->GetTestImage();
const Image* validInput = this->GetValidImage();
// Generally this filter is part of the mitk::Image::Equal() method and only checks the equality of the image data
// so no further image type comparison is performed!
// CAVE: If the images differ in a parameter other then the image data, the filter may fail!!
PixelType type = validInput->GetPixelType();
if(type.GetComponentType() == itk::ImageIOBase::CHAR)
{
CompareMultiComponentImage<char>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::UCHAR)
{
CompareMultiComponentImage<unsigned char>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::INT)
{
CompareMultiComponentImage<int>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::UINT)
{
CompareMultiComponentImage<unsigned int>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::SHORT)
{
CompareMultiComponentImage<short>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::USHORT)
{
CompareMultiComponentImage<unsigned short>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::LONG)
{
CompareMultiComponentImage<long>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::ULONG)
{
CompareMultiComponentImage<unsigned long>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::FLOAT)
{
CompareMultiComponentImage<float>( testInput, validInput);
}
else if (type.GetComponentType() == itk::ImageIOBase::DOUBLE)
{
CompareMultiComponentImage<double>( testInput, validInput);
}
else
{
mitkThrow() << "Pixel component type not supported!";
}
}
