SoItkBSplineResampleImageFilterBase::SoItkBSplineResampleImageFilterBase()
{
SO_ENGINE_CONSTRUCTOR( SoItkBSplineResampleImageFilterBase );
// Inputs
SO_ENGINE_ADD_INPUT( SplineOrder, (1) );
}
SoVtkGenericInterpolatedVelocityField::SoVtkGenericInterpolatedVelocityField()
{
SO_ENGINE_CONSTRUCTOR(SoVtkGenericInterpolatedVelocityField);
mObject = vtkGenericInterpolatedVelocityField::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkGenericInterpolatedVelocityField *aGenericInterpolatedVelocityField = vtkGenericInterpolatedVelocityField::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(Caching, (0));
Caching.setValue(aGenericInterpolatedVelocityField->GetCaching());
aGenericInterpolatedVelocityField->Delete();
SO_ENGINE_ADD_OUTPUT( oLastCell, SoSFVtkObject );
mLastCell = 0;
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
addCalled = 0;
}
SoVtkPlane::SoVtkPlane()
{
SO_ENGINE_CONSTRUCTOR(SoVtkPlane);
mObject = vtkPlane::New();
mObject->Register(0);mObject->SetGlobalWarningDisplay(0);
vtkPlane *aPlane = vtkPlane::New();
double *x;
SO_ENGINE_ADD_INPUT(Transform, (0));
SO_ENGINE_ADD_INPUT(Origin, (0,0,0));
x= aPlane->GetOrigin();
Origin.setValue(x[0],x[1],x[2]);
SO_ENGINE_ADD_INPUT(Normal, (0,0,0));
x= aPlane->GetNormal();
Normal.setValue(x[0],x[1],x[2]);
aPlane->Delete();
SO_ENGINE_ADD_OUTPUT(Output, SoSFVtkObject );
mOutput = 0;
}
SoItkExpNegativeImageFilter::SoItkExpNegativeImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkExpNegativeImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( Factor, (1.0) );
}
SoVtkImageLuminance::SoVtkImageLuminance()
{
SO_ENGINE_CONSTRUCTOR(SoVtkImageLuminance);
mObject = vtkImageLuminance::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkImageLuminance *aImageLuminance = vtkImageLuminance::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(NumberOfThreads, (0));
NumberOfThreads.setValue(aImageLuminance->GetNumberOfThreads());
SO_ENGINE_ADD_INPUT(InputConnection, (0));
aImageLuminance->Delete();
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
mOutputPort = 0;
addCalled = 0;
}
SoItkInPlaceImageFilter::SoItkInPlaceImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkInPlaceImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( InPlace, (0) );
}
SoItkImageFileReader::SoItkImageFileReader()
{
SO_ENGINE_CONSTRUCTOR( SoItkImageFileReader );
// Enumerations
SO_ENGINE_DEFINE_ENUM_VALUE( DataType, FLOAT );
SO_ENGINE_DEFINE_ENUM_VALUE( DataType, UNSIGNED_SHORT );
SO_ENGINE_DEFINE_ENUM_VALUE( DataType, SHORT );
SO_ENGINE_DEFINE_ENUM_VALUE( DataType, UNSIGNED_CHAR );
SO_ENGINE_DEFINE_ENUM_VALUE( DimensionEnum, TWO );
SO_ENGINE_DEFINE_ENUM_VALUE( DimensionEnum, THREE );
SO_ENGINE_DEFINE_ENUM_VALUE( ComponentLayoutType, LUMINANCE );
SO_ENGINE_DEFINE_ENUM_VALUE( ComponentLayoutType, RGB );
SO_ENGINE_DEFINE_ENUM_VALUE( ComponentLayoutType, RGBA );
// Define input fields and their default values
SO_ENGINE_SET_SF_ENUM_TYPE( Type, DataType );
SO_ENGINE_SET_SF_ENUM_TYPE( Dimension, DimensionEnum );
SO_ENGINE_SET_SF_ENUM_TYPE( ComponentLayout, ComponentLayoutType );
SO_ENGINE_ADD_INPUT( File, ("") );
SO_ENGINE_ADD_INPUT( Type, (FLOAT) );
SO_ENGINE_ADD_INPUT( Dimension, (TWO) );
SO_ENGINE_ADD_INPUT( ComponentLayout, (LUMINANCE) );
// Outputs
SO_ENGINE_ADD_OUTPUT( Output, SoItkSFDataImage );
SO_ENGINE_ADD_OUTPUT( Dimensions, SoMFShort );
mOutput = 0;
}
SoVtkImageToStructuredPoints::SoVtkImageToStructuredPoints()
{
SO_ENGINE_CONSTRUCTOR(SoVtkImageToStructuredPoints);
mObject = vtkImageToStructuredPoints::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkImageToStructuredPoints *aImageToStructuredPoints = vtkImageToStructuredPoints::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(VectorInput, (0));
SO_ENGINE_ADD_INPUT(InputConnection, (0));
aImageToStructuredPoints->Delete();
SO_ENGINE_ADD_OUTPUT( oVectorInput, SoSFVtkObject );
mVectorInput = 0;
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
mOutputPort = 0;
addCalled = 0;
}
SoMVTVolumeCalculator::SoMVTVolumeCalculator(void)
{
SO_ENGINE_CONSTRUCTOR( SoMVTVolumeCalculator );
// Enumerations
SO_ENGINE_DEFINE_ENUM_VALUE( DataType, UNSIGNED_SHORT );
SO_ENGINE_DEFINE_ENUM_VALUE( DataType, UNSIGNED_CHAR );
SO_ENGINE_SET_SF_ENUM_TYPE( Type, DataType );
// Inputs
SO_ENGINE_ADD_INPUT( inputVolume, (0) );
SO_ENGINE_ADD_INPUT( refVolume, (0) );
SO_ENGINE_ADD_INPUT( process, () );
// Outputs
SO_ENGINE_ADD_OUTPUT( volumeSeg, SoSFFloat );
SO_ENGINE_ADD_OUTPUT( volumeRef, SoSFFloat );
SO_ENGINE_ADD_OUTPUT( volumeDif, SoSFFloat );
SO_ENGINE_ADD_OUTPUT( volumeDifPerc, SoSFFloat );
SO_ENGINE_ADD_OUTPUT( volumeDifPercAbs, SoSFFloat );
SO_ENGINE_ADD_OUTPUT( tanimotoError, SoSFFloat );
volumeFactor = 1.0;
_volumeSeg = 0.0;
_volumeRef = 0.0;
_volumeDif = 0.0;
_volumeDifPerc = 0.0;
_volumeDifPercAbs = 0.0;
_tanimotoError = 0.0;
}
SoItkNaryFunctorImageFilter::SoItkNaryFunctorImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkNaryFunctorImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( Input1, (0) );
}
SoVtkImageExport::SoVtkImageExport()
{
SO_ENGINE_CONSTRUCTOR(SoVtkImageExport);
mObject = vtkImageExport::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkImageExport *aImageExport = vtkImageExport::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(ImageLowerLeft, (0));
ImageLowerLeft.setValue(aImageExport->GetImageLowerLeft());
SO_ENGINE_ADD_INPUT(InputConnection, (0));
aImageExport->Delete();
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
mOutputPort = 0;
addCalled = 0;
}
SoVtkExtractUnstructuredGridPiece::SoVtkExtractUnstructuredGridPiece()
{
SO_ENGINE_CONSTRUCTOR(SoVtkExtractUnstructuredGridPiece);
mObject = vtkExtractUnstructuredGridPiece::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkExtractUnstructuredGridPiece *aExtractUnstructuredGridPiece = vtkExtractUnstructuredGridPiece::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(CreateGhostCells, (0));
CreateGhostCells.setValue(aExtractUnstructuredGridPiece->GetCreateGhostCells());
SO_ENGINE_ADD_INPUT(InputConnection, (0));
aExtractUnstructuredGridPiece->Delete();
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
mOutputPort = 0;
addCalled = 0;
}
SoItkImageToImageMetric::SoItkImageToImageMetric()
{
SO_ENGINE_CONSTRUCTOR( SoItkImageToImageMetric );
SO_ENGINE_DEFINE_ENUM_VALUE( PixelTypeEnum, UNSIGNED_SHORT );
SO_ENGINE_DEFINE_ENUM_VALUE( PixelTypeEnum, FLOAT );
SO_ENGINE_SET_SF_ENUM_TYPE( PixelType, PixelTypeEnum );
SO_ENGINE_ADD_INPUT( PixelType, (FLOAT) );
SO_ENGINE_ADD_INPUT( Dimension, (2) );
// SO_ENGINE_ADD_INPUT( FixedImage, (0) );
// SO_ENGINE_ADD_INPUT( MovingImage, (0) );
// SO_ENGINE_ADD_INPUT( Transform, (0) );
// SO_ENGINE_ADD_INPUT( Interpolator, (0) );
// SO_ENGINE_ADD_INPUT( FixedImageRegionOrigin, (0, 0, 0) );
// SO_ENGINE_ADD_INPUT( FixedImageRegionSize, (0, 0, 0) );
// SO_ENGINE_ADD_INPUT( TransformParameters, (0) );
// TransformParameters.setNum(0);
// SO_ENGINE_ADD_INPUT( ComputeGradient, (FALSE) );
// SO_ENGINE_ADD_OUTPUT( NumberOfPixelsCounted, SoSFFloat );
// SO_ENGINE_ADD_OUTPUT( NumberOfParameters, SoSFFloat );
// SO_ENGINE_ADD_OUTPUT( GradientImage, SoItkSFDataImage );
mGradientImage = 0;
SO_ENGINE_ADD_OUTPUT( Output, SoItkSFDataImageMetric );
mOutput = 0;
}
SoVtkFieldData::SoVtkFieldData()
{
SO_ENGINE_CONSTRUCTOR(SoVtkFieldData);
mObject = vtkFieldData::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkFieldData *aFieldData = vtkFieldData::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(Component, ());
Component.setFormat("const vtkIdType const int const double");
aFieldData->Delete();
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
addCalled = 0;
}
SoXipLoadDicom::SoXipLoadDicom()
{
SO_ENGINE_CONSTRUCTOR(SoXipLoadDicom);
SO_ENGINE_ADD_INPUT(name, (""));
SO_ENGINE_ADD_OUTPUT(dicom, SoXipMFDataDicom);
}
SoVtkOutlineFilter::SoVtkOutlineFilter()
{
SO_ENGINE_CONSTRUCTOR(SoVtkOutlineFilter);
mObject = vtkOutlineFilter::New();
mObject->Register(0);mObject->SetGlobalWarningDisplay(0);
mObject->SetGlobalWarningDisplay(0);
vtkOutlineFilter *aOutlineFilter = vtkOutlineFilter::New();
SO_ENGINE_ADD_INPUT(Input, (0));
SO_ENGINE_ADD_INPUT(InputArrayToProcess, ());
InputArrayToProcess.setFormat("int int int int char*");
SO_ENGINE_ADD_INPUT(InputConnection, (0));
aOutlineFilter->Delete();
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
mOutputPort = 0;
}
SoItkFunctionBase::SoItkFunctionBase()
{
SO_ENGINE_CONSTRUCTOR( SoItkFunctionBase );
SO_ENGINE_ADD_OUTPUT( Output, SoItkSFDataInterpolator );
mOutput = 0;
}
SoSpring::SoSpring()
{
SO_ENGINE_CONSTRUCTOR(SoSpring);
SO_ENGINE_ADD_INPUT(startpos,(-5,0,0));
SO_ENGINE_ADD_INPUT(endpos,(0,0,0));
SO_ENGINE_ADD_INPUT(mass,(1.0f));
SO_ENGINE_ADD_INPUT(vel,(0,0,0));
SO_ENGINE_ADD_INPUT(acc,(0,0,0));
SO_ENGINE_ADD_INPUT(stiffness,(250.0f));
SO_ENGINE_ADD_INPUT(damp,(0.5f));
SO_ENGINE_ADD_INPUT(timeStep,(0.002f));
SO_ENGINE_ADD_INPUT(trigger,());
SO_ENGINE_ADD_INPUT(treshold,(0.01f));
SO_ENGINE_ADD_OUTPUT(posout, SoSFVec3f);
evaluate();
// This timer will be used to update the system once it is been triggered
timer=new SoTimerSensor(timerFunc,this);
}
SoItkCurvatureFlowImageFilter::SoItkCurvatureFlowImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkCurvatureFlowImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( TimeStep, (0.05f) );
}
SoOneShot::SoOneShot()
//
////////////////////////////////////////////////////////////////////////
{
SO_ENGINE_CONSTRUCTOR(SoOneShot);
SO_ENGINE_ADD_INPUT(duration, (1.0));
SO_ENGINE_ADD_INPUT(trigger, ());
SO_ENGINE_ADD_INPUT(flags, (0));
SO_ENGINE_ADD_INPUT(disable, (0));
SO_ENGINE_ADD_INPUT(timeIn, (SbTime::zero()));
SO_ENGINE_ADD_OUTPUT(timeOut, SoSFTime);
SO_ENGINE_ADD_OUTPUT(isActive, SoSFBool);
SO_ENGINE_ADD_OUTPUT(ramp, SoSFFloat);
SO_ENGINE_DEFINE_ENUM_VALUE(Flags, RETRIGGERABLE);
SO_ENGINE_DEFINE_ENUM_VALUE(Flags, HOLD_FINAL);
SO_ENGINE_SET_SF_ENUM_TYPE(flags, Flags);
state = OFF;
rampVal = 0.0;
timeVal = 0.0;
outputPending = FALSE;
isBuiltIn = TRUE;
// default time source connection
timeIn.connectFrom(SoDB::getGlobalField("realTime"));
ramp.enable(FALSE);
isActive.enable(FALSE);
timeOut.enable(FALSE);
}
SoBoolOperation::SoBoolOperation()
//
////////////////////////////////////////////////////////////////////////
{
SO_ENGINE_CONSTRUCTOR(SoBoolOperation);
SO_ENGINE_ADD_INPUT(a, (FALSE));
SO_ENGINE_ADD_INPUT(b, (FALSE));
SO_ENGINE_ADD_INPUT(operation, (A));
SO_ENGINE_ADD_OUTPUT(output, SoMFBool);
SO_ENGINE_ADD_OUTPUT(inverse, SoMFBool);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, CLEAR);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, SET);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, A);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, NOT_A);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, NOT_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, A_OR_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, NOT_A_OR_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, A_OR_NOT_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, NOT_A_OR_NOT_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, A_AND_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, NOT_A_AND_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, A_AND_NOT_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, NOT_A_AND_NOT_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, A_EQUALS_B);
SO_ENGINE_DEFINE_ENUM_VALUE(Operation, A_NOT_EQUALS_B);
SO_ENGINE_SET_MF_ENUM_TYPE(operation, Operation);
isBuiltIn = TRUE;
}
SoVtkImageWrapPad::SoVtkImageWrapPad()
{
SO_ENGINE_CONSTRUCTOR(SoVtkImageWrapPad);
mObject = vtkImageWrapPad::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkImageWrapPad *aImageWrapPad = vtkImageWrapPad::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(OutputNumberOfScalarComponents, (0));
OutputNumberOfScalarComponents.setValue(aImageWrapPad->GetOutputNumberOfScalarComponents());
SO_ENGINE_ADD_INPUT(NumberOfThreads, (0));
NumberOfThreads.setValue(aImageWrapPad->GetNumberOfThreads());
SO_ENGINE_ADD_INPUT(OutputWholeExtent, ());
OutputWholeExtent.setFormat("int int int int int int");
SO_ENGINE_ADD_INPUT(InputConnection, (0));
aImageWrapPad->Delete();
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
mOutputPort = 0;
addCalled = 0;
}
SoVtkCylindricalTransform::SoVtkCylindricalTransform()
{
SO_ENGINE_CONSTRUCTOR(SoVtkCylindricalTransform);
mObject = vtkCylindricalTransform::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkCylindricalTransform *aCylindricalTransform = vtkCylindricalTransform::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(InverseIterations, (0));
InverseIterations.setValue(aCylindricalTransform->GetInverseIterations());
SO_ENGINE_ADD_INPUT(InverseTolerance, (0));
InverseTolerance.setValue(aCylindricalTransform->GetInverseTolerance());
SO_ENGINE_ADD_INPUT(Inverse, (0));
aCylindricalTransform->Delete();
SO_ENGINE_ADD_OUTPUT( oInverse, SoSFVtkObject );
mInverse = 0;
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
addCalled = 0;
}
SoVtkDataSetTriangleFilter::SoVtkDataSetTriangleFilter()
{
SO_ENGINE_CONSTRUCTOR(SoVtkDataSetTriangleFilter);
mObject = vtkDataSetTriangleFilter::New();
mObject->Register(0);
mObject->SetGlobalWarningDisplay(0);
vtkDataSetTriangleFilter *aDataSetTriangleFilter = vtkDataSetTriangleFilter::New();
double *x = 0;
int *y = 0;
float *z = 0;
SO_ENGINE_ADD_INPUT(InputConnection, (0));
aDataSetTriangleFilter->Delete();
SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
mOutput = 0;
SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
mOutputPort = 0;
addCalled = 0;
}
SoInterpolate::SoInterpolate()
//
////////////////////////////////////////////////////////////////////////
{
SO_ENGINE_CONSTRUCTOR(SoInterpolate);
isBuiltIn = TRUE;
}
SoItkWhiteTopHatImageFilter::SoItkWhiteTopHatImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkWhiteTopHatImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( Kernel, (0) );
}
SoDoubleCalculator::SoDoubleCalculator()
//
////////////////////////////////////////////////////////////////////////
{
SO_ENGINE_CONSTRUCTOR(SoDoubleCalculator);
SO_ENGINE_ADD_INPUT(a, (0));
SO_ENGINE_ADD_INPUT(b, (0));
SO_ENGINE_ADD_INPUT(c, (0));
SO_ENGINE_ADD_INPUT(d, (0));
SO_ENGINE_ADD_INPUT(e, (0));
SO_ENGINE_ADD_INPUT(f, (0));
SO_ENGINE_ADD_INPUT(g, (0));
SO_ENGINE_ADD_INPUT(h, (0));
SO_ENGINE_ADD_INPUT(A, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(B, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(C, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(D, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(E, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(F, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(G, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(H, (SbVec3f(0,0,0)));
SO_ENGINE_ADD_INPUT(expression, (""));
SO_ENGINE_ADD_OUTPUT(oa, SoMFDouble);
SO_ENGINE_ADD_OUTPUT(ob, SoMFDouble);
SO_ENGINE_ADD_OUTPUT(oc, SoMFDouble);
SO_ENGINE_ADD_OUTPUT(od, SoMFDouble);
SO_ENGINE_ADD_OUTPUT(oA, SoMFVec3f);
SO_ENGINE_ADD_OUTPUT(oB, SoMFVec3f);
SO_ENGINE_ADD_OUTPUT(oC, SoMFVec3f);
SO_ENGINE_ADD_OUTPUT(oD, SoMFVec3f);
parser = new SoCalcParser(lookupDouble, lookupVec3f, this);
reparse = FALSE;
isBuiltIn = TRUE;
}
SoItkConstantPadImageFilter::SoItkConstantPadImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkConstantPadImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( Constant, (0) );
}
SoItkWeightedAddImageFilter::SoItkWeightedAddImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkWeightedAddImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( Alpha, (0) );
}
SoItkMorphologyImageFilter::SoItkMorphologyImageFilter()
{
SO_ENGINE_CONSTRUCTOR( SoItkMorphologyImageFilter );
// Inputs
SO_ENGINE_ADD_INPUT( Kernel, (0) );
}
