#include <mitkDopplerToStrainRateFilter.h>
Public Types | |
| typedef DopplerToStrainRateFilter | Self |
| typedef ImageToImageFilter | Superclass |
| typedef itk::SmartPointer< Self > | Pointer |
| typedef itk::SmartPointer < const Self > | ConstPointer |
Public Member Functions | |
| virtual const char * | GetClassName () const |
| virtual void | SetDistance (float _arg) |
| virtual float | GetDistance () |
| virtual void | SetNoStrainInterval (int _arg) |
| virtual int | GetNoStrainInterval () |
| float | GetLimit () |
Static Public Member Functions | |
| static Pointer | New () |
Protected Member Functions | |
| virtual void | GenerateData () |
| A version of GenerateData() specific for image processing filters. | |
| virtual void | GenerateOutputInformation () |
| virtual void | GenerateInputRequestedRegion () |
| DopplerToStrainRateFilter () | |
| ~DopplerToStrainRateFilter () | |
Protected Attributes | |
| itk::TimeStamp | m_TimeOfHeaderInitialization |
Definition at line 35 of file mitkDopplerToStrainRateFilter.h.
| typedef itk::SmartPointer<const Self> mitk::DopplerToStrainRateFilter::ConstPointer |
Definition at line 38 of file mitkDopplerToStrainRateFilter.h.
| typedef itk::SmartPointer<Self> mitk::DopplerToStrainRateFilter::Pointer |
Definition at line 38 of file mitkDopplerToStrainRateFilter.h.
Definition at line 38 of file mitkDopplerToStrainRateFilter.h.
Definition at line 38 of file mitkDopplerToStrainRateFilter.h.
| mitk::DopplerToStrainRateFilter::DopplerToStrainRateFilter | ( | ) | [protected] |
Definition at line 334 of file mitkDopplerToStrainRateFilter.cpp.
: m_Distance(10), m_NoStrainInterval(2)
{
m_Origin[0] = 0;
m_Origin[1] = 0;
m_Origin[2] = 0;
}
| mitk::DopplerToStrainRateFilter::~DopplerToStrainRateFilter | ( | ) | [protected] |
Definition at line 349 of file mitkDopplerToStrainRateFilter.cpp.
{
}
| void mitk::DopplerToStrainRateFilter::GenerateData | ( | ) | [protected, virtual] |
A version of GenerateData() specific for image processing filters.
This implementation will split the processing across multiple threads. The buffer is allocated by this method. Then the BeforeThreadedGenerateData() method is called (if provided). Then, a series of threads are spawned each calling ThreadedGenerateData(). After all the threads have completed processing, the AfterThreadedGenerateData() method is called (if provided). If an image processing filter cannot be threaded, the filter should provide an implementation of GenerateData(). That implementation is responsible for allocating the output buffer. If a filter an be threaded, it should NOT provide a GenerateData() method but should provide a ThreadedGenerateData() instead.
Reimplemented from mitk::ImageSource.
Definition at line 65 of file mitkDopplerToStrainRateFilter.cpp.
References mitk::GenericProperty< T >::GetValue(), int(), MITK_INFO, mitkIpPicDescriptor, mitk::ImageTimeSelector::New(), and QuadProgPP::t().
{
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();
_mitkIpPicFreeTags(picStrainRate->info->tags_head);
picStrainRate->info->tags_head = _mitkIpPicCloneTags(timeSelector->GetOutput()->GetPic()->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 = timeSelector->GetOutput()->GetPic();
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->SetPicVolume(picStrainRate, t, n);
}
}
mitkIpPicFree(picStrainRate);
#define WRITE_STRAIN_PIC
#ifdef WRITE_STRAIN_PIC
picStrainRate = output->GetPic();
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::DopplerToStrainRateFilter::GenerateInputRequestedRegion | ( | ) | [protected, virtual] |
What is the input requested region that is required to produce the output requested region? The base assumption for image processing filters is that the input requested region can be set to match the output requested region. If a filter requires more input (for instance a filter that uses neighborhoods needs more input than output to avoid introducing artificial boundary conditions) or less input (for instance a magnify filter) will have to override this method. In doing so, it should call its superclass' implementation as its first step. Note that this imaging filters operate differently than the classes to this point in the class hierachy. Up till now, the base assumption has been that the largest possible region will be requested of the input.
Reimplemented from mitk::ImageToImageFilter.
Definition at line 354 of file mitkDopplerToStrainRateFilter.cpp.
{
Superclass::GenerateInputRequestedRegion();
mitk::ImageToImageFilter::InputImagePointer input =
const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
mitk::Image::Pointer output = this->GetOutput();
Image::RegionType requestedRegion;
requestedRegion = output->GetRequestedRegion();
requestedRegion.SetIndex(0, 0);
requestedRegion.SetIndex(1, 0);
requestedRegion.SetIndex(2, 0);
//requestedRegion.SetIndex(3, 0);
//requestedRegion.SetIndex(4, 0);
requestedRegion.SetSize(0, input->GetDimension(0));
requestedRegion.SetSize(1, input->GetDimension(1));
requestedRegion.SetSize(2, input->GetDimension(2));
//requestedRegion.SetSize(3, output->GetDimension(3));
//requestedRegion.SetSize(4, output->GetNumberOfChannels());
input->SetRequestedRegion( & requestedRegion );
}
| void mitk::DopplerToStrainRateFilter::GenerateOutputInformation | ( | void | ) | [protected, virtual] |
Definition at line 28 of file mitkDopplerToStrainRateFilter.cpp.
References mitk::ImageToImageFilter::GetInput(), mitk::ImageSource::GetOutput(), and m_TimeOfHeaderInitialization.
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int i;
unsigned int *tmpDimensions = new unsigned int[input->GetDimension()];
for(i=0;i<input->GetDimension();++i)
tmpDimensions[i]=input->GetDimension(i);
//@todo maybe we should shift the following somehow in ImageToImageFilter
output->Initialize(input->GetPixelType(),
input->GetDimension(),
tmpDimensions,
input->GetNumberOfChannels());
output->GetSlicedGeometry()->SetSpacing(input->GetSlicedGeometry()->GetSpacing());
//output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
//output->GetSlicedGeometry()->SetEvenlySpaced();
//set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
output->SetPropertyList(input->GetPropertyList()->Clone());
delete [] tmpDimensions;
m_TimeOfHeaderInitialization.Modified();
}
| virtual const char* mitk::DopplerToStrainRateFilter::GetClassName | ( | ) | const [virtual] |
| virtual float mitk::DopplerToStrainRateFilter::GetDistance | ( | ) | [virtual] |
| float mitk::DopplerToStrainRateFilter::GetLimit | ( | ) |
Definition at line 344 of file mitkDopplerToStrainRateFilter.cpp.
{ return (128/m_Distance);
}
| virtual int mitk::DopplerToStrainRateFilter::GetNoStrainInterval | ( | ) | [virtual] |
| static Pointer mitk::DopplerToStrainRateFilter::New | ( | ) | [static] |
Method for creation through the object factory.
Reimplemented from mitk::ImageToImageFilter.
| virtual void mitk::DopplerToStrainRateFilter::SetDistance | ( | float | _arg ) | [virtual] |
| virtual void mitk::DopplerToStrainRateFilter::SetNoStrainInterval | ( | int | _arg ) | [virtual] |
itk::TimeStamp mitk::DopplerToStrainRateFilter::m_TimeOfHeaderInitialization [protected] |
Definition at line 54 of file mitkDopplerToStrainRateFilter.h.
Referenced by GenerateOutputInformation().
1.7.2