void mitk::DopplerToStrainRateFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
mitk::Point3iProperty::Pointer pointProp;
pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
if (pointProp.IsNotNull() )
{
m_Origin = pointProp->GetValue();
}
MITK_INFO << "compute Strain Rate Image .... " << std::endl
<< " origin[0]=" << m_Origin[0] << " origin[1]=" << m_Origin[1] << " origin[2]=" << m_Origin[2] << std::endl
<< " distance=" << m_Distance << std::endl
<< " NoStrainIntervall=" << m_NoStrainInterval << std::endl;
const Vector3D & spacing = input->GetSlicedGeometry()->GetSpacing();
// MITK_INFO << " in: xres=" << spacing[0] << " yres=" << spacing[1] << " zres=" << spacing[2] << std::endl;
mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
timeSelector->SetInput(input);
mitkIpPicDescriptor* picStrainRate;
picStrainRate = mitkIpPicNew();
picStrainRate->dim=3;
picStrainRate->bpe = output->GetPixelType().GetBpe();
//picStrainRate->type = output->GetPixelType().GetType();
picStrainRate->n[0] = output->GetDimension(0);
picStrainRate->n[1] = output->GetDimension(1);
picStrainRate->n[2] = output->GetDimension(2);
picStrainRate->data=malloc(_mitkIpPicSize(picStrainRate));
int xDim = picStrainRate->n[0];
int yDim = picStrainRate->n[1];
int zDim = picStrainRate->n[2];
long slice_size = xDim*yDim;
long vol_size = slice_size*zDim;
mitkIpPicDescriptor *picDoppler;
int x,y,z;//,time; // loop-counter
int strainRate; // the computed Strain Rate
int v1,v2; // velocity and Point p1 and p2
float alpha; // the beam-angle, angle betwen current point and beam-point
float dx=0, dy=0; // projection of this->distance to x- and y-axis
int x1; // a square, where the velocity v1 lies in
int y1; // the points are used for interpolation
int minStrainRate=128, maxStrainRate=128;
int n, nmax;
int t, tmax;
t = output->GetRequestedRegion().GetIndex(3);
n = output->GetRequestedRegion().GetIndex(4);
MITK_INFO << "t = " <<t << " n = " << n << std::endl;
tmax = t + output->GetRequestedRegion().GetSize(3);
nmax = n + output->GetRequestedRegion().GetSize(4);
MITK_INFO << "tmax = "<< tmax << " nmax = " << nmax << std::endl;
if (m_Distance<1) m_Distance=1;
for(;n<nmax;n++)//output->GetNumberOfChannels();++n)
{
timeSelector->SetChannelNr(n);
MITK_INFO << "computing chanel n = " << n << std::endl;
for(t=0;t<tmax;t++)
{
MITK_INFO << "computing time slot t = " << t << std::endl;
timeSelector->SetTimeNr(t);
timeSelector->Update();
// Cast to pic descriptor for the timeSelector image
mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew();
CastToIpPicDescriptor( timeSelector->GetOutput(), timeSelectorPic );
_mitkIpPicFreeTags(picStrainRate->info->tags_head);
picStrainRate->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head);
//#define WRITE_ANGLE_PIC
#ifdef WRITE_ANGLE_PIC
mitkIpPicDescriptor *anglePic;
mitkIpBool_t isAnglePicWritten = mitkIpFalse;
anglePic = mitkIpPicNew();
anglePic->type = mitkIpPicInt;
anglePic->bpe = 8;
anglePic->dim = 2;
anglePic->n[0] = xDim;
anglePic->n[1] = yDim;
anglePic->data = (mitkIpInt1_t *)calloc(xDim*yDim,sizeof(mitkIpInt1_t));
#endif
picDoppler = timeSelectorPic;
picDoppler = mitkIpFuncGausF( picDoppler, 5,2 , mitkIpFuncBorderOld ) ;
for (z=0 ; z<zDim ; z++) {
for (y=1; y<yDim; y++) {
if (y<m_Origin[1]) continue; // cannot compute StrainRate above Transducer-Position
for (x=0; x<xDim; x++) {
if ((m_Origin[0] - x)==0) { // winkelhalbierende
int yDistanceInUnits = (int)( m_Distance/spacing[1]);
int yTmp = ( (y-yDistanceInUnits)<0 ) ? 0 : (y-yDistanceInUnits);
v1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + yTmp*xDim + x] ;
v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ;
} else {
// compute angle to transducer position
// m_Origin is given in units, not in mm
alpha = atan( (float) (m_Origin[0] - x) / (float) (m_Origin[1] - y) );
// m_Distance is given in mm
dx = -sin(alpha) * m_Distance;
dy = -cos(alpha) * m_Distance;
// convert to units
dx = dx/spacing[0];
dy = dy/spacing[1];
//#define WEIGTHED
#ifdef WEIGTHED
weightX = dx - floor(dx);
weightY = dy - floor(dy);
dxFloor = (int) floor(dx);
dyFloor = (int) floor(dy);
x1 = x + dxFloor; // lower left
y1 = y + dyFloor;
x2 = x + (dxFloor+1); // lower right
y2 = y + dyFloor;
x3 = x + (dxFloor+1); // upper right
y3 = y + (dyFloor+1);
x4 = x + dxFloor; // upper left
y4 = y + (dyFloor+1);
vTmp1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1];
vTmp2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y2*xDim + x2];
vTmp3 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y3*xDim + x3];
vTmp4 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y4*xDim + x4];
v1 = (int) ((1-weightX)*(1-weightY)*vTmp1 + weightX*(1-weightY)*vTmp2 + weightX*weightY*vTmp3 + (1-weightX)*weightY*vTmp4);
v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ;
#else
x1 = (int)(x + dx);
y1 = (int)(y + dy);
if (y1<0) y1=0;
#endif
v1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1];
v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ;
}
if (v1==128) { // schaue in Gegenrichtung, falls keine SRI hier berechenbar
x1 = (int)(x - dx);
y1 = (int)(y - dy);
if (y1>yDim) y1=yDim;
//swap v1 and v2, otherwise StrainRate is calculate in false direction
v1 = v2;
v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1];
}
if ( (v1==0 ) || (v2==0) || // wenn keine Geschwindigkeit vorhanden
// oder wenn nur ganz kleine Geschwindigkeit vorhanden
(v1>=(128-m_NoStrainInterval) && v1<=(128+m_NoStrainInterval)) ||
(v2>=(128-m_NoStrainInterval) && v2<=(128+m_NoStrainInterval))) {
strainRate = 128; // this means no deformation
// this is neccessay due to the Cyl2Cart filter
} else {
strainRate = (int)( (v1 - v2)/2 + 128 );
if (strainRate==128) strainRate=129;
}
if (strainRate < minStrainRate && strainRate > 0 )
minStrainRate = strainRate;
if (strainRate > maxStrainRate)
maxStrainRate = strainRate;
if (strainRate<0 ) {
//strainRate = -strainRate;
MITK_INFO << " error: neg. strainRate ... exit() " << std::endl
<< " x=" << x << " y=" << y << " z=" << z << std::endl
<< " v1=" << v1 << " v2=" << v2 << " dist=" << m_Distance << std::endl
<< " sr=" << strainRate << std::endl;
exit(0);
}
((mitkIpUInt1_t *)picStrainRate->data)[t*vol_size + z*slice_size + y*xDim + x]=strainRate;
// cout << "z: " << z << " y: " << y << " x: " << x << " strainrate: " << strainRate << endl;
#ifdef WRITE_ANGLE_PIC
// if (!isAnglePicWritten)
// ((mitkIpInt1_t *)anglePic->data)[y*xDim + x] = (int) ( (alpha/1.6)*128);
if (!isAnglePicWritten)
((mitkIpInt1_t *)anglePic->data)[y*xDim + x] = (int) ( dx);
#endif
} // x
} // y
//isAnglePicWritten = mitkIpTrue;
} // z
//isStrainComputed = mitkIpTrue;
std::string filenameD;
filenameD ="doppler.pic";
mitkIpPicPut(const_cast<char *>(filenameD.c_str()),picDoppler);
#define WRITE_STRAIN_PIC
#ifdef WRITE_STRAIN_PIC
char tmpfilename[100];
sprintf(tmpfilename,"strain%d.pic",t);;
mitkIpPicPut(tmpfilename,picStrainRate);
#endif
#ifdef WRITE_ANGLE_PIC
std::string filename2;
filename2="angle.pic";
mitkIpPicPut(const_cast<char *>(filename2.c_str()),anglePic);
#endif
((mitkIpUInt1_t *)picStrainRate->data)[0]=0;
((mitkIpUInt1_t *)picStrainRate->data)[1]=255;
output->SetVolume(picStrainRate->data, t, n);
}
}
mitkIpPicFree(picStrainRate);
#define WRITE_STRAIN_PIC
#ifdef WRITE_STRAIN_PIC
// Get the StrainRate ipPic descriptor
picStrainRate = mitkIpPicNew();
CastToIpPicDescriptor( output, picStrainRate );
std::string filename;
filename ="strain.pic";
mitkIpPicPut(const_cast<char *>(filename.c_str()),picStrainRate);
#endif
MITK_INFO << "Strain Rate Image computed.... " << std::endl
<< " minStrainRate: " << minStrainRate << std::endl
<< " maxStrainRate: " << maxStrainRate << std::endl;
}
void mitk::CylindricToCartesianFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
timeSelector->SetInput(input);
mitkIpPicDescriptor* pic_transformed=NULL;
pic_transformed = mitkIpPicNew();
pic_transformed->dim=3;
pic_transformed->bpe = output->GetPixelType().GetBpe();
//pic_transformed->type = output->GetPixelType().GetType();
pic_transformed->n[0] = output->GetDimension(0);
pic_transformed->n[1] = output->GetDimension(1);
pic_transformed->n[2] = output->GetDimension(2);
pic_transformed->data=malloc(_mitkIpPicSize(pic_transformed));
int nstart, nmax;
int tstart, tmax;
tstart=output->GetRequestedRegion().GetIndex(3);
nstart=output->GetRequestedRegion().GetIndex(4);
tmax=tstart+output->GetRequestedRegion().GetSize(3);
nmax=nstart+output->GetRequestedRegion().GetSize(4);
if(zt==NULL)
{
timeSelector->SetChannelNr(nstart);
timeSelector->SetTimeNr(tstart);
buildTransformShortCuts(input->GetDimension(0),input->GetDimension(1), input->GetDimension(2), output->GetDimension(0), rt_pic, phit_pic, fr_pic, fphi_pic, zt, fz);
// query the line limiting the sector
a=b=0;
mitk::FloatProperty::Pointer prop;
prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE SLOPE").GetPointer());
if (prop.IsNotNull() )
a = prop->GetValue();
prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE OFFSET").GetPointer());
if (prop.IsNotNull() )
b = prop->GetValue();
buildConeCutOffShortCut(input->GetDimension(0),input->GetDimension(1), rt_pic, fr_pic, a, b, coneCutOff_pic);
// mitkIpPicPut("C:\\temp\\rt_90.pic",rt_pic);
//mitkIpPicPut("C:\\temp\\coneCutOff.pic", coneCutOff_pic);
}
int n,t;
for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n)
{
timeSelector->SetChannelNr(n);
for(t=tstart;t<tmax;++t)
{
timeSelector->SetTimeNr(t);
timeSelector->Update();
// Cast to pic descriptor for the timeSelector image
mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew();
CastToIpPicDescriptor( timeSelector->GetOutput(), timeSelectorPic );
_mitkIpPicFreeTags(pic_transformed->info->tags_head);
pic_transformed->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head);
if(input->GetDimension(2)>1)
{
mitkIpPicTypeMultiplex9(_transform, timeSelectorPic , pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
// mitkIpPicPut("1trf.pic",pic_transformed);
}
else
{
mitkIpPicDescriptor *doubleSlice = mitkIpPicCopyHeader( timeSelectorPic , NULL);
doubleSlice->dim=3;
doubleSlice->n[2]=2;
doubleSlice->data=malloc(_mitkIpPicSize(doubleSlice));
memcpy(doubleSlice->data, timeSelectorPic->data, _mitkIpPicSize(doubleSlice)/2);
mitkIpPicTypeMultiplex9(_transform, doubleSlice, pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
mitkIpPicFree(doubleSlice);
}
output->SetVolume(pic_transformed->data, t, n);
}
}
//mitkIpPicPut("outzzzzzzzz.pic",pic_transformed);
mitkIpPicFree(pic_transformed);
m_TimeOfHeaderInitialization.Modified();
}
mitkIpPicDescriptor *
MITKipPicGet( char *infile_name, mitkIpPicDescriptor *pic )
{
mitkIpPicFile_t infile;
mitkIpPicTag_t tag_name;
mitkIpUInt4_t len;
mitkIpUInt4_t to_read;
size_t size;
size_t number_of_elements;
size_t bytes_per_element;
size_t number_of_bytes;
size_t block_size;
size_t number_of_blocks;
size_t remaining_bytes;
size_t bytes_read;
size_t block_nr;
mitkIpUInt1_t* data;
size_t ignored;
infile = _mitkIpPicOpenPicFileIn( infile_name );
if( !infile )
{
/*ipPrintErr( "mitkIpPicGet: sorry, error opening infile\n" );*/
return( NULL );
}
/* read infile */
ignored = mitkIpPicFRead( tag_name, 1, 4, infile );
if( strncmp( "\037\213", tag_name, 2 ) == 0 )
{
fprintf( stderr, "mitkIpPicGetHeader: sorry, can't read compressed file\n" );
return( NULL );
}
else if( strncmp( mitkIpPicVERSION, tag_name, 4 ) != 0 )
{
#ifndef CHILIPLUGIN
if( pic == NULL )
pic = _MITKipPicOldGet( infile,
NULL );
else
_MITKipPicOldGet( infile,
pic );
if( infile != stdin )
mitkIpPicFClose( infile );
#else
return NULL;
#endif
return( pic );
}
size = 0;
if( pic == NULL )
pic = mitkIpPicNew();
else
{
size= _mitkIpPicSize(pic);
if(pic->data == NULL)
size = 0;
}
if( pic->info != NULL )
{
_mitkIpPicFreeTags( pic->info->tags_head );
pic->info->tags_head = NULL;
}
ignored = mitkIpPicFRead( &(tag_name[4]), 1, sizeof(mitkIpPicTag_t)-4, infile );
strncpy( pic->info->version, tag_name, _mitkIpPicTAGLEN );
ignored = mitkIpPicFReadLE( &len, sizeof(mitkIpUInt4_t), 1, infile );
ignored = mitkIpPicFReadLE( &(pic->type), sizeof(mitkIpUInt4_t), 1, infile );
ignored = mitkIpPicFReadLE( &(pic->bpe), sizeof(mitkIpUInt4_t), 1, infile );
ignored = mitkIpPicFReadLE( &(pic->dim), sizeof(mitkIpUInt4_t), 1, infile );
ignored = mitkIpPicFReadLE( &(pic->n), sizeof(mitkIpUInt4_t), pic->dim, infile );
(void *)ignored;
to_read = len - 3 * sizeof(mitkIpUInt4_t)
- pic->dim * sizeof(mitkIpUInt4_t);
#if 0
mitkIpPicFSeek( infile, to_read, SEEK_CUR );
#else
pic->info->tags_head = _MITKipPicReadTags( pic->info->tags_head, to_read, infile, mitkIpPicEncryptionType(pic) );
#endif
pic->info->write_protect = mitkIpFalse;
if((size == 0) || (size != _mitkIpPicSize(pic)))
{
if( pic->data != NULL )
{
free( pic->data );
pic->data = NULL;
}
#ifdef WIN
if ((pic->hdata = GlobalAlloc( GMEM_MOVEABLE, _mitkIpPicSize(pic) )) != 0)
pic->data = GlobalLock( pic->hdata );
#else
pic->data = malloc( _mitkIpPicSize(pic) );
#endif
}
pic->info->pixel_start_in_file = mitkIpPicFTell( infile );
/*
* data is read in blocks of size 'block_size' to prevent from
* errors due to large file sizes (>=2GB)
*/
number_of_elements = _mitkIpPicElements(pic);
bytes_per_element = pic->bpe / 8;
number_of_bytes = number_of_elements * bytes_per_element;
block_size = 1024*1024; /* Use 1 MB blocks. Make sure that block size is smaller than 2^31 */
number_of_blocks = number_of_bytes / block_size;
remaining_bytes = number_of_bytes % block_size;
bytes_read = 0;
block_nr = 0;
/*printf( "mitkIpPicGet: number of blocks to read is %ul.\n", number_of_blocks ); */
data = (mitkIpUInt1_t*) pic->data;
if( pic->type == mitkIpPicNonUniform )
{
for ( block_nr = 0 ; block_nr < number_of_blocks ; ++block_nr )
bytes_read += mitkIpPicFRead( data + ( block_nr * block_size ), 1, (unsigned int) block_size, infile );
bytes_read += mitkIpPicFRead( data + ( number_of_blocks * block_size ), 1, (unsigned int) remaining_bytes, infile );
}
else
{
for ( block_nr = 0 ; block_nr < number_of_blocks ; ++block_nr )
bytes_read += mitkIpPicFReadLE( data + ( block_nr * block_size ), 1, (unsigned int) block_size, infile );
bytes_read += mitkIpPicFReadLE( data + ( number_of_blocks * block_size ), 1, (unsigned int) remaining_bytes, infile );
}
if ( bytes_read != number_of_bytes )
{
fprintf( stderr, "Error while reading, only %lu bytes were read! Eof indicator is %u.\n", (long unsigned int)bytes_read, mitkIpPicFEOF(infile) );
#ifndef USE_ZLIB
fprintf( stderr, "(ferror indicates %u).\n", ferror(infile));
#endif
}
if( infile != stdin )
mitkIpPicFClose( infile );
#ifdef WIN
GlobalUnlock( pic->hdata );
#endif
return( pic );
}
