FIXED Attach pointer/reference operator (*, &, or ^) to the variable type

Result after adding the --align-pointer=type option to astyle
Signed-off-by: Emmanuel Promayon <Emmanuel.Promayon@imag.fr>

imaging/actions/itkfilters/AnisotropicDiffusion.cpp

@@ -45,7 +45,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-AnisotropicDiffusion::AnisotropicDiffusion(ActionExtension * extension) : Action(extension) {
+AnisotropicDiffusion::AnisotropicDiffusion(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Anisotropic Diffusion");
     setDescription("<p>Anisotropic diffusion methods are formulated to reduce noise (or unwanted detail) in images while preserving specific image features. For many applications, there is an assumption that light-dark transitions (edges) are interesting. Standard isotropic diffusion methods move and blur light-dark boundaries. Anisotropic diffusion methods are formulated to specifically preserve edges.</p> \
@@ -103,14 +103,14 @@ AnisotropicDiffusion::AnisoDiffType AnisotropicDiffusion::getDiffusionType() {
 // --------------- apply -------------------
 Action::ApplyStatus AnisotropicDiffusion::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
 // --------------- process -------------------
-void AnisotropicDiffusion::process(ImageComponent * comp) {
+void AnisotropicDiffusion::process(ImageComponent* comp) {
     // Get the parameters
     this->keepOrgVoxelType = property("Keep original image voxel type").toBool();
     this->numberOfIterations = property("Number of iterations").toInt();

imaging/actions/itkfilters/AnisotropicDiffusion.h

@@ -51,7 +51,7 @@ public:
     enum AnisoDiffType {GRADIENT, CURVATURE};
 
     /// Default Constructor
-    AnisotropicDiffusion(camitk::ActionExtension * );
+    AnisotropicDiffusion(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~AnisotropicDiffusion();
@@ -74,7 +74,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);
 

imaging/actions/itkfilters/CannyEdgeDetection.cpp

@@ -45,7 +45,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-CannyEdgeDetection::CannyEdgeDetection(ActionExtension * extension) : Action(extension) {
+CannyEdgeDetection::CannyEdgeDetection(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Canny Edge Detection");
     setDescription("<br>The <b> <i>Canny edge detector</i> </b> is an edge detection operator that uses a multi-stage algorithm to detect a wide range of edges in images. <br> \n The filter steps are : \n  * Preprocessing noise reduction using a gaussian convolution filtering. \n  * Finding the intensity gradient of the image \n  * Non-maximum suppression \n  * Tracing edges through the image and hysteresis thresholding \n It was developed by John F. Canny in 1986. <i>(source: Wikipedia)</i>.<br> \n This filter is widely used for edge detection since it is the optimal solution satisfying the constraints of good sensitivity, localization and noise robustness. <i>(source: ITK Developer's Guide)</i>.<br>  ");
@@ -85,13 +85,13 @@ CannyEdgeDetection::~CannyEdgeDetection() {
 // --------------- apply -------------------
 Action::ApplyStatus CannyEdgeDetection::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void CannyEdgeDetection::process(ImageComponent * comp) {
+void CannyEdgeDetection::process(ImageComponent* comp) {
     // Get the parameters
     this->keepOrgVoxelType = property("Keep original voxel type?").toBool();
     this->variance = property("Variance").toDouble();

imaging/actions/itkfilters/CannyEdgeDetection.h

@@ -45,7 +45,7 @@ class ITKFILTER_API CannyEdgeDetection : public camitk::Action {
 
 public:
     /// Default Constructor
-    CannyEdgeDetection(camitk::ActionExtension *);
+    CannyEdgeDetection(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~CannyEdgeDetection();
@@ -60,7 +60,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 private:
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);

imaging/actions/itkfilters/ConnectedComponents.cpp

@@ -41,7 +41,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-ConnectedComponents::ConnectedComponents(ActionExtension * extension) : Action(extension) {
+ConnectedComponents::ConnectedComponents(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Connected Components Classification");
     setDescription("	Labels connected components of a binary image and order the labes with respect to the size of the connected components (i.e. the larges connected component has the label 1, the one a little smaller has the label 2, and so on...  ");
@@ -70,13 +70,13 @@ void ConnectedComponents::setNbConnectedComponents(const int nbConnectedComponen
 // --------------- apply -------------------
 Action::ApplyStatus ConnectedComponents::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void ConnectedComponents::process(ImageComponent * comp) {
+void ConnectedComponents::process(ImageComponent* comp) {
     // ITK filter implementation using templates
     vtkSmartPointer<vtkImageData> inputImage = comp->getImageData();
     vtkSmartPointer<vtkImageData> outputImage = implementProcess (inputImage);

imaging/actions/itkfilters/ConnectedComponents.h

@@ -49,7 +49,7 @@ class ITKFILTER_API ConnectedComponents : public camitk::Action {
 
 public:
     /// Default Constructor
-    ConnectedComponents(camitk::ActionExtension *);
+    ConnectedComponents(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~ConnectedComponents();
@@ -67,7 +67,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);
 

imaging/actions/itkfilters/Derivative.cpp

@@ -46,7 +46,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-Derivative::Derivative(ActionExtension * extension) : Action(extension) {
+Derivative::Derivative(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Partial Derivative");
     setDescription("<br><b>This filter is used for computing the <i>partial derivative</i> of an image.</b><br>\
@@ -99,13 +99,13 @@ Derivative::~Derivative() {
 // --------------- apply -------------------
 Action::ApplyStatus Derivative::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         this->process(input);
     }
     return SUCCESS;
 }
 
-void Derivative::process(ImageComponent * comp) {
+void Derivative::process(ImageComponent* comp) {
     // Get the parameters
     this->keepOrgVoxelType = property("Keep original voxel type?").toBool();
     this->order = property("Derivative order").toInt();

imaging/actions/itkfilters/Derivative.h

@@ -55,7 +55,7 @@ public:
     enum derivativeDirection { DIRECTION_X, DIRECTION_Y, DIRECTION_Z };
 
     /// Default Constructor
-    Derivative(camitk::ActionExtension *);
+    Derivative(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~Derivative();
@@ -70,7 +70,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 private:
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);

imaging/actions/itkfilters/GaussianFilter.cpp

@@ -46,7 +46,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-GaussianFilter::GaussianFilter(ActionExtension * extension) : Action(extension) {
+GaussianFilter::GaussianFilter(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Gaussian Filter");
     setDescription("<p>Blurring is the traditional apporach for removing noise from images. It is usually implemented in the form of a convolution with a kernel. One of the most commonly used kernels is the Gaussian.</p><p>The classical methode of smoothing an image by convolution with a Gaussian kernel has the drawback that it is slow when the standard deviation sigma of the Gaussian is large.</p><p>The Recursive IIR (Infinite Impulse Rewponse) implements an approximation of convolution with the Gaussian. In practice, this filter requires a constant number of operations for approximating the convolution, regardless of the sigma value.</p>");
@@ -93,13 +93,13 @@ GaussianFilter::GaussianType GaussianFilter::getType() {
 // --------------- apply -------------------
 Action::ApplyStatus GaussianFilter::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void GaussianFilter::process(ImageComponent * comp) {
+void GaussianFilter::process(ImageComponent* comp) {
     // Get the parameters
     this->variance = property("Variance").toDouble();
 

imaging/actions/itkfilters/GaussianFilter.h

@@ -52,7 +52,7 @@ public:
     enum GaussianType {STANDARD, RECURSIVE_IIR };
 
     /// Default Constructor
-    GaussianFilter(camitk::ActionExtension *);
+    GaussianFilter(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~GaussianFilter();
@@ -73,7 +73,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);

imaging/actions/itkfilters/GradientMagnitude.cpp

@@ -37,7 +37,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-GradientMagnitude::GradientMagnitude(ActionExtension * extension) : Action(extension) {
+GradientMagnitude::GradientMagnitude(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Gradient Magnitude");
     setDescription("<br>The <i>magnitude of the image gradient</i> is extensively used in image analysis, mainly to help in the determination of object contours and the separation of homogeneous regions. <br> \
@@ -59,13 +59,13 @@ GradientMagnitude::~GradientMagnitude() {
 // --------------- apply -------------------
 Action::ApplyStatus GradientMagnitude::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void GradientMagnitude::process(ImageComponent * comp) {
+void GradientMagnitude::process(ImageComponent* comp) {
     // ITK filter implementation using templates
     vtkSmartPointer<vtkImageData> inputImage = comp->getImageData();
     vtkSmartPointer<vtkImageData> outputImage = implementProcess (inputImage);

imaging/actions/itkfilters/GradientMagnitude.h

@@ -45,7 +45,7 @@ class ITKFILTER_API GradientMagnitude : public camitk::Action {
 
 public:
     /// Default Constructor
-    GradientMagnitude(camitk::ActionExtension *);
+    GradientMagnitude(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~GradientMagnitude();
@@ -60,7 +60,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 private:
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);

imaging/actions/itkfilters/GradientMagnitudeRecursiveGaussian.cpp

@@ -44,7 +44,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-GradientMagnitudeRecursiveGaussian::GradientMagnitudeRecursiveGaussian(ActionExtension * extension) : Action(extension) {
+GradientMagnitudeRecursiveGaussian::GradientMagnitudeRecursiveGaussian(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Gradient Magnitude With Smoothing");
     setDescription("<br>Differentiation is an ill-defined operation over digital data.<br> \
@@ -80,13 +80,13 @@ GradientMagnitudeRecursiveGaussian::~GradientMagnitudeRecursiveGaussian() {
 // --------------- apply -------------------
 Action::ApplyStatus GradientMagnitudeRecursiveGaussian::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void GradientMagnitudeRecursiveGaussian::process(ImageComponent * comp) {
+void GradientMagnitudeRecursiveGaussian::process(ImageComponent* comp) {
     // Get the parameters
     sigma = property("Standard deviation").toDouble();
 

imaging/actions/itkfilters/GradientMagnitudeRecursiveGaussian.h

@@ -45,7 +45,7 @@ class ITKFILTER_API GradientMagnitudeRecursiveGaussian : public camitk::Action {
 
 public:
     /// Default Constructor
-    GradientMagnitudeRecursiveGaussian(camitk::ActionExtension *);
+    GradientMagnitudeRecursiveGaussian(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~GradientMagnitudeRecursiveGaussian();
@@ -60,7 +60,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 private:
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);

imaging/actions/itkfilters/Laplacian.cpp

@@ -45,7 +45,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-Laplacian::Laplacian(ActionExtension * extension) : Action(extension) {
+Laplacian::Laplacian(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Laplacian Filter");
     setDescription("<br/>This filter computes the <b>Laplacian of a scalar-valued image</b>.<br/><br/> \
@@ -74,13 +74,13 @@ Laplacian::~Laplacian() {
 // --------------- apply -------------------
 Action::ApplyStatus Laplacian::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void Laplacian::process(ImageComponent * comp) {
+void Laplacian::process(ImageComponent* comp) {
     // Get the parameters
     this->keepOrgVoxelType = property("Keep original voxel type?").toBool();
 

imaging/actions/itkfilters/Laplacian.h

@@ -46,7 +46,7 @@ class ITKFILTER_API Laplacian : public camitk::Action {
 
 public:
     /// Default Constructor
-    Laplacian(camitk::ActionExtension *);
+    Laplacian(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~Laplacian();
@@ -61,7 +61,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 private:
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);

imaging/actions/itkfilters/LaplacianRecursiveGaussian.cpp

@@ -43,7 +43,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-LaplacianRecursiveGaussian::LaplacianRecursiveGaussian(ActionExtension * extension) : Action(extension) {
+LaplacianRecursiveGaussian::LaplacianRecursiveGaussian(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Laplacian Filter With Smoothing");
     setDescription("<br/>Computes the <b>Laplacian of Gaussian (LoG)</b> of an image by convolution with the second derivative of a Gaussian.<br/><br/> This filter is implemented using the recursive gaussian filters.");
@@ -77,13 +77,13 @@ LaplacianRecursiveGaussian::~LaplacianRecursiveGaussian() {
 // --------------- apply -------------------
 Action::ApplyStatus LaplacianRecursiveGaussian::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void LaplacianRecursiveGaussian::process(ImageComponent * comp) {
+void LaplacianRecursiveGaussian::process(ImageComponent* comp) {
     // Get the parameters
     this->keepOrgVoxelType = property("Keep original voxel type?").toBool();
     this->sigma = property("Standard deviation").toDouble();

imaging/actions/itkfilters/LaplacianRecursiveGaussian.h

@@ -45,7 +45,7 @@ class ITKFILTER_API LaplacianRecursiveGaussian : public camitk::Action {
 
 public:
     /// Default Constructor
-    LaplacianRecursiveGaussian(camitk::ActionExtension *);
+    LaplacianRecursiveGaussian(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~LaplacianRecursiveGaussian();
@@ -60,7 +60,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 private:
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);

imaging/actions/itkfilters/LaplacianSharpening.cpp

@@ -37,7 +37,7 @@ using namespace camitk;
 
 
 // --------------- constructor -------------------
-LaplacianSharpening::LaplacianSharpening(ActionExtension * extension) : Action(extension) {
+LaplacianSharpening::LaplacianSharpening(ActionExtension* extension) : Action(extension) {
     // Setting name, description and input component
     setName("Laplacian Sharpening");
     setDescription("<br>This filter <b> <i>sharpens an image using a Laplacian filter</i> </b>.<br> \
@@ -63,13 +63,13 @@ LaplacianSharpening::~LaplacianSharpening() {
 // --------------- apply -------------------
 Action::ApplyStatus LaplacianSharpening::apply() {
     foreach (Component * comp, getTargets()) {
-        ImageComponent * input = dynamic_cast<ImageComponent *> ( comp );
+        ImageComponent* input = dynamic_cast<ImageComponent*> ( comp );
         process(input);
     }
     return SUCCESS;
 }
 
-void LaplacianSharpening::process(ImageComponent * comp) {
+void LaplacianSharpening::process(ImageComponent* comp) {
     // ITK filter implementation using templates
     vtkSmartPointer<vtkImageData> inputImage = comp->getImageData();
     vtkSmartPointer<vtkImageData> outputImage = implementProcess (inputImage);

imaging/actions/itkfilters/LaplacianSharpening.h

@@ -45,7 +45,7 @@ class ITKFILTER_API LaplacianSharpening : public camitk::Action {
 
 public:
     /// Default Constructor
-    LaplacianSharpening(camitk::ActionExtension *);
+    LaplacianSharpening(camitk::ActionExtension*);
 
     /// Default Destructor
     virtual ~LaplacianSharpening();
@@ -60,7 +60,7 @@ public slots:
 
 private:
     /// helper method to simplify the target component processing
-    virtual void process(camitk::ImageComponent *);
+    virtual void process(camitk::ImageComponent*);
 
 private:
     vtkSmartPointer<vtkImageData> implementProcess(vtkSmartPointer<vtkImageData> img);