00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef __itkStatisticsLabelObject_h
00018 #define __itkStatisticsLabelObject_h
00019
00020 #include "itkShapeLabelObject.h"
00021 #include "itkHistogram.h"
00022
00023 namespace itk
00024 {
00025
00039 template < class TLabel, unsigned int VImageDimension >
00040 class ITK_EXPORT StatisticsLabelObject : public ShapeLabelObject< TLabel, VImageDimension >
00041 {
00042 public:
00044 typedef StatisticsLabelObject Self;
00045 typedef ShapeLabelObject< TLabel, VImageDimension > Superclass;
00046 typedef typename Superclass::LabelObjectType LabelObjectType;
00047 typedef SmartPointer<Self> Pointer;
00048 typedef SmartPointer<const Self> ConstPointer;
00049 typedef WeakPointer<const Self> ConstWeakPointer;
00050
00052 itkNewMacro(Self);
00053
00055 itkTypeMacro(StatisticsLabelObject, LabelObject);
00056
00057 typedef LabelMap< Self > LabelMapType;
00058
00059 itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension);
00060
00061 typedef typename Superclass::IndexType IndexType;
00062
00063 typedef Point< double, itkGetStaticConstMacro(ImageDimension) > PointType;
00064
00065 typedef TLabel LabelType;
00066
00067 typedef typename Superclass::LineType LineType;
00068
00069 typedef typename Superclass::LengthType LengthType;
00070
00071 typedef typename Superclass::LineContainerType LineContainerType;
00072
00073 typedef Matrix< double, itkGetStaticConstMacro(ImageDimension), itkGetStaticConstMacro(ImageDimension) > MatrixType;
00074
00075 typedef Vector< double, itkGetStaticConstMacro(ImageDimension) > VectorType;
00076
00077 typedef Statistics::Histogram< double > HistogramType;
00078
00079 typedef typename Superclass::AttributeType AttributeType;
00080 itkStaticConstMacro(MINIMUM, AttributeType, 200);
00081 itkStaticConstMacro(MAXIMUM, AttributeType, 201);
00082 itkStaticConstMacro(MEAN, AttributeType, 202);
00083 itkStaticConstMacro(SUM, AttributeType, 203);
00084 itkStaticConstMacro(SIGMA, AttributeType, 204);
00085 itkStaticConstMacro(VARIANCE, AttributeType, 205);
00086 itkStaticConstMacro(MEDIAN, AttributeType, 206);
00087 itkStaticConstMacro(MAXIMUM_INDEX, AttributeType, 207);
00088 itkStaticConstMacro(MINIMUM_INDEX, AttributeType, 208);
00089 itkStaticConstMacro(CENTER_OF_GRAVITY, AttributeType, 209);
00090
00091 itkStaticConstMacro(PRINCIPAL_MOMENTS, AttributeType, 211);
00092 itkStaticConstMacro(PRINCIPAL_AXES, AttributeType, 212);
00093 itkStaticConstMacro(KURTOSIS, AttributeType, 213);
00094 itkStaticConstMacro(SKEWNESS, AttributeType, 214);
00095 itkStaticConstMacro(ELONGATION, AttributeType, 215);
00096 itkStaticConstMacro(HISTOGRAM, AttributeType, 216);
00097 itkStaticConstMacro(FLATNESS, AttributeType, 217);
00098
00099 static AttributeType GetAttributeFromName( const std::string & s )
00100 {
00101 if( s == "Minimum" )
00102 {
00103 return MINIMUM;
00104 }
00105 else if( s == "Maximum" )
00106 {
00107 return MAXIMUM;
00108 }
00109 else if( s == "Mean" )
00110 {
00111 return MEAN;
00112 }
00113 else if( s == "Sum" )
00114 {
00115 return SUM;
00116 }
00117 else if( s == "Sigma" )
00118 {
00119 return SIGMA;
00120 }
00121 else if( s == "Variance" )
00122 {
00123 return VARIANCE;
00124 }
00125 else if( s == "Median" )
00126 {
00127 return MEDIAN;
00128 }
00129 else if( s == "MaximumIndex" )
00130 {
00131 return MAXIMUM_INDEX;
00132 }
00133 else if( s == "MinimumIndex" )
00134 {
00135 return MINIMUM_INDEX;
00136 }
00137 else if( s == "CenterOfGravity" )
00138 {
00139 return CENTER_OF_GRAVITY;
00140 }
00141
00142
00143
00144
00145
00146
00147 else if( s == "PrincipalMoments" )
00148 {
00149 return PRINCIPAL_MOMENTS;
00150 }
00151 else if( s == "PrincipalAxes" )
00152 {
00153 return PRINCIPAL_AXES;
00154 }
00155 else if( s == "Kurtosis" )
00156 {
00157 return KURTOSIS;
00158 }
00159 else if( s == "Skewness" )
00160 {
00161 return SKEWNESS;
00162 }
00163 else if( s == "Elongation" )
00164 {
00165 return ELONGATION;
00166 }
00167 else if( s == "Histogram" )
00168 {
00169 return HISTOGRAM;
00170 }
00171 else if( s == "Flatness" )
00172 {
00173 return FLATNESS;
00174 }
00175
00176 return Superclass::GetAttributeFromName( s );
00177 }
00178
00179 static std::string GetNameFromAttribute( const AttributeType & a )
00180 {
00181 switch( a )
00182 {
00183 case MINIMUM:
00184 return "Minimum";
00185 break;
00186 case MAXIMUM:
00187 return "Maximum";
00188 break;
00189 case MEAN:
00190 return "Mean";
00191 break;
00192 case SUM:
00193 return "Sum";
00194 break;
00195 case SIGMA:
00196 return "Sigma";
00197 break;
00198 case VARIANCE:
00199 return "Variance";
00200 break;
00201 case MEDIAN:
00202 return "Median";
00203 break;
00204 case MAXIMUM_INDEX:
00205 return "MaximumIndex";
00206 break;
00207 case MINIMUM_INDEX:
00208 return "MinimumIndex";
00209 break;
00210 case CENTER_OF_GRAVITY:
00211 return "CenterOfGravity";
00212 break;
00213
00214
00215
00216 case PRINCIPAL_MOMENTS:
00217 return "PrincipalMoments";
00218 break;
00219 case PRINCIPAL_AXES:
00220 return "PrincipalAxes";
00221 break;
00222 case KURTOSIS:
00223 return "Kurtosis";
00224 break;
00225 case SKEWNESS:
00226 return "Skewness";
00227 break;
00228 case ELONGATION:
00229 return "Elongation";
00230 break;
00231 case HISTOGRAM:
00232 return "Histogram";
00233 break;
00234 case FLATNESS:
00235 return "Flatness";
00236 break;
00237 }
00238
00239 return Superclass::GetNameFromAttribute( a );
00240 }
00241
00242 typedef ImageRegion< itkGetStaticConstMacro(ImageDimension) > RegionType;
00243
00244 typedef typename Superclass::CentroidType CentroidType;
00245
00246
00247 virtual void CopyAttributesFrom( const LabelObjectType * lo )
00248 {
00249 Superclass::CopyAttributesFrom( lo );
00250
00251
00252 const Self * src = dynamic_cast<const Self *>( lo );
00253 if( src == NULL )
00254 {
00255 return;
00256 }
00257 m_Minimum = src->m_Minimum;
00258 m_Maximum = src->m_Maximum;
00259 m_Mean = src->m_Mean;
00260 m_Sum = src->m_Sum;
00261 m_Sigma = src->m_Sigma;
00262 m_Variance = src->m_Variance;
00263 m_Median = src->m_Median;
00264 m_MaximumIndex = src->m_MaximumIndex;
00265 m_MinimumIndex = src->m_MinimumIndex;
00266 m_CenterOfGravity = src->m_CenterOfGravity;
00267
00268 m_PrincipalMoments = src->m_PrincipalMoments;
00269 m_PrincipalAxes = src->m_PrincipalAxes;
00270 m_Kurtosis = src->m_Kurtosis;
00271 m_Skewness = src->m_Skewness;
00272 m_Elongation = src->m_Elongation;
00273 m_Histogram = src->m_Histogram;
00274 m_Flatness = src->m_Flatness;
00275 }
00276
00277 const double & GetMinimum() const
00278 {
00279 return m_Minimum;
00280 }
00281
00282 void SetMinimum( const double & v )
00283 {
00284 m_Minimum = v;
00285 }
00286
00287 const double & GetMaximum() const
00288 {
00289 return m_Maximum;
00290 }
00291
00292 void SetMaximum( const double & v )
00293 {
00294 m_Maximum = v;
00295 }
00296
00297 const double & GetMean() const
00298 {
00299 return m_Mean;
00300 }
00301
00302 void SetMean( const double & v )
00303 {
00304 m_Mean = v;
00305 }
00306
00307 const double & GetSum() const
00308 {
00309 return m_Sum;
00310 }
00311
00312 void SetSum( const double & v )
00313 {
00314 m_Sum = v;
00315 }
00316
00317 const double & GetSigma() const
00318 {
00319 return m_Sigma;
00320 }
00321
00322 void SetSigma( const double & v )
00323 {
00324 m_Sigma = v;
00325 }
00326
00327 const double & GetVariance() const
00328 {
00329 return m_Variance;
00330 }
00331
00332 void SetVariance( const double & v )
00333 {
00334 m_Variance = v;
00335 }
00336
00337 const double & GetMedian() const
00338 {
00339 return m_Median;
00340 }
00341
00342 void SetMedian( const double & v )
00343 {
00344 m_Median = v;
00345 }
00346
00347 const IndexType & GetMaximumIndex() const
00348 {
00349 return m_MaximumIndex;
00350 }
00351
00352 void SetMaximumIndex( const IndexType & v )
00353 {
00354 m_MaximumIndex = v;
00355 }
00356
00357 const IndexType & GetMinimumIndex() const
00358 {
00359 return m_MinimumIndex;
00360 }
00361
00362 void SetMinimumIndex( const IndexType & v )
00363 {
00364 m_MinimumIndex = v;
00365 }
00366
00367 const PointType & GetCenterOfGravity() const
00368 {
00369 return m_CenterOfGravity;
00370 }
00371
00372 void SetCenterOfGravity( const PointType & v )
00373 {
00374 m_CenterOfGravity = v;
00375 }
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388 const VectorType & GetPrincipalMoments() const
00389 {
00390 return m_PrincipalMoments;
00391 }
00392
00393 void SetPrincipalMoments( const VectorType & v )
00394 {
00395 m_PrincipalMoments = v;
00396 }
00397
00398 const MatrixType & GetPrincipalAxes() const
00399 {
00400 return m_PrincipalAxes;
00401 }
00402
00403 void SetPrincipalAxes( const MatrixType & v )
00404 {
00405 m_PrincipalAxes = v;
00406 }
00407
00408 const double & GetSkewness() const
00409 {
00410 return m_Skewness;
00411 }
00412
00413 void SetSkewness( const double & v )
00414 {
00415 m_Skewness = v;
00416 }
00417
00418 const double & GetKurtosis() const
00419 {
00420 return m_Kurtosis;
00421 }
00422
00423 void SetKurtosis( const double & v )
00424 {
00425 m_Kurtosis = v;
00426 }
00427
00428 const double & GetElongation() const
00429 {
00430 return m_Elongation;
00431 }
00432
00433 void SetElongation( const double & v )
00434 {
00435 m_Elongation = v;
00436 }
00437
00438 const HistogramType * GetHistogram() const
00439 {
00440 return m_Histogram;
00441 }
00442
00443 void SetHistogram( const HistogramType * v )
00444 {
00445 m_Histogram = v;
00446 }
00447
00448 const double & GetFlatness() const
00449 {
00450 return m_Flatness;
00451 }
00452
00453 void SetFlatness( const double & v )
00454 {
00455 m_Flatness = v;
00456 }
00457
00458
00459
00461 typedef AffineTransform<double,itkGetStaticConstMacro(ImageDimension)> AffineTransformType;
00462 typedef typename AffineTransformType::Pointer AffineTransformPointer;
00463
00467 AffineTransformPointer GetPrincipalAxesToPhysicalAxesTransform() const
00468 {
00469 typename AffineTransformType::MatrixType matrix;
00470 typename AffineTransformType::OffsetType offset;
00471 for (unsigned int i = 0; i < ImageDimension; i++)
00472 {
00473 offset[i] = m_CenterOfGravity[i];
00474 for (unsigned int j = 0; j < ImageDimension; j++)
00475 {
00476 matrix[j][i] = m_PrincipalAxes[i][j];
00477 }
00478 }
00480
00481 AffineTransformPointer result = AffineTransformType::New();
00482
00483 result->SetMatrix(matrix);
00484 result->SetOffset(offset);
00485
00486 return result;
00487 }
00488
00493 AffineTransformPointer GetPhysicalAxesToPrincipalAxesTransform(void) const
00494 {
00495 typename AffineTransformType::MatrixType matrix;
00496 typename AffineTransformType::OffsetType offset;
00497 for (unsigned int i = 0; i < ImageDimension; i++)
00498 {
00499 offset[i] = m_CenterOfGravity[i];
00500 for (unsigned int j = 0; j < ImageDimension; j++)
00501 {
00502 matrix[j][i] = m_PrincipalAxes[i][j];
00503 }
00504 }
00506
00507 AffineTransformPointer result = AffineTransformType::New();
00508 result->SetMatrix(matrix);
00509 result->SetOffset(offset);
00510
00511 AffineTransformPointer inverse = AffineTransformType::New();
00512 result->GetInverse(inverse);
00513
00514 return inverse;
00515 }
00516
00517
00518 protected:
00519 StatisticsLabelObject()
00520 {
00521 m_Minimum = 0;
00522 m_Maximum = 0;
00523 m_Mean = 0;
00524 m_Sum = 0;
00525 m_Sigma = 0;
00526 m_Variance = 0;
00527 m_Median = 0;
00528 m_MaximumIndex.Fill(0);
00529 m_MinimumIndex.Fill(0);
00530 m_CenterOfGravity.Fill(0);
00531
00532 m_PrincipalMoments.Fill(0);
00533 m_PrincipalAxes.Fill(0);
00534 m_Kurtosis = 0;
00535 m_Skewness = 0;
00536 m_Elongation = 0;
00537 m_Histogram = NULL;
00538 m_Flatness = 0;
00539 }
00540
00541
00542 void PrintSelf(std::ostream& os, Indent indent) const
00543 {
00544 Superclass::PrintSelf( os, indent );
00545
00546 os << indent << "Minimum: " << m_Minimum << std::endl;
00547 os << indent << "Maximum: " << m_Maximum << std::endl;
00548 os << indent << "Mean: " << m_Mean << std::endl;
00549 os << indent << "Sum: " << m_Sum << std::endl;
00550 os << indent << "Sigma: " << m_Sigma << std::endl;
00551 os << indent << "Variance: " << m_Variance << std::endl;
00552 os << indent << "Median: " << m_Median << std::endl;
00553 os << indent << "MaximumIndex: " << m_MaximumIndex << std::endl;
00554 os << indent << "MinimumIndex: " << m_MinimumIndex << std::endl;
00555 os << indent << "CenterOfGravity: " << m_CenterOfGravity << std::endl;
00556
00557 os << indent << "PrincipalMoments: " << m_PrincipalMoments << std::endl;
00558 os << indent << "PrincipalAxes: " << std::endl << m_PrincipalAxes;
00559 os << indent << "Skewness: " << m_Skewness << std::endl;
00560 os << indent << "Kurtosis: " << m_Kurtosis << std::endl;
00561 os << indent << "Elongation: " << m_Elongation << std::endl;
00562 os << indent << "Histogram: ";
00563 if( m_Histogram.IsNull() )
00564 {
00565 os << "NULL" << std::endl;
00566 }
00567 else
00568 {
00569 m_Histogram->Print( os, indent );
00570 }
00571 os << indent << "Flatness: " << m_Flatness << std::endl;
00572 }
00573
00574 private:
00575 StatisticsLabelObject(const Self&);
00576 void operator=(const Self&);
00577
00578 double m_Minimum;
00579 double m_Maximum;
00580 double m_Mean;
00581 double m_Sum;
00582 double m_Sigma;
00583 double m_Variance;
00584 double m_Median;
00585 IndexType m_MaximumIndex;
00586 IndexType m_MinimumIndex;
00587 PointType m_CenterOfGravity;
00588
00589 VectorType m_PrincipalMoments;
00590 MatrixType m_PrincipalAxes;
00591 double m_Skewness;
00592 double m_Kurtosis;
00593 double m_Elongation;
00594 typename HistogramType::ConstPointer m_Histogram;
00595 double m_Flatness;
00596
00597 };
00598
00599 }
00600
00601 #endif
00602