int mitkMultiComponentImageDataComparisonFilterTest(int /*argc*/, char *argv[])
{
MITK_TEST_BEGIN("MultiComponentImageDataComparisonFilter");
// instantiation
mitk::MultiComponentImageDataComparisonFilter::Pointer testObject =
mitk::MultiComponentImageDataComparisonFilter::New();
MITK_TEST_CONDITION_REQUIRED(testObject.IsNotNull(), "Testing instantiation of test class!");
MITK_TEST_CONDITION_REQUIRED(testObject->GetCompareFilterResult() == nullptr, "Testing initialization of result struct");
MITK_TEST_CONDITION_REQUIRED(testObject->GetTolerance() == 0.0f, "Testing initialization of tolerance member");
MITK_TEST_CONDITION_REQUIRED(testObject->GetResult() == false, "Testing initialization of CompareResult member");
// initialize compare result struct and pass it to the filter
mitk::CompareFilterResults compareResult;
compareResult.m_MaximumDifference = 0.0f;
compareResult.m_MinimumDifference = itk::NumericTraits<double>::max();
compareResult.m_MeanDifference = 0.0f;
compareResult.m_FilterCompleted = false;
compareResult.m_TotalDifference = 0.0f;
compareResult.m_PixelsWithDifference = 0;
testObject->SetCompareFilterResult(&compareResult);
MITK_TEST_CONDITION_REQUIRED(testObject->GetCompareFilterResult() != nullptr,
"Testing set/get of compare result struct");
MITK_TEST_CONDITION_REQUIRED(testObject->GetResult() == false, "CompareResult still false");
// now load an image with several components and present it to the filter
mitk::Image::Pointer testImg = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(argv[1])[0].GetPointer());
mitk::Image::Pointer testImg2 = testImg->Clone();
testObject->SetValidImage(testImg);
testObject->SetTestImage(testImg2);
MITK_TEST_CONDITION_REQUIRED(testObject->GetNumberOfIndexedInputs() == 2, "Testing correct handling of input images");
testObject->Update();
MITK_TEST_CONDITION_REQUIRED(testObject->GetResult(), "Testing filter processing with equal image data");
// now change some of the data and check if the response is correct
mitk::ImageReadAccessor imgAcc(testImg2);
unsigned char *imgData = (unsigned char *)imgAcc.GetData();
imgData[10] += 1;
imgData[20] += 2;
imgData[30] += 3;
testObject->Update();
MITK_TEST_CONDITION_REQUIRED(testObject->GetResult() == false, "Testing filter processing with unequal image data");
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal((int)testObject->GetCompareFilterResult()->m_PixelsWithDifference, (int)3) &&
mitk::Equal((double)testObject->GetCompareFilterResult()->m_MaximumDifference, (double)3.0) &&
mitk::Equal((double)testObject->GetCompareFilterResult()->m_MeanDifference, (double)2.0),
"Assessing calculated image differences");
MITK_TEST_END();
}
mitk::Image::Pointer mitk::CompressedImageContainer::GetImage()
{
if (m_ByteBuffers.empty())
return nullptr;
// uncompress image data, create an Image
Image::Pointer image = Image::New();
unsigned int dims[20]; // more than 20 dimensions and bang
for (unsigned int dim = 0; dim < m_ImageDimension; ++dim)
dims[dim] = m_ImageDimensions[dim];
image->Initialize(*m_PixelType, m_ImageDimension, dims); // this IS needed, right ?? But it does allocate memory ->
// does create one big lump of memory (also in windows)
unsigned int timeStep(0);
for (auto iter = m_ByteBuffers.begin(); iter != m_ByteBuffers.end(); ++iter, ++timeStep)
{
ImageReadAccessor imgAcc(image, image->GetVolumeData(timeStep));
auto *dest((unsigned char *)imgAcc.GetData());
::uLongf destLen(m_OneTimeStepImageSizeInBytes);
::Bytef *source(iter->first);
::uLongf sourceLen(iter->second);
int zlibRetVal = ::uncompress(dest, &destLen, source, sourceLen);
if (itk::Object::GetDebug())
{
if (zlibRetVal == Z_OK)
{
MITK_INFO << "Success, destLen now " << destLen << " bytes" << std::endl;
}
else
{
switch (zlibRetVal)
{
case Z_DATA_ERROR:
MITK_ERROR << "compressed data corrupted" << std::endl;
break;
case Z_MEM_ERROR:
MITK_ERROR << "not enough memory" << std::endl;
break;
case Z_BUF_ERROR:
MITK_ERROR << "output buffer too small" << std::endl;
break;
default:
MITK_ERROR << "other, unspecified error" << std::endl;
break;
}
}
}
}
image->SetGeometry(m_ImageGeometry);
image->Modified();
return image;
}
void mitk::CompressedImageContainer::SetImage(Image *image)
{
for (auto iter = m_ByteBuffers.begin(); iter != m_ByteBuffers.end(); ++iter)
{
free(iter->first);
}
m_ByteBuffers.clear();
// Compress diff image using zlib (will be restored on demand)
// determine memory size occupied by voxel data
m_ImageDimension = image->GetDimension();
m_ImageDimensions.clear();
m_PixelType = new mitk::PixelType(image->GetPixelType());
m_OneTimeStepImageSizeInBytes = m_PixelType->GetSize(); // bits per element divided by 8
for (unsigned int i = 0; i < m_ImageDimension; ++i)
{
unsigned int currentImageDimension = image->GetDimension(i);
m_ImageDimensions.push_back(currentImageDimension);
if (i < 3)
{
m_OneTimeStepImageSizeInBytes *= currentImageDimension; // only the 3D memory size
}
}
m_ImageGeometry = image->GetGeometry();
m_NumberOfTimeSteps = 1;
if (m_ImageDimension > 3)
{
m_NumberOfTimeSteps = image->GetDimension(3);
}
for (unsigned int timestep = 0; timestep < m_NumberOfTimeSteps; ++timestep)
{
// allocate a buffer as specified by zlib
unsigned long bufferSize =
m_OneTimeStepImageSizeInBytes + static_cast<unsigned long>(m_OneTimeStepImageSizeInBytes * 0.2) + 12;
auto *byteBuffer = (unsigned char *)malloc(bufferSize);
if (itk::Object::GetDebug())
{
// compress image here into a buffer
MITK_INFO << "Using ZLib version: '" << zlibVersion() << "'" << std::endl
<< "Attempting to compress " << m_OneTimeStepImageSizeInBytes << " image bytes into a buffer of size "
<< bufferSize << std::endl;
}
ImageReadAccessor imgAcc(image, image->GetVolumeData(timestep));
::Bytef *dest(byteBuffer);
::uLongf destLen(bufferSize);
auto *source((unsigned char *)imgAcc.GetData());
::uLongf sourceLen(m_OneTimeStepImageSizeInBytes);
int zlibRetVal = ::compress(dest, &destLen, source, sourceLen);
if (itk::Object::GetDebug())
{
if (zlibRetVal == Z_OK)
{
MITK_INFO << "Success, using " << destLen << " bytes of the buffer (ratio "
<< ((double)destLen / (double)sourceLen) << ")" << std::endl;
}
else
{
switch (zlibRetVal)
{
case Z_MEM_ERROR:
MITK_ERROR << "not enough memory" << std::endl;
break;
case Z_BUF_ERROR:
MITK_ERROR << "output buffer too small" << std::endl;
break;
default:
MITK_ERROR << "other, unspecified error" << std::endl;
break;
}
}
}
// only use the neccessary amount of memory, realloc the buffer!
byteBuffer = (unsigned char *)realloc(byteBuffer, destLen);
bufferSize = destLen;
// MITK_INFO << "Using " << bufferSize << " bytes to store compressed image (" << destLen << " needed)" <<
// std::endl;
m_ByteBuffers.push_back(std::pair<unsigned char *, unsigned long>(byteBuffer, bufferSize));
}
}
