Commit 575ebda2 authored by Berk Geveci's avatar Berk Geveci Committed by Dave DeMarle
Browse files

Removed priority based streaming and fast path.

Removed priority based streaming and fast path codes in
preparation for future refactoring. These were polluting core
classes despite having a small user base. In the future, they
may be refactored into the appropriate subclasses and "plugins".

Change-Id: I54562546688c6de468b0068e9b6c65e49c5ec269
parent a909be53
......@@ -41,7 +41,6 @@ vtkInformationKeyMacro(vtkDataObject, DATA_EXTENT_TYPE, Integer);
vtkInformationKeyMacro(vtkDataObject, DATA_PIECE_NUMBER, Integer);
vtkInformationKeyMacro(vtkDataObject, DATA_NUMBER_OF_PIECES, Integer);
vtkInformationKeyMacro(vtkDataObject, DATA_NUMBER_OF_GHOST_LEVELS, Integer);
vtkInformationKeyMacro(vtkDataObject, DATA_RESOLUTION, Double);
vtkInformationKeyMacro(vtkDataObject, DATA_TIME_STEP, Double);
vtkInformationKeyMacro(vtkDataObject, POINT_DATA_VECTOR, InformationVector);
vtkInformationKeyMacro(vtkDataObject, CELL_DATA_VECTOR, InformationVector);
......@@ -55,14 +54,11 @@ vtkInformationKeyMacro(vtkDataObject, FIELD_NAME, String);
vtkInformationKeyMacro(vtkDataObject, FIELD_NUMBER_OF_COMPONENTS, Integer);
vtkInformationKeyMacro(vtkDataObject, FIELD_NUMBER_OF_TUPLES, Integer);
vtkInformationKeyRestrictedMacro(vtkDataObject, FIELD_RANGE, DoubleVector, 2);
vtkInformationKeyRestrictedMacro(vtkDataObject, PIECE_FIELD_RANGE, DoubleVector, 2);
vtkInformationKeyMacro(vtkDataObject, FIELD_ARRAY_NAME, String);
vtkInformationKeyRestrictedMacro(vtkDataObject, PIECE_EXTENT, IntegerVector, 6);
vtkInformationKeyMacro(vtkDataObject, FIELD_OPERATION, Integer);
vtkInformationKeyRestrictedMacro(vtkDataObject, DATA_EXTENT, IntegerPointer, 6);
vtkInformationKeyRestrictedMacro(vtkDataObject, ORIGIN, DoubleVector, 3);
vtkInformationKeyRestrictedMacro(vtkDataObject, SPACING, DoubleVector, 3);
vtkInformationKeyMacro(vtkDataObject, DATA_GEOMETRY_UNMODIFIED, Integer);
vtkInformationKeyMacro(vtkDataObject, SIL, DataObject);
vtkInformationKeyRestrictedMacro(vtkDataObject, BOUNDING_BOX, DoubleVector, 6);
......@@ -170,7 +166,6 @@ void vtkDataObject::Initialize()
this->Information->Remove(DATA_NUMBER_OF_PIECES());
this->Information->Remove(DATA_NUMBER_OF_GHOST_LEVELS());
this->Information->Remove(DATA_TIME_STEP());
this->Information->Remove(DATA_RESOLUTION());
}
this->Modified();
......@@ -599,10 +594,6 @@ void vtkDataObject::InternalDataObjectCopy(vtkDataObject *src)
{
this->Information->CopyEntry(src->Information, DATA_TIME_STEP(), 1);
}
if(src->Information->Has(DATA_RESOLUTION()))
{
this->Information->CopyEntry(src->Information, DATA_RESOLUTION(), 1);
}
// This also caused a pipeline problem.
// An input pipelineMTime was copied to output. Pipeline did not execute...
......
......@@ -301,7 +301,6 @@ public:
static vtkInformationIntegerKey* DATA_PIECE_NUMBER();
static vtkInformationIntegerKey* DATA_NUMBER_OF_PIECES();
static vtkInformationIntegerKey* DATA_NUMBER_OF_GHOST_LEVELS();
static vtkInformationDoubleKey* DATA_RESOLUTION();
static vtkInformationDoubleKey* DATA_TIME_STEP();
static vtkInformationInformationVectorKey* POINT_DATA_VECTOR();
static vtkInformationInformationVectorKey* CELL_DATA_VECTOR();
......@@ -315,13 +314,10 @@ public:
static vtkInformationIntegerKey* FIELD_NUMBER_OF_TUPLES();
static vtkInformationIntegerKey* FIELD_OPERATION();
static vtkInformationDoubleVectorKey* FIELD_RANGE();
static vtkInformationDoubleVectorKey* PIECE_FIELD_RANGE();
static vtkInformationStringKey* FIELD_ARRAY_NAME();
static vtkInformationIntegerVectorKey* PIECE_EXTENT();
static vtkInformationStringKey* FIELD_NAME();
static vtkInformationDoubleVectorKey* ORIGIN();
static vtkInformationDoubleVectorKey* SPACING();
static vtkInformationIntegerKey* DATA_GEOMETRY_UNMODIFIED();
static vtkInformationDoubleVectorKey* BOUNDING_BOX();
// Key used to put SIL information in the output information by readers.
......
......@@ -57,13 +57,6 @@ vtkInformationKeyMacro(vtkAlgorithm, PORT_REQUIREMENTS_FILLED, Integer);
vtkInformationKeyMacro(vtkAlgorithm, INPUT_PORT, Integer);
vtkInformationKeyMacro(vtkAlgorithm, INPUT_CONNECTION, Integer);
vtkInformationKeyMacro(vtkAlgorithm, INPUT_ARRAYS_TO_PROCESS, InformationVector);
vtkInformationKeyMacro(vtkAlgorithm, PRESERVES_DATASET, Integer);
vtkInformationKeyMacro(vtkAlgorithm, PRESERVES_GEOMETRY, Integer);
vtkInformationKeyMacro(vtkAlgorithm, PRESERVES_BOUNDS, Integer);
vtkInformationKeyMacro(vtkAlgorithm, PRESERVES_TOPOLOGY, Integer);
vtkInformationKeyMacro(vtkAlgorithm, PRESERVES_ATTRIBUTES, Integer);
vtkInformationKeyMacro(vtkAlgorithm, PRESERVES_RANGES, Integer);
vtkInformationKeyMacro(vtkAlgorithm, MANAGES_METAINFORMATION, Integer);
vtkExecutive* vtkAlgorithm::DefaultExecutivePrototype = 0;
......@@ -1647,19 +1640,6 @@ void vtkAlgorithm::SetProgressText(const char* ptext)
}
}
//-------------------------------------------------------------
double vtkAlgorithm::ComputePriority()
{
vtkStreamingDemandDrivenPipeline *sddp =
vtkStreamingDemandDrivenPipeline::SafeDownCast
(this->GetExecutive());
if (!sddp)
{
return 1.0;
}
return sddp->ComputePriority(0);
}
//-------------------------------------------------------------
int vtkAlgorithm::SetUpdateExtentToWholeExtent(int port)
{
......
......@@ -470,23 +470,6 @@ public:
// in CreateDefaultExecutive() using NewInstance().
static void SetDefaultExecutivePrototype(vtkExecutive* proto);
// Description:
// Returns the priority of the piece described by the current update
// extent. The priority is a number between 0.0 and 1.0 with 0 meaning
// skippable (REQUEST_DATA not needed) and 1.0 meaning important.
virtual double ComputePriority();
// Description:
// These are flags that can be set that let the pipeline keep accurate
// meta-information for ComputePriority.
static vtkInformationIntegerKey* PRESERVES_DATASET();
static vtkInformationIntegerKey* PRESERVES_GEOMETRY();
static vtkInformationIntegerKey* PRESERVES_BOUNDS();
static vtkInformationIntegerKey* PRESERVES_TOPOLOGY();
static vtkInformationIntegerKey* PRESERVES_ATTRIBUTES();
static vtkInformationIntegerKey* PRESERVES_RANGES();
static vtkInformationIntegerKey* MANAGES_METAINFORMATION();
// Description:
// If the whole output extent is required, this method can be called to set
// the output update extent to the whole extent. This method assumes that
......
......@@ -604,11 +604,6 @@ int vtkCompositeDataPipeline::NeedToExecuteData(
return 1;
}
if (this->NeedToExecuteBasedOnFastPathData(outInfo))
{
return 1;
}
if (this->NeedToExecuteBasedOnCompositeIndices(outInfo))
{
return 1;
......
......@@ -123,9 +123,6 @@ public:
static int GetUpdateNumberOfPieces(vtkInformation *);
static int SetUpdateGhostLevel(vtkInformation *, int n);
static int GetUpdateGhostLevel(vtkInformation *);
int SetUpdateResolution(int port, double r);
int SetUpdateResolution(vtkInformation *, double r);
double GetUpdateResolution(vtkInformation *);
// Description:
// Get/Set the update extent for output ports that use Temporal Extents
......@@ -158,14 +155,6 @@ public:
void GetWholeBoundingBox(int port, double bb[6]);
double* GetWholeBoundingBox(int port);
// Description:
// Set/Get the piece bounding box of an output port data object.
// The piece bounding box is meta data for data sets. It gets
// set by the algorithm during the update extent information pass.
int SetPieceBoundingBox(int port, double bb[6]);
void GetPieceBoundingBox(int port, double bb[6]);
double* GetPieceBoundingBox(int port);
// Description:
// Key defining a request to propagate the update extent upstream.
static vtkInformationRequestKey* REQUEST_UPDATE_EXTENT();
......@@ -176,17 +165,6 @@ public:
// Key defining a request to make sure the meta information is up to date.
static vtkInformationRequestKey* REQUEST_TIME_DEPENDENT_INFORMATION();
// Description:
// Key defining a request to propagate information about the update
// extent downstream.
static vtkInformationRequestKey* REQUEST_UPDATE_EXTENT_INFORMATION();
static vtkInformationRequestKey* REQUEST_MANAGE_INFORMATION();
// Description:
// Key defining to propagate resolution changes up the pipeline.
static vtkInformationRequestKey* REQUEST_RESOLUTION_PROPAGATE();
// Description:
// Key for an algorithm to store in a request to tell this executive
// to keep executing it.
......@@ -204,10 +182,6 @@ public:
static vtkInformationIntegerKey* UPDATE_NUMBER_OF_PIECES();
static vtkInformationIntegerKey* UPDATE_NUMBER_OF_GHOST_LEVELS();
// Description:
// Key to store an update in the AMR level of resolution.
static vtkInformationIntegerKey* UPDATE_AMR_LEVEL();
// Description:
// Key for combining the update extents requested by all consumers,
// so that the final extent that is produced satisfies all consumers.
......@@ -238,15 +212,6 @@ public:
// information.
static vtkInformationDoubleVectorKey* WHOLE_BOUNDING_BOX();
// Description:
// Key to store the bounding box of a portion of the data set in
// pipeline information.
static vtkInformationDoubleVectorKey* PIECE_BOUNDING_BOX();
// Description:
// Key used to reject unimportant pieces in streaming.
static vtkInformationDoubleVectorKey* PIECE_NORMAL();
// Description:
// Key to specify the request for exact extent in pipeline information.
static vtkInformationIntegerKey* EXACT_EXTENT();
......@@ -273,74 +238,14 @@ public:
// to gather the time dependent information
static vtkInformationIntegerKey* TIME_DEPENDENT_INFORMATION();
// Description:
// Key that specifies from 0.0 to 1.0 the pipeline computed priority
// of this update extent. 0.0 means does not contribute and can
// be skipped.
static vtkInformationDoubleKey* PRIORITY();
// Description:
// Key that specifies how many cells were in the piece at the head of the
// pipeline, so that work estimates can be made.
static vtkInformationUnsignedLongKey* ORIGINAL_NUMBER_OF_CELLS();
// Description:
// Key that specifies a requested resolution level for this update
// extent. 0.0 is very low and 1.0 is full resolution.
static vtkInformationDoubleKey* UPDATE_RESOLUTION();
// Description:
// Used internally to validate meta information as it flows through pipeline
static vtkInformationIntegerKey* REMOVE_ATTRIBUTE_INFORMATION();
// Description:
// The following keys are meant to be used by an algorithm that
// works with temporal data. Rather than re-executing the pipeline
// for each timestep, if the reader, as part of its API, contains
// a faster way to read temporal data, algorithms may use these
// keys to request temporal data from the reader.
// See also: vtkExtractArraysOverTime.
// Key to allow a reader to advertise that it supports a fast-path
// for reading data over time.
static vtkInformationIntegerKey* FAST_PATH_FOR_TEMPORAL_DATA();
// The type of data being requested.
// Possible values: POINT, CELL, EDGE, FACE
static vtkInformationStringKey* FAST_PATH_OBJECT_TYPE();
// Possible values: INDEX, GLOBAL
static vtkInformationStringKey* FAST_PATH_ID_TYPE();
// The id (either index or global id) being requested
static vtkInformationIdTypeKey* FAST_PATH_OBJECT_ID();
// Description:
// key to record the bounds of a dataset.
static vtkInformationDoubleVectorKey *BOUNDS();
// Description:
// Issues pipeline request to determine and return the priority of the
// piece described by the current update extent. The priority is a
// number between 0.0 and 1.0 with 0 meaning skippable (REQUEST_DATA
// not needed) and 1.0 meaning important.
double ComputePriority()
{
return this->ComputePriority(0);
}
virtual double ComputePriority(int port);
protected:
vtkStreamingDemandDrivenPipeline();
~vtkStreamingDemandDrivenPipeline();
// Description:
// Called before RequestUpdateExtent() pass on the algorithm. Here we remove
// all update-related keys from the input information.
// Currently this only removes the fast-path related keys.
virtual void ResetUpdateInformation(vtkInformation* request,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec);
// Keep track of the update time request corresponding to the
// previous executing. If the previous update request did not
// correspond to an existing time step and the reader chose
......@@ -350,21 +255,11 @@ protected:
// We know that it does not have this time step.
static vtkInformationDoubleKey* PREVIOUS_UPDATE_TIME_STEP();
// Keep track of the fast path keys corresponding to the
// previous executing. If all key values are the same as their
// counterparts in the previous request, we do not need to re-execute.
static vtkInformationIdTypeKey* PREVIOUS_FAST_PATH_OBJECT_ID();
static vtkInformationStringKey* PREVIOUS_FAST_PATH_OBJECT_TYPE();
static vtkInformationStringKey* PREVIOUS_FAST_PATH_ID_TYPE();
// Does the time request correspond to what is in the data?
// Returns 0 if yes, 1 otherwise.
virtual int NeedToExecuteBasedOnTime(vtkInformation* outInfo,
vtkDataObject* dataObject);
// If the request contains a fast path key for temporal data, always execute
virtual int NeedToExecuteBasedOnFastPathData(vtkInformation* outInfo);
// Setup default information on the output after the algorithm
// executes information.
virtual int ExecuteInformation(vtkInformation* request,
......
......@@ -94,9 +94,6 @@ vtkContourFilter::vtkContourFilter()
// by default process active point scalars
this->SetInputArrayToProcess(0,0,0,vtkDataObject::FIELD_ASSOCIATION_POINTS,
vtkDataSetAttributes::SCALARS);
this->GetInformation()->Set(vtkAlgorithm::PRESERVES_RANGES(), 1);
this->GetInformation()->Set(vtkAlgorithm::PRESERVES_BOUNDS(), 1);
}
vtkContourFilter::~vtkContourFilter()
......@@ -708,97 +705,6 @@ int vtkContourFilter::GetOutputPointsPrecision() const
return this->OutputPointsPrecision;
}
//----------------------------------------------------------------------------
int vtkContourFilter::ProcessRequest(vtkInformation* request,
vtkInformationVector** inputVector,
vtkInformationVector* outputVector)
{
// generate the data
if(request->Has(vtkStreamingDemandDrivenPipeline::REQUEST_UPDATE_EXTENT_INFORMATION()))
{
// compute the priority for this UE
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
// get the range of the input if available
vtkInformation *fInfo = NULL;
vtkDataArray *inscalars = this->GetInputArrayToProcess(0, inputVector);
if (inscalars)
{
vtkInformationVector *miv = inInfo->Get(vtkDataObject::POINT_DATA_VECTOR());
for (int index = 0; index < miv->GetNumberOfInformationObjects(); index++)
{
vtkInformation *mInfo = miv->GetInformationObject(index);
const char *minfo_arrayname =
mInfo->Get(vtkDataObject::FIELD_ARRAY_NAME());
if (minfo_arrayname && !strcmp(minfo_arrayname, inscalars->GetName()))
{
fInfo = mInfo;
break;
}
}
}
else
{
fInfo = vtkDataObject::GetActiveFieldInformation
(inInfo, vtkDataObject::FIELD_ASSOCIATION_POINTS,
vtkDataSetAttributes::SCALARS);
}
if (!fInfo)
{
return 1;
}
double *range = fInfo->Get(vtkDataObject::PIECE_FIELD_RANGE());
int numContours = this->ContourValues->GetNumberOfContours();
if (range && numContours)
{
// compute the priority
// get the incoming priority if any
double inPriority = 1;
if (inInfo->Has(vtkStreamingDemandDrivenPipeline::PRIORITY()))
{
inPriority = inInfo->Get(vtkStreamingDemandDrivenPipeline::PRIORITY());
}
outInfo->Set(vtkStreamingDemandDrivenPipeline::PRIORITY(),inPriority);
if (!inPriority)
{
return 1;
}
// do any contours intersect the range?
double *values=this->ContourValues->GetValues();
int i;
for (i=0; i < numContours; i++)
{
if (values[i] >= range[0] && values[i] <= range[1])
{
return 1;
}
}
double inRes = 1.0;
if (inInfo->Has(vtkStreamingDemandDrivenPipeline::UPDATE_RESOLUTION()))
{
inRes = inInfo->Get
(vtkStreamingDemandDrivenPipeline::UPDATE_RESOLUTION());
}
if (inRes >= 0.99)
{
outInfo->Set(vtkStreamingDemandDrivenPipeline::PRIORITY(),0.0);
}
else
{
outInfo->Set
(vtkStreamingDemandDrivenPipeline::PRIORITY(),inPriority*0.1);
}
}
return 1;
}
return this->Superclass::ProcessRequest(request, inputVector, outputVector);
}
int vtkContourFilter::FillInputPortInformation(int, vtkInformation *info)
{
info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkDataSet");
......
......@@ -152,12 +152,6 @@ public:
vtkGetMacro(GenerateTriangles,int);
vtkBooleanMacro(GenerateTriangles,int);
// Description:
// see vtkAlgorithm for details
virtual int ProcessRequest(vtkInformation*,
vtkInformationVector**,
vtkInformationVector*);
// Description:
// Set/get the desired precision for the output types. See the documentation
// for the vtkAlgorithm::Precision enum for an explanation of the available
......
......@@ -71,9 +71,6 @@ vtkCutter::vtkCutter(vtkImplicitFunction *cf)
this->SynchronizedTemplatesCutter3D = vtkSynchronizedTemplatesCutter3D::New();
this->GridSynchronizedTemplates = vtkGridSynchronizedTemplates3D::New();
this->RectilinearSynchronizedTemplates = vtkRectilinearSynchronizedTemplates::New();
this->GetInformation()->Set(vtkAlgorithm::PRESERVES_RANGES(), 1);
this->GetInformation()->Set(vtkAlgorithm::PRESERVES_BOUNDS(), 1);
}
//----------------------------------------------------------------------------
......@@ -1048,130 +1045,3 @@ void vtkCutter::PrintSelf(ostream& os, vtkIndent indent)
os << indent << "Precision of the output points: "
<< this->OutputPointsPrecision << "\n";
}
//-----------------------------------------------------------------------
int vtkCutter::ProcessRequest(vtkInformation* request,
vtkInformationVector** inputVector,
vtkInformationVector* outputVector)
{
if(request->Has(vtkStreamingDemandDrivenPipeline::
REQUEST_UPDATE_EXTENT_INFORMATION()))
{
// compute the priority for this UpdateExtent
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
if (!inInfo)
{
return 1;
}
double inPrior = 1;
if (inInfo->Has(vtkStreamingDemandDrivenPipeline::PRIORITY()))
{
inPrior = inInfo->Get(vtkStreamingDemandDrivenPipeline::
PRIORITY());
}
// Get bounds and evaluate implicit function. If all bounds
// evaluate to a value smaller than input value, this piece
// has priority set to 0.
static double bounds[] = {-1.0,1.0, -1.0,1.0, -1.0,1.0};
double prior = 1;
// determine geometric bounds of this piece
double *wBBox =
inInfo->
Get(vtkStreamingDemandDrivenPipeline::PIECE_BOUNDING_BOX());
if (!wBBox)
{
wBBox =
inInfo->
Get(vtkStreamingDemandDrivenPipeline::WHOLE_BOUNDING_BOX());
}
if (wBBox)
{
bounds[0] = wBBox[0];
bounds[1] = wBBox[1];
bounds[2] = wBBox[2];
bounds[3] = wBBox[3];
bounds[4] = wBBox[4];
bounds[5] = wBBox[5];
}
else
{
//try to figure out geometric bounds
double *origin = inInfo->Get(vtkDataObject::ORIGIN());
double *spacing = inInfo->Get(vtkDataObject::SPACING());
int *subExtent = inInfo->Get(
vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT());
if (origin && spacing && subExtent)
{
bounds[0] = origin[0]+subExtent[0]*spacing[0];
bounds[1] = origin[0]+subExtent[1]*spacing[0];
bounds[2] = origin[1]+subExtent[2]*spacing[1];
bounds[3] = origin[1]+subExtent[3]*spacing[1];
bounds[4] = origin[2]+subExtent[4]*spacing[2];
bounds[5] = origin[2]+subExtent[5]*spacing[2];
}
else
{
//cerr << "Need geometric bounds meta information to evaluate priority" << endl;
outputVector->GetInformationObject(0)->
Set(vtkStreamingDemandDrivenPipeline::PRIORITY(),inPrior);
return 1;
}
}
vtkPlane* fPtr = vtkPlane::SafeDownCast(this->GetCutFunction());
if (!fPtr)
{
//cerr << "Can not evaluate priority for that clip type" << endl;
outputVector->GetInformationObject(0)->
Set(vtkStreamingDemandDrivenPipeline::PRIORITY(),inPrior);
return 1;
}
static double fVal[8];
fVal[0] = fPtr->EvaluateFunction(bounds[0],bounds[2],bounds[4]);
fVal[1] = fPtr->EvaluateFunction(bounds[0],bounds[2],bounds[5]);
fVal[2] = fPtr->EvaluateFunction(bounds[0],bounds[3],bounds[4]);
fVal[3] = fPtr->EvaluateFunction(bounds[0],bounds[3],bounds[5]);
fVal[4] = fPtr->EvaluateFunction(bounds[1],bounds[2],bounds[4]);
fVal[5] = fPtr->EvaluateFunction(bounds[1],bounds[2],bounds[5]);
fVal[6] = fPtr->EvaluateFunction(bounds[1],bounds[3],bounds[4]);
fVal[7] = fPtr->EvaluateFunction(bounds[1],bounds[3],bounds[5]);
prior = 0;
int numOffsets = this->ContourValues->GetNumberOfContours();
for (int c=0; c < numOffsets; c++)
{
double value = this->ContourValues->GetValue(c);
int i;
bool less = fVal[0]<value;
for (i=1; i<8;i++)
{
if ((fVal[i]<=value) != less)
{
//this corner is on different side than first, piece
//intersects and cannot be rejected
prior = inPrior;
c = numOffsets;
break;
}
}
}
if (prior != inPrior)
{
//cerr << "rejected something!" << endl;
}
outputVector->GetInformationObject(0)->
Set(vtkStreamingDemandDrivenPipeline::PRIORITY(),prior);
return 1;
}
//all other requests handled by superclass
return this->Superclass::ProcessRequest(request, inputVector,
outputVector);
}
......@@ -194,12 +194,6 @@ protected:
vtkCutter(vtkImplicitFunction *cf=NULL);
~vtkCutter();
// Description:
// Overridden to process REQUEST_UPDATE_EXTENT_INFORMATION.
virtual int ProcessRequest(vtkInformation*,
vtkInformationVector**,
vtkInformationVector*);
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
virtual int RequestUpdateExtent(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
virtual int FillInputPortInformation(int port, vtkInformation *info);
......
......@@ -88,9 +88,6 @@ vtkQuadricClustering::vtkQuadricClustering()
this->InCellCount = this->OutCellCount = 0;
this->CopyCellData = 0;
this->GetInformation()->Set(vtkAlgorithm::PRESERVES_RANGES(), 1);
this->GetInformation()->Set(vtkAlgorithm::PRESERVES_BOUNDS(), 1);
}
//----------------------------------------------------------------------------
......
......@@ -46,8 +46,6 @@ vtkThreshold::vtkThreshold()
this->SetInputArrayToProcess(0,0,0,vtkDataObject::FIELD_ASSOCIATION_POINTS_THEN_CELLS,
vtkDataSetAttributes::SCALARS);
this->GetInformation()->Set(vtkAlgorithm::PRESERVES_RANGES(), 1);