Commit 14eea6e3 authored by Ken Martin's avatar Ken Martin

removed statics

parent 0158140a
......@@ -21,7 +21,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageHSVToRGB, "1.24");
vtkCxxRevisionMacro(vtkImageHSVToRGB, "1.25");
vtkStandardNewMacro(vtkImageHSVToRGB);
//----------------------------------------------------------------------------
......@@ -34,10 +34,10 @@ vtkImageHSVToRGB::vtkImageHSVToRGB()
//----------------------------------------------------------------------------
// This templated function executes the filter for any type of data.
template <class T>
static void vtkImageHSVToRGBExecute(vtkImageHSVToRGB *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageHSVToRGBExecute(vtkImageHSVToRGB *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt(inData, outExt);
vtkImageProgressIterator<T> outIt(outData, outExt, self, id);
......
......@@ -18,7 +18,7 @@
#include "vtkImageIslandRemoval2D.h"
#include "vtkObjectFactory.h"
vtkCxxRevisionMacro(vtkImageIslandRemoval2D, "1.39");
vtkCxxRevisionMacro(vtkImageIslandRemoval2D, "1.40");
vtkStandardNewMacro(vtkImageIslandRemoval2D);
//----------------------------------------------------------------------------
......@@ -64,10 +64,10 @@ void vtkImageIslandRemoval2D::PrintSelf(ostream& os, vtkIndent indent)
// neighborhoods is to check neighbors one by one directly. Also, I did
// not want to break the templated function into pieces.
template <class T>
static void vtkImageIslandRemoval2DExecute(vtkImageIslandRemoval2D *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6])
void vtkImageIslandRemoval2DExecute(vtkImageIslandRemoval2D *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6])
{
int outIdx0, outIdx1, outIdx2;
int outInc0, outInc1, outInc2;
......
......@@ -20,7 +20,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageLaplacian, "1.24");
vtkCxxRevisionMacro(vtkImageLaplacian, "1.25");
vtkStandardNewMacro(vtkImageLaplacian);
//----------------------------------------------------------------------------
......@@ -81,10 +81,10 @@ void vtkImageLaplacian::ComputeInputUpdateExtent(int inExt[6],
// it handles boundaries. Pixels are just replicated to get values
// out of extent.
template <class T>
static void vtkImageLaplacianExecute(vtkImageLaplacian *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
void vtkImageLaplacianExecute(vtkImageLaplacian *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
{
int idxC, idxX, idxY, idxZ;
int maxC, maxX, maxY, maxZ;
......
......@@ -21,7 +21,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageLogarithmicScale, "1.20");
vtkCxxRevisionMacro(vtkImageLogarithmicScale, "1.21");
vtkStandardNewMacro(vtkImageLogarithmicScale);
//----------------------------------------------------------------------------
......@@ -34,10 +34,10 @@ vtkImageLogarithmicScale::vtkImageLogarithmicScale()
//----------------------------------------------------------------------------
// This templated function executes the filter for any type of data.
template <class T>
static void vtkImageLogarithmicScaleExecute(vtkImageLogarithmicScale *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageLogarithmicScaleExecute(vtkImageLogarithmicScale *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt(inData, outExt);
vtkImageProgressIterator<T> outIt(outData, outExt, self, id);
......
......@@ -20,7 +20,7 @@
#include "vtkObjectFactory.h"
#include "vtkImageProgressIterator.h"
vtkCxxRevisionMacro(vtkImageLogic, "1.26");
vtkCxxRevisionMacro(vtkImageLogic, "1.27");
vtkStandardNewMacro(vtkImageLogic);
//----------------------------------------------------------------------------
......@@ -36,10 +36,8 @@ vtkImageLogic::vtkImageLogic()
// This templated function executes the filter for any type of data.
// Handles the one input operations
template <class T>
static void vtkImageLogicExecute1(vtkImageLogic *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageLogicExecute1(vtkImageLogic *self, vtkImageData *inData,
vtkImageData *outData, int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt(inData, outExt);
vtkImageProgressIterator<T> outIt(outData, outExt, self, id);
......@@ -96,11 +94,9 @@ static void vtkImageLogicExecute1(vtkImageLogic *self,
// This templated function executes the filter for any type of data.
// Handles the two input operations
template <class T>
static void vtkImageLogicExecute2(vtkImageLogic *self,
vtkImageData *in1Data,
vtkImageData *in2Data,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageLogicExecute2(vtkImageLogic *self, vtkImageData *in1Data,
vtkImageData *in2Data, vtkImageData *outData,
int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt1(in1Data, outExt);
vtkImageIterator<T> inIt2(in2Data, outExt);
......
......@@ -21,7 +21,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageLuminance, "1.19");
vtkCxxRevisionMacro(vtkImageLuminance, "1.20");
vtkStandardNewMacro(vtkImageLuminance);
//----------------------------------------------------------------------------
......@@ -37,10 +37,9 @@ void vtkImageLuminance::ExecuteInformation(vtkImageData *vtkNotUsed(inData),
// it handles boundaries. Pixels are just replicated to get values
// out of extent.
template <class T>
static void vtkImageLuminanceExecute(vtkImageLuminance *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageLuminanceExecute(vtkImageLuminance *self, vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt(inData, outExt);
vtkImageProgressIterator<T> outIt(outData, outExt, self, id);
......
......@@ -21,7 +21,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageMagnitude, "1.32");
vtkCxxRevisionMacro(vtkImageMagnitude, "1.33");
vtkStandardNewMacro(vtkImageMagnitude);
//----------------------------------------------------------------------------
......@@ -37,10 +37,10 @@ void vtkImageMagnitude::ExecuteInformation(vtkImageData *vtkNotUsed(inData),
// it handles boundaries. Pixels are just replicated to get values
// out of extent.
template <class T>
static void vtkImageMagnitudeExecute(vtkImageMagnitude *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageMagnitudeExecute(vtkImageMagnitude *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt(inData, outExt);
vtkImageProgressIterator<T> outIt(outData, outExt, self, id);
......
......@@ -18,7 +18,7 @@
#include "vtkImageMapToWindowLevelColors.h"
#include "vtkObjectFactory.h"
vtkCxxRevisionMacro(vtkImageMapToWindowLevelColors, "1.11");
vtkCxxRevisionMacro(vtkImageMapToWindowLevelColors, "1.12");
vtkStandardNewMacro(vtkImageMapToWindowLevelColors);
// Constructor sets default values
......@@ -125,10 +125,10 @@ void vtkImageMapToWindowLevelColors::ExecuteInformation(vtkImageData *inData,
* for a window of values of type T, lower and upper.
*/
template <class T>
static void vtkImageMapToWindowLevelClamps ( vtkImageData *data, float w,
float l, T& lower, T& upper,
unsigned char &lower_val,
unsigned char &upper_val)
void vtkImageMapToWindowLevelClamps ( vtkImageData *data, float w,
float l, T& lower, T& upper,
unsigned char &lower_val,
unsigned char &upper_val)
{
double f_lower, f_upper, f_lower_val, f_upper_val;
double adjustedLower, adjustedUpper;
......@@ -222,11 +222,12 @@ static void vtkImageMapToWindowLevelClamps ( vtkImageData *data, float w,
//----------------------------------------------------------------------------
// This non-templated function executes the filter for any type of data.
template <class T>
static void vtkImageMapToWindowLevelColorsExecute(vtkImageMapToWindowLevelColors *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData,
unsigned char *outPtr,
int outExt[6], int id)
void vtkImageMapToWindowLevelColorsExecute(
vtkImageMapToWindowLevelColors *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData,
unsigned char *outPtr,
int outExt[6], int id)
{
int idxX, idxY, idxZ;
int extX, extY, extZ;
......
......@@ -18,7 +18,7 @@
#include "vtkImageMask.h"
#include "vtkObjectFactory.h"
vtkCxxRevisionMacro(vtkImageMask, "1.29");
vtkCxxRevisionMacro(vtkImageMask, "1.30");
vtkStandardNewMacro(vtkImageMask);
//----------------------------------------------------------------------------
......@@ -75,10 +75,10 @@ void vtkImageMask::SetMaskedOutputValue(int num, float *v)
//----------------------------------------------------------------------------
// This templated function executes the filter for any type of data.
template <class T>
static void vtkImageMaskExecute(vtkImageMask *self, int ext[6],
vtkImageData *in1Data, T *in1Ptr,
vtkImageData *in2Data, unsigned char *in2Ptr,
vtkImageData *outData, T *outPtr, int id)
void vtkImageMaskExecute(vtkImageMask *self, int ext[6],
vtkImageData *in1Data, T *in1Ptr,
vtkImageData *in2Data, unsigned char *in2Ptr,
vtkImageData *outData, T *outPtr, int id)
{
int num0, num1, num2, numC, pixSize;
int idx0, idx1, idx2, idxC;
......
......@@ -21,7 +21,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageMaskBits, "1.13");
vtkCxxRevisionMacro(vtkImageMaskBits, "1.14");
vtkStandardNewMacro(vtkImageMaskBits);
vtkImageMaskBits::vtkImageMaskBits()
......@@ -40,10 +40,10 @@ vtkImageMaskBits::vtkImageMaskBits()
// it handles boundaries. Pixels are just replicated to get values
// out of extent.
template <class T>
static void vtkImageMaskBitsExecute(vtkImageMaskBits *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageMaskBitsExecute(vtkImageMaskBits *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt(inData, outExt);
vtkImageProgressIterator<T> outIt(outData, outExt, self, id);
......
......@@ -21,7 +21,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageMathematics, "1.41");
vtkCxxRevisionMacro(vtkImageMathematics, "1.42");
vtkStandardNewMacro(vtkImageMathematics);
//----------------------------------------------------------------------------
......@@ -68,7 +68,7 @@ void vtkImageMathematics::ExecuteInformation(vtkImageData **inDatas,
}
template <class TValue, class TIvar>
static void vtkImageMathematicsClamp(TValue &value, TIvar ivar, vtkImageData *data)
void vtkImageMathematicsClamp(TValue &value, TIvar ivar, vtkImageData *data)
{
if (ivar < (TIvar) data->GetScalarTypeMin())
{
......@@ -88,10 +88,10 @@ static void vtkImageMathematicsClamp(TValue &value, TIvar ivar, vtkImageData *da
// This templated function executes the filter for any type of data.
// Handles the one input operations
template <class T>
static void vtkImageMathematicsExecute1(vtkImageMathematics *self,
vtkImageData *in1Data, T *in1Ptr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
void vtkImageMathematicsExecute1(vtkImageMathematics *self,
vtkImageData *in1Data, T *in1Ptr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
{
int idxR, idxY, idxZ;
int maxY, maxZ;
......@@ -219,11 +219,11 @@ static void vtkImageMathematicsExecute1(vtkImageMathematics *self,
// This templated function executes the filter for any type of data.
// Handles the two input operations
template <class T>
static void vtkImageMathematicsExecute2(vtkImageMathematics *self,
vtkImageData *in1Data, T *in1Ptr,
vtkImageData *in2Data, T *in2Ptr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
void vtkImageMathematicsExecute2(vtkImageMathematics *self,
vtkImageData *in1Data, T *in1Ptr,
vtkImageData *in2Data, T *in2Ptr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
{
int idxR, idxY, idxZ;
int maxY, maxZ;
......
......@@ -18,7 +18,7 @@
#include "vtkImageMedian3D.h"
#include "vtkObjectFactory.h"
vtkCxxRevisionMacro(vtkImageMedian3D, "1.28");
vtkCxxRevisionMacro(vtkImageMedian3D, "1.29");
vtkStandardNewMacro(vtkImageMedian3D);
//----------------------------------------------------------------------------
......@@ -175,10 +175,10 @@ double *vtkImageMedian3DAccumulateMedian(int &UpNum, int &DownNum,
// This method contains the second switch statement that calls the correct
// templated function for the mask types.
template <class T>
static void vtkImageMedian3DExecute(vtkImageMedian3D *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
void vtkImageMedian3DExecute(vtkImageMedian3D *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
{
int *kernelMiddle, *kernelSize;
int NumberOfElements;
......
......@@ -18,7 +18,7 @@
#include "vtkImageMirrorPad.h"
#include "vtkObjectFactory.h"
vtkCxxRevisionMacro(vtkImageMirrorPad, "1.28");
vtkCxxRevisionMacro(vtkImageMirrorPad, "1.29");
vtkStandardNewMacro(vtkImageMirrorPad);
//----------------------------------------------------------------------------
......@@ -49,10 +49,10 @@ void vtkImageMirrorPad::ComputeInputUpdateExtent(int inExt[6],
//----------------------------------------------------------------------------
template <class T>
static void vtkImageMirrorPadExecute(vtkImageMirrorPad *self,
vtkImageData *inData,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
void vtkImageMirrorPadExecute(vtkImageMirrorPad *self,
vtkImageData *inData,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
{
int idxC, idxX, idxY, idxZ;
int maxX, maxY, maxZ;
......
......@@ -20,7 +20,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageNonMaximumSuppression, "1.44");
vtkCxxRevisionMacro(vtkImageNonMaximumSuppression, "1.45");
vtkStandardNewMacro(vtkImageNonMaximumSuppression);
//----------------------------------------------------------------------------
......@@ -98,14 +98,13 @@ void vtkImageNonMaximumSuppression::ComputeInputUpdateExtent(int inExt[6],
// This templated function executes the filter for any type of data.
// Handles the two input operations
template <class T>
static void vtkImageNonMaximumSuppressionExecute(vtkImageNonMaximumSuppression *self,
vtkImageData *in1Data,
T *in1Ptr,
vtkImageData *in2Data,
T *in2Ptr,
vtkImageData *outData,
T *outPtr,
int outExt[6], int id)
void vtkImageNonMaximumSuppressionExecute(vtkImageNonMaximumSuppression *self,
vtkImageData *in1Data, T *in1Ptr,
vtkImageData *in2Data,
T *in2Ptr,
vtkImageData *outData,
T *outPtr,
int outExt[6], int id)
{
int idxC, idxX, idxY, idxZ;
int maxC, maxX, maxY, maxZ;
......
......@@ -21,7 +21,7 @@
#include <math.h>
vtkCxxRevisionMacro(vtkImageNormalize, "1.10");
vtkCxxRevisionMacro(vtkImageNormalize, "1.11");
vtkStandardNewMacro(vtkImageNormalize);
//----------------------------------------------------------------------------
......@@ -37,10 +37,10 @@ void vtkImageNormalize::ExecuteInformation(vtkImageData *vtkNotUsed(inData),
// it handles boundaries. Pixels are just replicated to get values
// out of extent.
template <class T>
static void vtkImageNormalizeExecute(vtkImageNormalize *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
void vtkImageNormalizeExecute(vtkImageNormalize *self,
vtkImageData *inData,
vtkImageData *outData,
int outExt[6], int id, T *)
{
vtkImageIterator<T> inIt(inData, outExt);
vtkImageProgressIterator<float> outIt(outData, outExt, self, id);
......
......@@ -18,7 +18,7 @@
#include "vtkImagePermute.h"
#include "vtkObjectFactory.h"
vtkCxxRevisionMacro(vtkImagePermute, "1.29");
vtkCxxRevisionMacro(vtkImagePermute, "1.30");
vtkStandardNewMacro(vtkImagePermute);
//----------------------------------------------------------------------------
......@@ -78,10 +78,10 @@ void vtkImagePermute::ComputeInputUpdateExtent(int inExt[6],
//----------------------------------------------------------------------------
// This templated function executes the filter for any type of data.
template <class T>
static void vtkImagePermuteExecute(vtkImagePermute *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
void vtkImagePermuteExecute(vtkImagePermute *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData, T *outPtr,
int outExt[6], int id)
{
int idxX, idxY, idxZ, idxC;
int maxX, maxY, maxZ;
......
......@@ -22,7 +22,7 @@
#include <math.h>
#include <stdlib.h>
vtkCxxRevisionMacro(vtkImageQuantizeRGBToIndex, "1.31");
vtkCxxRevisionMacro(vtkImageQuantizeRGBToIndex, "1.32");
vtkStandardNewMacro(vtkImageQuantizeRGBToIndex);
class vtkColorQuantizeNode
......@@ -132,12 +132,9 @@ protected:
};
template <class T>
static void vtkImageQuantizeRGBToIndexHistogram( T *inPtr,
int extent[6],
int inIncrement[3],
int type,
int bounds[6],
int *histogram[3] )
void vtkImageQuantizeRGBToIndexHistogram( T *inPtr, int extent[6],
int inIncrement[3], int type,
int bounds[6], int *histogram[3] )
{
T *rgbPtr, v[3];
int x, y, z, c;
......@@ -210,10 +207,10 @@ static void vtkImageQuantizeRGBToIndexHistogram( T *inPtr,
// This templated function executes the filter for supported types of data.
template <class T>
static void vtkImageQuantizeRGBToIndexExecute(vtkImageQuantizeRGBToIndex *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData,
unsigned short *outPtr)
void vtkImageQuantizeRGBToIndexExecute(vtkImageQuantizeRGBToIndex *self,
vtkImageData *inData, T *inPtr,
vtkImageData *outData,
unsigned short *outPtr)
{
int extent[6];
int inIncrement[3], outIncrement[3];
......
This diff is collapsed.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment