mitkIpPicDescriptor *mitkIpFuncRank ( mitkIpPicDescriptor *pic_old,
mitkIpUInt4_t rank,
mitkIpUInt4_t mask_dim,
mitkIpUInt4_t mask_size,
mitkIpFuncFlagI_t border )
{
mitkIpPicDescriptor *pic_new; /* pointer to transformed image */
mitkIpInt4_t i; /* loop index */
mitkIpInt4_t offset; /* offset of image */
mitkIpInt4_t ind[_mitkIpPicNDIM]; /* loop index vector */
mitkIpInt4_t *off_vekt; /* pointer to offset vector */
mitkIpInt4_t begin; /* 0.5 * mask_size */
mitkIpUInt4_t size[_mitkIpPicNDIM]; /* */
mitkIpInt4_t n[_mitkIpPicNDIM]; /* size of each dimension */
mitkIpUInt4_t no_elem; /* number of elements in mask */
mitkIpUInt4_t len; /* length of offset vector */
/* calculate number of elements in mask */
no_elem = mask_size;
for ( i = 1; i < mask_dim; i++ )
no_elem = no_elem * mask_size;
/* check whether data are correct */
if ( _mitkIpFuncError ( pic_old ) != mitkIpFuncOK ) return ( mitkIpFuncERROR );
if ( mask_dim < 1 || mask_dim > pic_old->dim )
{
_mitkIpFuncSetErrno ( mitkIpFuncDIMMASC_ERROR );
return ( mitkIpFuncERROR );
}
if ( rank > no_elem )
{
_mitkIpFuncSetErrno ( mitkIpFuncDATA_ERROR );
return ( mitkIpFuncERROR );
}
if ( mask_size % 2 != 1 )
{
_mitkIpFuncSetErrno ( mitkIpFuncSIZE_ERROR );
return ( mitkIpFuncERROR );
}
/* initialize vectors and variables */
size[0] = 1;
for ( i = 1; i < _mitkIpPicNDIM; i++ )
size[i] = size[i-1] * pic_old->n[i-1];
len = 0;
begin = mask_size / 2;
for ( i = 0; i < mask_dim; i++ )
n[i] = begin + 1;
for ( i = mask_dim; i < _mitkIpPicNDIM; i++ )
n[i] = 1 - begin;
/* allocate image structure */
if ( border == mitkIpFuncBorderOld )
pic_new = mitkIpPicClone ( pic_old );
else if ( border == mitkIpFuncBorderZero )
{
pic_new = mitkIpPicCopyHeader ( pic_old, 0 );
pic_new->data = calloc ( _mitkIpPicElements ( pic_new ), pic_new->bpe/8 );
}
else
{
_mitkIpFuncSetErrno ( mitkIpFuncFLAG_ERROR );
return ( mitkIpFuncERROR );
}
if ( pic_new == NULL )
{
_mitkIpFuncSetErrno ( mitkIpFuncPICNEW_ERROR );
return ( mitkIpFuncERROR );
}
/* allocate offset vector */
off_vekt = malloc ( no_elem * sizeof ( mitkIpUInt4_t ) );
if ( off_vekt == NULL )
{
_mitkIpFuncSetErrno ( mitkIpFuncMALLOC_ERROR );
return ( mitkIpFuncERROR );
}
/* calculate offset vector */
for ( ind[0] = -begin; ind[0] < n[0]; ind[0]++ )
for ( ind[7] = -begin; ind[7] < n[7]; ind[7]++ )
for ( ind[6] = -begin; ind[6] < n[6]; ind[6]++ )
for ( ind[5] = -begin; ind[5] < n[5]; ind[5]++ )
for ( ind[4] = -begin; ind[4] < n[4]; ind[4]++ )
for ( ind[3] = -begin; ind[3] < n[3]; ind[3]++ )
for ( ind[2] = -begin; ind[2] < n[2]; ind[2]++ )
for ( ind[1] = -begin; ind[1] < n[1]; ind[1]++ )
{
offset = 0;
for ( i = 0; i < pic_old->dim; i++ )
offset = offset + ind[i] * size[i];
off_vekt[len] = offset;
len++;
}
if ( rank == 0 ) rank = no_elem / 2 + 1;
mitkIpPicFORALL_4 ( RANK, pic_old, begin, no_elem, size, rank );
free ( off_vekt );
/* Copy Tags */
mitkIpFuncCopyTags(pic_new, pic_old);
return ( pic_new );
}
int mitkImageTest(int argc, char* argv[])
{
MITK_TEST_BEGIN(mitkImageTest);
//Create Image out of nowhere
mitk::Image::Pointer imgMem;
mitk::PixelType pt(typeid(int));
unsigned int dim[]={100,100,20};
std::cout << "Testing creation of Image: ";
imgMem=mitk::Image::New();
if(imgMem.IsNull())
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Initialize(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions): ";
imgMem->Initialize(mitk::PixelType(typeid(int)), 3, dim);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing IsInitialized(): ";
if(imgMem->IsInitialized()==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetData(): ";
int *p = (int*)imgMem->GetData();
if(p==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Filling image: ";
unsigned int i;
unsigned int size = dim[0]*dim[1]*dim[2];
for(i=0; i<size; ++i, ++p)
*p= (signed int)i;
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Getting it again and compare with filled values: ";
int *p2 = (int*)imgMem->GetData();
if(p2==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
for(i=0; i<size; ++i, ++p2)
{
if(*p2!= (signed int)i )
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing IsInitialized(): ";
if(imgMem->IsInitialized()==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing GetSliceData() and compare with filled values: ";
p2 = (int*)imgMem->GetSliceData(dim[2]/2)->GetData();
unsigned int xy_size = dim[0]*dim[1];
unsigned int start_mid_slice = (dim[2]/2)*xy_size;
for(i=0; i<xy_size; ++i, ++p2)
{
if(*p2!=(signed int)(i+start_mid_slice))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
}
std::cout<<"[PASSED]"<<std::endl;
//----
mitkIpPicDescriptor *pic_slice=mitkIpPicClone(imgMem->GetSliceData(dim[2]/2)->GetPicDescriptor());
imgMem=mitk::Image::New();
std::cout << "Testing reinitializing via Initialize(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions): ";
imgMem->Initialize(mitk::PixelType(typeid(int)), 3, dim);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing slice-wise filling via SetPicSlice(): ";
for(i=0;i<dim[2];++i)
{
imgMem->SetPicSlice(pic_slice, i, 0, 0);
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Getting it again and compare with filled values: ";
p2 = (int*)imgMem->GetData();
if(p2==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
for(i=0; i<size; ++i, ++p2)
{
if(*p2!= (signed int)((i%xy_size)+start_mid_slice))
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing IsInitialized(): ";
if(imgMem->IsInitialized()==false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Setting a copy of the volume once again: ";
imgMem->SetPicVolume(mitkIpPicClone(imgMem->GetVolumeData(0)->GetPicDescriptor()),0);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Set a slice with different content via SetPicSlice(): ";
memset(pic_slice->data,0,xy_size*sizeof(int));
imgMem->SetPicSlice(pic_slice, 1);
std::cout << "Getting the volume again and compare the check the changed slice: ";
p2 = (int*)imgMem->GetData();
if(p2==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
p2+=xy_size;
for(i=0; i<xy_size; ++i, ++p2)
{
if(*p2!=0)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Setting volume again: ";
imgMem->SetVolume(imgMem->GetData());
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Set a slice with different content via SetSlice(): ";
memset(pic_slice->data,0,xy_size*sizeof(int));
imgMem->SetSlice(pic_slice->data, 0);
std::cout << "Getting the volume again and compare the check the changed slice: ";
p2 = (int*)imgMem->GetData();
if(p2==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
for(i=0; i<xy_size; ++i, ++p2)
{
if(*p2!=0)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
}
std::cout<<"[PASSED]"<<std::endl;
//std::cout << "Testing SetVolume(): ";
//imgMem->SetVolume(data);
//std::cout<<"[PASSED]"<<std::endl;
mitkIpPicFree(pic_slice);
//-----------------
// geometry information for image
mitk::Point3D origin;
mitk::Vector3D right, bottom;
mitk::Vector3D spacing;
mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
mitk::FillVector3D(right, 1.0, 2.0, 3.0);
mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing): " << std::flush;
mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
planegeometry->SetOrigin(origin);
std::cout << "done" << std::endl;
std::cout << "Testing Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int slices) with PlaneGeometry and GetData(): ";
imgMem->Initialize(mitk::PixelType(typeid(int)), *planegeometry);
p = (int*)imgMem->GetData();
if(p==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry) and GetData(): ";
imgMem->Initialize(mitk::PixelType(typeid(int)), 40, *planegeometry);
p = (int*)imgMem->GetData();
if(p==NULL)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
//-----------------
// testing origin information and methods
std::cout << "Testing correctness of origin via GetGeometry()->GetOrigin(): ";
if( mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of origin via GetTimeSlicedGeometry()->GetOrigin(): ";
if( mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetOrigin(), origin) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
mitk::FillVector3D(origin, 37.0, 17.92, 27.83);
std::cout << "Setting origin via SetOrigin(origin): ";
imgMem->SetOrigin(origin);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of changed origin via GetGeometry()->GetOrigin(): ";
if( mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of changed origin via GetTimeSlicedGeometry()->GetOrigin(): ";
if( mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetOrigin(), origin) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of changed origin via GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(): ";
if( mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(), origin) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
//-----------------
// testing spacing information and methods
std::cout << "Testing correctness of spacing via GetGeometry()->GetSpacing(): ";
if( mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of spacing via GetTimeSlicedGeometry()->GetSpacing(): ";
if( mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetSpacing(), spacing) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
mitk::FillVector3D(spacing, 7.0, 0.92, 1.83);
std::cout << "Setting spacing via SetSpacing(spacing): ";
imgMem->SetSpacing(spacing);
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of changed spacing via GetGeometry()->GetSpacing(): ";
if( mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of changed spacing via GetTimeSlicedGeometry()->GetSpacing(): ";
if( mitk::Equal(imgMem->GetTimeSlicedGeometry()->GetSpacing(), spacing) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
std::cout << "Testing correctness of changed spacing via GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(): ";
if( mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(), spacing) == false)
{
std::cout<<"[FAILED]"<<std::endl;
return EXIT_FAILURE;
}
std::cout<<"[PASSED]"<<std::endl;
//-----------------
MITK_TEST_OUTPUT(<< "Testing SetImportChannel");
mitk::Image::Pointer vecImg = mitk::Image::New();
vecImg->Initialize(*imgMem->GetPixelType().GetTypeId(), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/ );
vecImg->SetImportChannel(imgMem->GetData(), 0, mitk::Image::CopyMemory );
vecImg->SetImportChannel(imgMem->GetData(), 1, mitk::Image::CopyMemory );
std::cout<<"[PASSED]"<<std::endl;
MITK_TEST_OUTPUT(<< " Testing whether IsValidSlice returns valid after SetImportChannel");
MITK_TEST_CONDITION_REQUIRED( vecImg->IsValidSlice(0,0,1) , "");
MITK_TEST_OUTPUT(<< " Testing whether CopyMemory worked");
MITK_TEST_CONDITION_REQUIRED(imgMem->GetData() != vecImg->GetData(), "");
MITK_TEST_OUTPUT(<< " Testing destruction after SetImportChannel");
vecImg = NULL;
std::cout<<"[PASSED]"<<std::endl;
//-----------------
MITK_TEST_OUTPUT(<< "Testing initialization via vtkImageData");
MITK_TEST_OUTPUT(<< " Setting up vtkImageData");
vtkImageData* vtkimage = vtkImageData::New();
vtkimage->Initialize();
vtkimage->SetDimensions( 2, 3, 4);
double vtkorigin[] = {-350,-358.203, -1363.5};
vtkimage->SetOrigin(vtkorigin);
mitk::Point3D vtkoriginAsMitkPoint;
mitk::vtk2itk(vtkorigin, vtkoriginAsMitkPoint);
double vtkspacing[] = {1.367, 1.367, 2};
vtkimage->SetSpacing(vtkspacing);
vtkimage->SetScalarType( VTK_SHORT );
vtkimage->AllocateScalars();
std::cout<<"[PASSED]"<<std::endl;
MITK_TEST_OUTPUT(<< " Testing mitk::Image::Initialize(vtkImageData*, ...)");
mitk::Image::Pointer mitkByVtkImage = mitk::Image::New();
mitkByVtkImage ->Initialize(vtkimage);
MITK_TEST_CONDITION_REQUIRED(mitkByVtkImage->IsInitialized(), "");
MITK_TEST_OUTPUT(<< " vtkimage->Delete");
vtkimage->Delete();
std::cout<<"[PASSED]"<<std::endl;
MITK_TEST_OUTPUT(<< " Testing whether spacing has been correctly initialized from vtkImageData");
mitk::Vector3D spacing2 = mitkByVtkImage->GetGeometry()->GetSpacing();
mitk::Vector3D vtkspacingAsMitkVector;
mitk::vtk2itk(vtkspacing, vtkspacingAsMitkVector);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(spacing2,vtkspacingAsMitkVector), "");
MITK_TEST_OUTPUT(<< " Testing whether GetSlicedGeometry(0)->GetOrigin() has been correctly initialized from vtkImageData");
mitk::Point3D origin2 = mitkByVtkImage->GetSlicedGeometry(0)->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
MITK_TEST_OUTPUT(<< " Testing whether GetGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
origin2 = mitkByVtkImage->GetGeometry()->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
MITK_TEST_OUTPUT(<< " Testing whether GetTimeSlicedGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
origin2 = mitkByVtkImage->GetTimeSlicedGeometry()->GetOrigin();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
// TODO test the following initializers on channel-incorporation
// void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions, unsigned int channels)
// void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
// void mitk::Image::Initialize(const mitk::Image* image)
// void mitk::Image::Initialize(const mitkIpPicDescriptor* pic, int channels, int tDim, int sDim)
//mitk::Image::Pointer vecImg = mitk::Image::New();
//vecImg->Initialize(PixelType(typeid(float), 6, itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
//vecImg->Initialize(PixelType(typeid(itk::Vector<float,6>)), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
// testing access by index coordinates and by world coordinates
mitk::DataNode::Pointer node;
mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
MITK_TEST_CONDITION_REQUIRED(argc == 2, "Check if test image is accessible!");
const std::string filename = std::string(argv[1]);
try
{
nodeReader->SetFileName(filename);
nodeReader->Update();
node = nodeReader->GetOutput();
}
catch(...) {
MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
return NULL;
}
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
// test by index coordinates
mitk::Index3D index;
mitk::FillVector3D(index, 55, 39, 50);
MITK_TEST_OUTPUT(<< "Testing mitk::Image::GetPixelValueByIndex");
double val = image->GetPixelValueByIndex(index);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(val,112.22475433349609), "");
//test by world coordinates
MITK_TEST_OUTPUT(<< "Testing mitk::Image::GetPixelValueByWorldCoordinate");
mitk::Point3D point;
mitk::FillVector3D(point, -5.93752, 18.7199, 6.74218);
val = image->GetPixelValueByWorldCoordinate(point);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(val,94.456184387207031), "");
MITK_TEST_OUTPUT(<< "Convert to index and access value by mitk::Image::GetPixelValueByIndex again");
mitk::Index3D index2;
image->GetGeometry()->WorldToIndex(point, index2);
float val2 = image->GetPixelValueByIndex(index2);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(val2,94.456184387207031), "");
//access via itk
MITK_TEST_OUTPUT(<< "Test conversion to itk::Image");
typedef itk::Image<float,3> ItkFloatImage3D;
ItkFloatImage3D::Pointer itkimage;
mitk::CastToItkImage(image, itkimage);
std::cout<<"[PASSED]"<<std::endl;
MITK_TEST_OUTPUT(<< "Testing world->itk-physical->world consistency");
mitk::Point3D itkPhysicalPoint;
image->GetGeometry()->WorldToItkPhysicalPoint(point, itkPhysicalPoint);
mitk::Point3D backTransformedPoint;
image->GetGeometry()->ItkPhysicalPointToWorld(itkPhysicalPoint, backTransformedPoint);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(point,backTransformedPoint), "");
MITK_TEST_OUTPUT(<< "Compare value of pixel returned by mitk in comparison to itk");
itk::Index<3> idx;
itkimage->TransformPhysicalPointToIndex(itkPhysicalPoint, idx);
float valByItk = itkimage->GetPixel(idx);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(valByItk,94.456184387207031), "");
mitk::Image::Pointer cloneImage = image->Clone();
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension() == image->GetDimension(), "Clone (testing dimension)");
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetPixelType() == image->GetPixelType(), "Clone (testing pixel type)");
for (unsigned int i = 0u; i < cloneImage->GetDimension(); ++i)
{
MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension(i) == image->GetDimension(i), "Clone (testing dimension " << i << ")");
}
MITK_TEST_END();
return EXIT_SUCCESS;
}
bool mitk::CorrectorAlgorithm::modifySegment( int lineStart, int lineEnd, ipMITKSegmentationTYPE state, mitkIpPicDescriptor *pic, int* _ofsArray )
{
// offsets for pixels right, top, left, bottom
int nbDelta4[4];
nbDelta4[0]=1; nbDelta4[1]=pic->n[0]; nbDelta4[1]*=-1; // necessary because of unsigned declaration of pic->n
nbDelta4[2]=-1; nbDelta4[3]=pic->n[0];
// offsets for pixels right, top-right, top, top-left left, bottom-left, bottom, bottom-right
int nbDelta8[8];
nbDelta8[0] = 1; nbDelta8[1] = nbDelta4[1]+1; nbDelta8[2] = nbDelta4[1]; nbDelta8[3] = nbDelta4[1]-1;
nbDelta8[4] = -1; nbDelta8[5] = nbDelta4[3]-1; nbDelta8[6] = nbDelta4[3]; nbDelta8[7] = nbDelta4[3]+1;
ipMITKSegmentationTYPE* picdata = static_cast<ipMITKSegmentationTYPE*>(pic->data);
ipMITKSegmentationTYPE saveStart = *(picdata + _ofsArray[lineStart]);
ipMITKSegmentationTYPE saveEnd = *(picdata + _ofsArray[lineEnd]);
ipMITKSegmentationTYPE newState = ((!state)&1) + 2; // probably equal to: ipMITKSegmentationTYPE newState = 3 - state;
// make two copies of pic:
mitkIpPicDescriptor *seg1 = mitkIpPicClone( pic );
mitkIpPicDescriptor *seg2 = mitkIpPicClone( pic );
int i;
// mark line in original
for (i=lineStart; i<=lineEnd; i++) {
*(picdata + _ofsArray[i]) = 3;
}
// mark the first side in copy 1:
bool firstPix = true;
bool modified;
int line = pic->n[0]; // #pixels in line
int maxOfs = (int)(line * pic->n[1]); // #pixels in slice
for (i=lineStart+1; i<lineEnd; i++) {
do {
modified = false;
for (int nb=0; nb<8; nb++) {
int nbOfs = _ofsArray[i] + nbDelta8[nb];
if ( nbOfs < 0 // above first line
|| nbOfs >= maxOfs // below last line
) continue;
ipMITKSegmentationTYPE nbVal = *(picdata + nbOfs);
ipMITKSegmentationTYPE destVal = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
if (nbVal!=3 && destVal!=newState) { // get only neigbhours that are not part of the line itself
if (firstPix) {
*(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState; // this one is used to mark the side!
firstPix = false;
modified = true;
}
else {
int tnb = 0;
while ( tnb < 4
&& ((nbOfs + nbDelta4[tnb]) >= 0) && ((nbOfs + nbDelta4[tnb]) < maxOfs)
&& *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs + nbDelta4[tnb]) != newState
)
tnb++;
if (tnb < 4 && ((nbOfs + nbDelta4[tnb]) >= 0) && ((nbOfs + nbDelta4[tnb]) < maxOfs) ) {
*(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState; // we've got a buddy close
modified = true;
}
}
}
}
} while (modified);
}
// mark the other side in copy 2:
for (i=lineStart+1; i<lineEnd; i++) {
for (int nb=0; nb<4; nb++) {
int nbOfs = _ofsArray[i] + nbDelta4[nb];
if ( nbOfs < 0 // above first line
|| nbOfs >= maxOfs // below last line
) continue;
ipMITKSegmentationTYPE lineVal = *(picdata + nbOfs);
ipMITKSegmentationTYPE side1Val = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
if (lineVal != 3 && side1Val != newState) {
*(((ipMITKSegmentationTYPE*)seg2->data) + nbOfs) = newState;
}
}
}
// take care of line ends for multiple segments:
*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineStart]) = newState;
*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineEnd]) = newState;
*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineStart]) = newState;
*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineEnd]) = newState;
// replace regions:
newState = (!state)&1;
int sizeRegion1 = 0, sizeRegion2 = 0;
for (i=lineStart+1; i<lineEnd; i++) {
if (*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[i]) != newState) {
sizeRegion1 += ipMITKSegmentationReplaceRegion4N( seg1, _ofsArray[i], newState );
}
if (*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[i]) != newState) {
sizeRegion2 += ipMITKSegmentationReplaceRegion4N( seg2, _ofsArray[i], newState );
}
}
// combine image:
//printf( "Size Region1 = %8i Size Region2 = %8i\n", sizeRegion1, sizeRegion2 );
int sizeDif;
ipMITKSegmentationTYPE *current, *segSrc;
if (sizeRegion1 < sizeRegion2) {
segSrc = (ipMITKSegmentationTYPE*)seg1->data;
sizeDif = sizeRegion2 - sizeRegion1;
}
else {
segSrc = (ipMITKSegmentationTYPE*)seg2->data;
sizeDif = sizeRegion1 - sizeRegion2;
}
modified = false;
if (sizeDif > 2*(lineEnd-lineStart)) {
// decision is safe enough:
ipMITKSegmentationTYPE *end = picdata + (pic->n[0]*pic->n[1]);
for (current = picdata; current<end; current++) {
if (*segSrc == newState) *current = newState;
segSrc++;
}
modified = true;
}
// restore line:
for (int i=lineStart+1; i<lineEnd; i++) {
*(picdata + _ofsArray[i]) = state;
}
// restore end points:
*(picdata + _ofsArray[lineStart]) = saveStart;
*(picdata + _ofsArray[lineEnd]) = saveEnd;
mitkIpPicFree( seg1 );
mitkIpPicFree( seg2 );
return modified;
}
mitkIpPicDescriptor *mitkIpFuncWindowR ( mitkIpPicDescriptor *pic_1,
mitkIpPicDescriptor *pic_2,
mitkIpUInt4_t *begin,
mitkIpFuncFlagI_t keep )
{
mitkIpPicDescriptor *pic_new; /* pointer to transformed image */
mitkIpInt4_t i; /* loop index */
mitkIpUInt4_t end[_mitkIpPicNDIM]; /* end of image */
mitkIpUInt4_t size[_mitkIpPicNDIM]; /* */
/* check whether data are correct */
if ( _mitkIpFuncError ( pic_1 ) != mitkIpFuncOK ) return ( mitkIpFuncERROR );
if ( _mitkIpFuncError ( pic_2 ) != mitkIpFuncOK ) return ( mitkIpFuncERROR );
if ( pic_1->dim != pic_2->dim )
{
_mitkIpFuncSetErrno ( mitkIpFuncDIM_ERROR );
return ( mitkIpFuncERROR );
}
if ( pic_1->type != pic_2->type )
{
_mitkIpFuncSetErrno ( mitkIpFuncTYPE_ERROR );
return ( mitkIpFuncERROR );
}
if ( pic_1->bpe != pic_2->bpe )
{
_mitkIpFuncSetErrno ( mitkIpFuncSIZE_ERROR );
return ( mitkIpFuncERROR );
}
for ( i = 0; i < pic_1->dim; i++ )
{
if ( begin[i] < 0 || begin[i] > pic_1->n[i] )
{
_mitkIpFuncSetErrno ( mitkIpFuncDATA_ERROR );
return ( mitkIpFuncERROR );
}
end[i] = begin[i] + pic_2->n[i];
if ( end[i] > pic_1->n[i] )
{
_mitkIpFuncSetErrno ( mitkIpFuncDATA_ERROR );
return ( mitkIpFuncERROR );
}
}
/* initialize vectors and variables */
size[0] = 1;
for ( i = 1; i < _mitkIpPicNDIM; i++ )
size[i] = size[i-1] * pic_1->n[i-1];
size[pic_1->dim] = 0;
for ( i = pic_1->dim; i < _mitkIpPicNDIM; i++ )
{
begin[i] = 0;
end[i] = 1;
}
/* allocate image structure */
if ( keep == mitkIpFuncKeep )
pic_new = mitkIpPicClone ( pic_1 );
else
pic_new = pic_1;
mitkIpPicFORALL_3 ( WINDR, pic_2, begin, end, size );
/* Copy Tags */
mitkIpFuncCopyTags(pic_new, pic_1);
return ( pic_new );
}
