Ejemplo n.º 1
0
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);
}
Ejemplo n.º 2
0
/*!
  Default constructor.
*/
SoOneShot::SoOneShot(void)
{
  SO_ENGINE_INTERNAL_CONSTRUCTOR(SoOneShot);

  SO_ENGINE_ADD_INPUT(timeIn, (SbTime::zero()));
  SO_ENGINE_ADD_INPUT(duration, (SbTime(1.0)));
  SO_ENGINE_ADD_INPUT(trigger, ());
  SO_ENGINE_ADD_INPUT(flags, (0));
  SO_ENGINE_ADD_INPUT(disable, (FALSE));

  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);


  SoField * realtime = SoDB::getGlobalField("realTime");
  this->timeIn.connectFrom(realtime);

  this->running = FALSE;
  this->starttime = SbTime::zero();
  this->holdramp = 0.0f;
  this->holdduration = SbTime::zero();
}
Ejemplo n.º 3
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;
}
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;
}
Ejemplo n.º 5
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;
}
SoItkInterpolateImageFunction::SoItkInterpolateImageFunction()
{
	SO_ENGINE_CONSTRUCTOR( SoItkInterpolateImageFunction );

	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) );
}
Ejemplo n.º 7
0
SoXipImageOperation::SoXipImageOperation()
{
	SO_ENGINE_CONSTRUCTOR( SoXipImageOperation );

	SO_ENGINE_DEFINE_ENUM_VALUE( OperationEnum, MASK_OR );
	SO_ENGINE_DEFINE_ENUM_VALUE( OperationEnum, MASK_AND );
	SO_ENGINE_DEFINE_ENUM_VALUE( OperationEnum, MASK_NOR );
	SO_ENGINE_SET_SF_ENUM_TYPE( operation, OperationEnum );

	SO_ENGINE_ADD_INPUT( mask1, (0) );
    SO_ENGINE_ADD_INPUT( mask2, (0) );
    SO_ENGINE_ADD_INPUT( operation, (MASK_OR) );

	SO_ENGINE_ADD_OUTPUT( mask, SoXipSFDataImage );

	mMaskData = 0;
}
Ejemplo n.º 8
0
SoVtkAssignAttribute::SoVtkAssignAttribute()
{
	SO_ENGINE_CONSTRUCTOR(SoVtkAssignAttribute);

	mObject = vtkAssignAttribute::New();
	mObject->Register(0);
	mObject->SetGlobalWarningDisplay(0);

	vtkAssignAttribute *aAssignAttribute = vtkAssignAttribute::New();

	SO_ENGINE_ADD_INPUT(InputConnection, (0));

	aAssignAttribute->Delete();

	SO_ENGINE_DEFINE_ENUM_VALUE( AttributeLocation, CELL_DATA );
	SO_ENGINE_DEFINE_ENUM_VALUE( AttributeLocation, POINT_DATA );
	SO_ENGINE_SET_SF_ENUM_TYPE( AttributeLocationEnum, AttributeLocation );

	SO_ENGINE_ADD_OUTPUT( oImageDataOutput, SoSFVtkObject );
	mImageDataOutput = 0;

	SO_ENGINE_ADD_OUTPUT( oStructuredPointsOutput, SoSFVtkObject );
	mStructuredPointsOutput = 0;

	SO_ENGINE_ADD_OUTPUT( oStructuredGridOutput, SoSFVtkObject );
	mStructuredGridOutput = 0;

	SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
	mOutput = 0;

	SO_ENGINE_ADD_OUTPUT( oRectilinearGridOutput, SoSFVtkObject );
	mRectilinearGridOutput = 0;

	SO_ENGINE_ADD_OUTPUT( oUnstructuredGridOutput, SoSFVtkObject );
	mUnstructuredGridOutput = 0;

	SO_ENGINE_ADD_OUTPUT( OutputPort, SoSFVtkAlgorithmOutput );
	mOutputPort = 0;

	SO_ENGINE_ADD_OUTPUT( oPolyDataOutput, SoSFVtkObject );
	mPolyDataOutput = 0;

	addCalled = 0;
}
Ejemplo n.º 9
0
SoItkArray::SoItkArray()
{
	SO_ENGINE_CONSTRUCTOR( SoItkArray );

	// Enumerations
	SO_ENGINE_DEFINE_ENUM_VALUE( ValueTypeEnum, UNSIGNED_SHORT );
	SO_ENGINE_DEFINE_ENUM_VALUE( ValueTypeEnum, FLOAT );
	SO_ENGINE_DEFINE_ENUM_VALUE( ValueTypeEnum, DOUBLE );

	// Define input fields and their default values
	SO_ENGINE_SET_SF_ENUM_TYPE( ValueType, ValueTypeEnum );
	SO_ENGINE_ADD_INPUT( ValueType, (FLOAT) );
	SO_ENGINE_ADD_INPUT( Rows, (0) );
	SO_ENGINE_ADD_INPUT( Columns, (0) );
	SO_ENGINE_ADD_INPUT( Values, (0) );

	SO_ENGINE_ADD_OUTPUT( Output, SoItkSFDataArray );
	mOutput = 0;
}
Ejemplo n.º 10
0
CubicSplineEngine::CubicSplineEngine(void)
{
  SO_ENGINE_CONSTRUCTOR(CubicSplineEngine);
  
  SO_ENGINE_ADD_INPUT(timeIn, (SbTime::zero()));
  SO_ENGINE_ADD_INPUT(controlpoint, (0.0f, 0.0f, 0.0f));
  SO_ENGINE_ADD_INPUT(basisMatrix, (SbMatrix::identity()));
  SO_ENGINE_ADD_INPUT(duration, (1.0f));
  SO_ENGINE_ADD_INPUT(on, (FALSE));
  SO_ENGINE_ADD_INPUT(loop, (FALSE));
  SO_ENGINE_ADD_INPUT(type, (BEZIER));
  SO_ENGINE_ADD_INPUT(orientation, (SbRotation::identity()));
  SO_ENGINE_ADD_INPUT(orientationTime, (0.0f));
  SO_ENGINE_ADD_INPUT(offset, (0.0, 0.0, 0.0));
  
  SO_ENGINE_DEFINE_ENUM_VALUE(Type, BEZIER);
  SO_ENGINE_DEFINE_ENUM_VALUE(Type, B_SPLINE);
  SO_ENGINE_DEFINE_ENUM_VALUE(Type, CATMULL_ROM);
  
  SO_ENGINE_SET_SF_ENUM_TYPE(type, Type);

  SO_ENGINE_ADD_OUTPUT(pointOut, SoSFVec3d);
  SO_ENGINE_ADD_OUTPUT(tangentOut, SoSFVec3f);
  SO_ENGINE_ADD_OUTPUT(orientationOut, SoSFRotation);
  SO_ENGINE_ADD_OUTPUT(syncOut, SoSFTrigger);

  this->verifycb = NULL;
  this->linear = FALSE;
  
  this->syncOut.enable(FALSE);
  this->pointOut.enable(FALSE);
  this->tangentOut.enable(FALSE);
  this->orientationOut.enable(FALSE);
  this->first = TRUE;

  this->timeIn.enableNotify(FALSE);
  SoField * realtime = SoDB::getGlobalField("realTime");
  this->timeIn.connectFrom(realtime);
}
SoConditionalTrigger::SoConditionalTrigger()
{
   SO_ENGINE_CONSTRUCTOR(SoConditionalTrigger);

   SO_ENGINE_ADD_INPUT(triggerBool, (true));
   boolIn.setNum(0);						
   SO_ENGINE_ADD_INPUT(triggerFloat, (0.0));
   boolIn.setNum(0);						
   SO_ENGINE_ADD_INPUT(triggerInt, (0));
   boolIn.setNum(0);						
   SO_ENGINE_ADD_INPUT(triggerString, (""));
   boolIn.setNum(0);						
   SO_ENGINE_ADD_INPUT(triggerNode, (NULL));
   boolIn.setNum(0);						


   SO_ENGINE_ADD_INPUT(boolIn, (false));
   boolIn.setNum(0);						// we cant initialize an empty MFField, so we have to use this hack
   SO_ENGINE_ADD_INPUT(floatIn, (0.0));
   floatIn.setNum(0);						// we cant initialize an empty MFField, so we have to use this hack
   SO_ENGINE_ADD_INPUT(intIn, (0));
   intIn.setNum(0);							// we cant initialize an empty MFField, so we have to use this hack
   SO_ENGINE_ADD_INPUT(stringIn, (""));
   stringIn.setNum(0);						// we cant initialize an empty MFField, so we have to use this hack
   SO_ENGINE_ADD_INPUT(nodeIn, (NULL));
   nodeIn.setNum(0);						// we cant initialize an empty MFField, so we have to use this hack
   SO_ENGINE_ADD_INPUT(triggerIn, ());

   SO_ENGINE_ADD_INPUT(forwardInput, (FALSE));
   SO_ENGINE_ADD_INPUT(retrigger, (FALSE));


   SO_ENGINE_ADD_INPUT(triggerAtInit, (false));
   SO_ENGINE_ADD_INPUT(token, (""));


   SO_ENGINE_DEFINE_ENUM_VALUE(comparetype, EQUAL);
   SO_ENGINE_DEFINE_ENUM_VALUE(comparetype, LESS_THAN);
   SO_ENGINE_DEFINE_ENUM_VALUE(comparetype, GREATER_THAN);
   SO_ENGINE_DEFINE_ENUM_VALUE(comparetype, LESS_OR_EQUAL);
   SO_ENGINE_DEFINE_ENUM_VALUE(comparetype, GREATER_OR_EQUAL);
   SO_ENGINE_DEFINE_ENUM_VALUE(comparetype, NOT_EQUAL);

   SO_ENGINE_SET_SF_ENUM_TYPE(comparison, comparetype);
   SO_ENGINE_ADD_INPUT(comparison, (EQUAL));


   SO_ENGINE_ADD_OUTPUT(trigger, SoSFTrigger);
   SO_ENGINE_ADD_OUTPUT(tokenOut, SoSFString);
   SO_ENGINE_ADD_OUTPUT(boolOut, SoSFBool);
   SO_ENGINE_ADD_OUTPUT(intValueOut, SoSFInt32);

   triggerNotified = false;
   tempBool = false;
}
Ejemplo n.º 12
0
SoItkMatrix::SoItkMatrix()
{
	SO_ENGINE_CONSTRUCTOR( SoItkMatrix );

	// Enumerations
	SO_ENGINE_DEFINE_ENUM_VALUE( ValueTypeEnum, UNSIGNED_SHORT );
	SO_ENGINE_DEFINE_ENUM_VALUE( ValueTypeEnum, FLOAT );
	SO_ENGINE_DEFINE_ENUM_VALUE( ValueTypeEnum, DOUBLE );
    
    SO_ENGINE_DEFINE_ENUM_VALUE( MatrixTypeEnum, _2x2 );
	SO_ENGINE_DEFINE_ENUM_VALUE( MatrixTypeEnum, _3x3 );
	SO_ENGINE_DEFINE_ENUM_VALUE( MatrixTypeEnum, _4x4 );

	// Define input fields and their default values
	SO_ENGINE_SET_SF_ENUM_TYPE( ValueType, ValueTypeEnum );
	SO_ENGINE_ADD_INPUT( ValueType, (FLOAT) );
	SO_ENGINE_SET_SF_ENUM_TYPE( MatrixType, MatrixTypeEnum );
	SO_ENGINE_ADD_INPUT( MatrixType, (_2x2) );
	SO_ENGINE_ADD_INPUT( Values, (0) );

	SO_ENGINE_ADD_OUTPUT( Output, SoItkSFDataMatrix );
	mOutput = 0;
}
Ejemplo n.º 13
0
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;
}
Ejemplo n.º 14
0
SoVtkDataObject::SoVtkDataObject()
{
	SO_ENGINE_CONSTRUCTOR(SoVtkDataObject);

	mObject = vtkDataObject::New();
	mObject->Register(0);
	mObject->SetGlobalWarningDisplay(0);

	vtkDataObject *aDataObject = vtkDataObject::New();
	double *x = 0;
	int *y = 0;
	float *z = 0;

	SO_ENGINE_ADD_INPUT(FieldData, (0));

	SO_ENGINE_ADD_INPUT(ExtentTranslator, (0));

	SO_ENGINE_ADD_INPUT(MaximumNumberOfPieces, (0));
	MaximumNumberOfPieces.setValue(aDataObject->GetMaximumNumberOfPieces());

	SO_ENGINE_ADD_INPUT(RequestExactExtent, (0));
	RequestExactExtent.setValue(aDataObject->GetRequestExactExtent());

	SO_ENGINE_ADD_INPUT(UpdatePiece, (0));
	UpdatePiece.setValue(aDataObject->GetUpdatePiece());

	SO_ENGINE_ADD_INPUT(UpdateExtent, ());
	UpdateExtent.setFormat("int int int");

	SO_ENGINE_ADD_INPUT(WholeBoundingBox, ());
	WholeBoundingBox.setFormat("double double double double double double");

	SO_ENGINE_ADD_INPUT(UpdateGhostLevel, (0));
	UpdateGhostLevel.setValue(aDataObject->GetUpdateGhostLevel());

	SO_ENGINE_ADD_INPUT(UpdateNumberOfPieces, (0));
	UpdateNumberOfPieces.setValue(aDataObject->GetUpdateNumberOfPieces());

	SO_ENGINE_ADD_INPUT(WholeExtent, ());
	WholeExtent.setFormat("int int int int int int");

	SO_ENGINE_ADD_INPUT(Source, (0));

	SO_ENGINE_ADD_INPUT(PipelineInformation, (0));

	aDataObject->Delete();

	SO_ENGINE_DEFINE_ENUM_VALUE( FieldAssociations, FIELD_ASSOCIATION_POINTS );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldAssociations, FIELD_ASSOCIATION_NONE );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldAssociations, FIELD_ASSOCIATION_CELLS );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldAssociations, NUMBER_OF_ASSOCIATIONS );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldAssociations, FIELD_ASSOCIATION_POINTS_THEN_CELLS );
	SO_ENGINE_SET_SF_ENUM_TYPE( FieldAssociationsEnum, FieldAssociations );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldOperations, FIELD_OPERATION_REMOVED );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldOperations, FIELD_OPERATION_MODIFIED );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldOperations, FIELD_OPERATION_REINTERPOLATED );
	SO_ENGINE_DEFINE_ENUM_VALUE( FieldOperations, FIELD_OPERATION_PRESERVED );
	SO_ENGINE_SET_SF_ENUM_TYPE( FieldOperationsEnum, FieldOperations );

	SO_ENGINE_ADD_OUTPUT( oFieldData, SoSFVtkObject );
	mFieldData = 0;
	SO_ENGINE_ADD_OUTPUT( oExtentTranslator, SoSFVtkObject );
	mExtentTranslator = 0;
	SO_ENGINE_ADD_OUTPUT( oSource, SoSFVtkObject );
	mSource = 0;
	SO_ENGINE_ADD_OUTPUT( Output, SoSFVtkObject );
	mOutput = 0;


	addCalled = 0;
}