void
avtMinMaxQuery::Preparation(avtDataObject_p inData)
{
avtDataRequest_p dataRequest = inData->GetOriginatingSource()
->GetGeneralContract()->GetDataRequest();
src = inData->GetQueryableSource();
intVector dlist;
dataRequest->GetSIL().GetDomainList(dlist);
if (dlist.size() == 1 && dataRequest->UsesAllDomains())
singleDomain = true;
else
singleDomain = false;
avtDataAttributes &inAtts = inData->GetInfo().GetAttributes();
if (inAtts.HasInvTransform() && inAtts.GetCanUseInvTransform())
{
invTransform = new avtMatrix(*(inAtts.GetInvTransform()));
}
else
{
invTransform = NULL;
}
}
void
avtPseudocolorPlot::SetCellCountMultiplierForSRThreshold(
const avtDataObject_p dob)
{
if (dob->GetInfo().GetAttributes().GetTopologicalDimension() > 0)
{
// Not a point var, no multiplier.
cellCountMultiplierForSRThreshold = 1.0;
}
else
{
//
// Actual polygon count can change on-the-fly based on point type,
// and does not require re-execution of the engine (where the
// cell count is important, and queried from.)
// Using the current polgyon count doesn't make sense,
// the default point-type is 'Point' which does not do any
// glyhing. If we return 1, then we may never switch into SR
// mode even when necessary (if user changes type to icosahedron
// in 3D, which adds 20 polys per point).
// Always using the maximum may be overkill, but it seems best
// under the circumstances.
//
if (dob->GetInfo().GetAttributes().GetSpatialDimension() == 3)
cellCountMultiplierForSRThreshold = 20.0;
else
cellCountMultiplierForSRThreshold = 12.0;
}
}
void
avtNullDataSink::SetTypedInput(avtDataObject_p in)
{
if (*in != NULL &&
(strcmp(in->GetType(), "avtNullData") != 0) &&
(strcmp(in->GetType(), AVT_NULL_IMAGE_MSG) != 0) &&
(strcmp(in->GetType(), AVT_NULL_DATASET_MSG) != 0))
{
EXCEPTION0(ImproperUseException);
}
CopyTo(input, in);
}
void
avtNamedSelectionManager::CreateNamedSelection(avtDataObject_p dob,
const SelectionProperties &selProps, avtNamedSelectionExtension *ext)
{
const char *mName = "avtNamedSelectionManager::CreateNamedSelection: ";
StackTimer t0("CreateNamedSelection");
if (strcmp(dob->GetType(), "avtDataset") != 0)
{
EXCEPTION1(VisItException, "Named selections only work on data sets");
}
// Save the selection properties.
AddSelectionProperties(selProps);
// Augment the contract based on the selection properties.
avtContract_p c0 = dob->GetContractFromPreviousExecution();
bool needsUpdate = false;
avtContract_p contract = ext->ModifyContract(c0, selProps, needsUpdate);
//
// Let the input try to create the named selection ... some have special
// logic, for example the parallel coordinates filter.
//
const std::string &selName = selProps.GetName();
avtNamedSelection *ns = NULL;
if(selProps.GetSelectionType() == SelectionProperties::BasicSelection)
{
ns = dob->GetSource()->CreateNamedSelection(contract, selName);
if (ns != NULL)
{
int curSize = selList.size();
selList.resize(curSize+1);
selList[curSize] = ns;
//
// Save out the named selection in case of engine crash /
// save/restore session, etc.
//
SaveNamedSelection(selName, true);
return;
}
}
//
// Call into the extension to get the per-processor named selection.
//
TimedCodeBlock("Creating selection in extension",
ns = ext->GetSelection(dob, selProps, cache);
);
void
avtImageSink::SetTypedInput(avtDataObject_p in)
{
if (*in != NULL && strcmp(in->GetType(), "avtImage") != 0)
{
//
// Should create a new exception here, but I'm under time constraints.
//
debug1 << "Looking for avtImage, but found type \""
<< in->GetType() << "\"." << endl;
EXCEPTION0(ImproperUseException);
}
CopyTo(input, in);
}
void
avtDisplacePluginFilter::UpdateDataObjectInfoCB(avtDataObject_p &input,
avtDataObject_p &output, void *This)
{
avtDataAttributes &outAtts = output->GetInfo().GetAttributes();
outAtts.AddFilterMetaData("Displace");
}
avtDataObject_p
avtPseudocolorPlot::ApplyOperators(avtDataObject_p input)
{
avtDataObject_p dob = input;
if (staggeringFilter != NULL) {
delete staggeringFilter;
staggeringFilter = NULL;
}
staggeringFilter = new avtStaggeringFilter();
staggeringFilter->SetInput(dob);
dob = staggeringFilter->GetOutput();
if (input->GetInfo().GetAttributes().GetTopologicalDimension() == 0)
{
if (pcfilter != NULL)
{
delete pcfilter;
}
pcfilter = new avtPseudocolorFilter();
pcfilter->SetInput(dob);
pcfilter->SetPlotAtts(&atts);
dob = pcfilter->GetOutput();
}
return dob;
}
void
avtExternalSurfaceFilter::UpdateDataObjectInfoCB(avtDataObject_p &input,
avtDataObject_p &output, void *This)
{
avtDataAttributes &outAtts = output->GetInfo().GetAttributes();
outAtts.AddFilterMetaData("ExternalSurface");
}
void
avtTransformFilter::UpdateDataObjectInfoCB(avtDataObject_p &input,
avtDataObject_p &output, void *This)
{
avtDataAttributes &outAtts = output->GetInfo().GetAttributes();
const TransformAttributes &tf = ((const avtTransformFilter *)This)->atts;
char tmp[200];
std::string scale, translate, rotate;
if(tf.GetDoScale())
{
SNPRINTF(tmp, 200, "scale=%lg,%lg,%lg ",
tf.GetScaleX(), tf.GetScaleY(), tf.GetScaleZ());
scale = tmp;
}
if(tf.GetDoTranslate())
{
SNPRINTF(tmp, 200, "translate=%lg,%lg,%lg ",
tf.GetTranslateX(), tf.GetTranslateY(), tf.GetTranslateZ());
translate = tmp;
}
if(tf.GetDoRotate())
{
SNPRINTF(tmp, 200, "rotateOrigin=%lg,%lg,%lg rotateAxis=%lg,%lg,%lg rotateAmount=%lg",
tf.GetRotateOrigin()[0], tf.GetRotateOrigin()[1], tf.GetRotateOrigin()[2],
tf.GetRotateAxis()[0], tf.GetRotateAxis()[1], tf.GetRotateAxis()[2],
tf.GetRotateAmount());
rotate = tmp;
}
outAtts.AddFilterMetaData("Transform", scale + translate + rotate);
}
avtDataObject_p
avtOriginalDataMinMaxQuery::ApplyFilters(avtDataObject_p inData)
{
Preparation(inData);
avtDataRequest_p dataRequest =
inData->GetOriginatingSource()->GetFullDataRequest();
if (dataRequest->GetVariable() != queryAtts.GetVariables()[0] ||
dataRequest->GetTimestep() != queryAtts.GetTimeStep() ||
timeVarying)
{
dataRequest = new avtDataRequest(queryAtts.GetVariables()[0].c_str(),
queryAtts.GetTimeStep(),
dataRequest->GetRestriction());
}
avtContract_p contract =
new avtContract(dataRequest, queryAtts.GetPipeIndex());
if (ParallelizingOverTime())
{
// Make sure we set up our request to do streaming.
contract->SetOnDemandStreaming(true);
contract->UseLoadBalancing(false);
}
avtDataObject_p temp;
CopyTo(temp, inData);
eef->SetInput(temp);
avtDataObject_p retObj = eef->GetOutput();
retObj->Update(contract);
return retObj;
}
avtDataObject_p
avtActualDataMinMaxQuery::ApplyFilters(avtDataObject_p inData)
{
Preparation(inData);
bool zonesPreserved = GetInput()->GetInfo().GetValidity().GetZonesPreserved();
zonesPreserved = (bool)UnifyMinimumValue((int)zonesPreserved);
if (!timeVarying && zonesPreserved)
{
avtContract_p contract =
inData->GetOriginatingSource()->GetGeneralContract();
avtDataset_p ds;
CopyTo(ds, inData);
avtSourceFromAVTDataset termsrc(ds);
avtDataObject_p obj = termsrc.GetOutput();
condense->SetInput(obj);
avtDataObject_p retObj = condense->GetOutput();
retObj->Update(contract);
return retObj;
}
else
{
avtDataRequest_p oldSpec = inData->GetOriginatingSource()->
GetGeneralContract()->GetDataRequest();
avtDataRequest_p newDS = new
avtDataRequest(oldSpec, querySILR);
newDS->SetTimestep(queryAtts.GetTimeStep());
newDS->SetVariable(queryAtts.GetVariables()[0].c_str());
if (!zonesPreserved)
newDS->TurnZoneNumbersOn();
avtContract_p contract =
new avtContract(newDS, queryAtts.GetPipeIndex());
avtDataObject_p temp;
CopyTo(temp, inData);
condense->SetInput(temp);
avtDataObject_p retObj = condense->GetOutput();
retObj->Update(contract);
return retObj;
}
}
// ****************************************************************************
// Method: avtConnComponentsWeightedVariableQuery::ApplyFilters
//
// Purpose:
// Applies the filters to the input.
//
// Programmer: Cyrus Harrison
// Creation: February 2, 2007
//
// Modifications:
// Cyrus Harrison, Mon Jun 6 17:04:12 PDT 2011
// Support lines.
//
// ****************************************************************************
avtDataObject_p
avtConnComponentsWeightedVariableQuery::ApplyFilters(avtDataObject_p inData)
{
//
// Create an artificial pipeline.
//
avtDataset_p ds;
CopyTo(ds, inData);
avtSourceFromAVTDataset termsrc(ds);
avtDataObject_p dob = termsrc.GetOutput();
// add either lengthFilter, areaFilter, or volumeFilter based on input dimension
int topo = GetInput()->GetInfo().GetAttributes().GetTopologicalDimension();
if (topo == 1)
{
debug5 << "ConnComponentsWeightedVariable query using length" << endl;
lengthFilter->SetInput(dob);
dob = lengthFilter->GetOutput();
}
else if (topo == 2)
{
if (GetInput()->GetInfo().GetAttributes().GetMeshCoordType()== AVT_XY)
{
debug5 << "ConnComponentsWeightedVariable query using "
<< "Area" << endl;
areaFilter->SetInput(dob);
dob = areaFilter->GetOutput();
}
else
{
debug5 << "ConnComponentsWeightedVariable query using "
<< "RevolvedVolume" << endl;
revolvedVolumeFilter->SetInput(dob);
dob = revolvedVolumeFilter->GetOutput();
}
}
else
{
debug5 << "ConnComponentsWeightedVariable query using "
<< "Volume" << endl;
volumeFilter->SetInput(dob);
dob = volumeFilter->GetOutput();
}
cclFilter->SetInput(dob);
dob = cclFilter->GetOutput();
avtContract_p contract =
inData->GetOriginatingSource()->GetGeneralContract();
cclFilter->GetOutput()->Update(contract);
return cclFilter->GetOutput();
}
avtDataObject_p
avtHistogramPlot::ApplyOperators(avtDataObject_p input)
{
#ifdef ENGINE
if (HistogramFilter != NULL)
delete HistogramFilter;
if (amountFilter != NULL)
delete amountFilter;
avtDataAttributes &in_atts = input->GetInfo().GetAttributes();
avtExpressionFilter *af = NULL;
if (in_atts.GetTopologicalDimension() == 3)
{
af = new avtVMetricVolume;
}
else
{
if (in_atts.GetSpatialDimension() == 2)
{
if (input->GetInfo().GetAttributes().GetMeshCoordType() == AVT_XY)
af = new avtVMetricArea;
else
af = new avtRevolvedVolume;
}
else
af = new avtVMetricArea;
}
af->SetOutputVariableName("_amounts");
af->SetInput(input);
amountFilter = af;
HistogramFilter = new avtHistogramFilter;
HistogramFilter->SetAttributes(atts);
if (atts.GetHistogramType() != HistogramAttributes::Frequency)
HistogramFilter->SetInput(af->GetOutput());
else
HistogramFilter->SetInput(input);
return HistogramFilter->GetOutput();
#endif
return input;
}
void
avtResamplePluginFilter::UpdateDataObjectInfoCB(avtDataObject_p &input,
avtDataObject_p &output, void *This)
{
avtDataAttributes &outAtts = output->GetInfo().GetAttributes();
const ResampleAttributes &rs = ((const avtResamplePluginFilter *)This)->atts;
char params[200];
SNPRINTF(params, 200, "nx=%d ny=%d nz=%d",
rs.GetSamplesX(), rs.GetSamplesY(), rs.GetSamplesZ());
outAtts.AddFilterMetaData("Resample", params);
}
avtDataObject_p
avtLocalizedCompactnessFactorQuery::ApplyFilters(avtDataObject_p inData)
{
//
// Create an artificial pipeline.
//
avtDataset_p ds;
CopyTo(ds, inData);
avtSourceFromAVTDataset termsrc(ds);
avtDataObject_p dob = termsrc.GetOutput();
double extents[6] = { 0, 0, 0, 0, 0, 0 };
avtDatasetExaminer::GetSpatialExtents(ds, extents);
avtConstantCreatorExpression ccf;
ccf.SetValue(1.0);
ccf.SetInput(dob);
ccf.SetOutputVariableName("is_material");
dob = ccf.GetOutput();
InternalResampleAttributes res_atts;
res_atts.SetDefaultVal(0.);
bool is2D = (dob->GetInfo().GetAttributes().GetSpatialDimension() < 3);
int res = (is2D ? 250000 : 2000000);
res_atts.SetTargetVal(res);
res_atts.SetUseTargetVal(true);
res_atts.SetUseBounds(true);
res_atts.SetMinX(extents[0]);
res_atts.SetMaxX(extents[1]);
res_atts.SetMinY(extents[2]);
res_atts.SetMaxY(extents[3]);
res_atts.SetMinZ(extents[4]);
res_atts.SetMaxZ(extents[5]);
avtResampleFilter resf(&res_atts);
resf.SetInput(dob);
dob = resf.GetOutput();
avtLocalizedCompactnessExpression lce;
lce.SetInput(dob);
lce.SetOutputVariableName("lce");
lce.AddInputVariableName("is_material");
dob = lce.GetOutput();
//
// Cause our artificial pipeline to execute.
//
avtContract_p contract =
inData->GetOriginatingSource()->GetGeneralContract();
contract->GetDataRequest()->AddSecondaryVariable("is_material");
dob->Update(contract);
return dob;
}
avtDataObject_p
avtStreamlinePlot::ApplyOperators(avtDataObject_p input)
{
#ifdef ENGINE
avtDataObject_p dob = input;
// Try to determine the centering. If we have an expression, we won't
// be able to. So be conservative and assume the worst.
avtCentering centering = AVT_ZONECENT;
if (input->GetInfo().GetAttributes().ValidVariable(varname))
centering = input->GetInfo().GetAttributes().GetCentering(varname);
//Convert from zonal to nodal, if requested.
if(centering == AVT_ZONECENT && atts.GetForceNodeCenteredData())
{
if(shiftCenteringFilter != NULL)
delete shiftCenteringFilter;
shiftCenteringFilter = new avtShiftCenteringFilter(AVT_NODECENT);
shiftCenteringFilter->SetInput(input);
dob = shiftCenteringFilter->GetOutput();
if(removeGhostZonesFilter != NULL)
delete removeGhostZonesFilter;
removeGhostZonesFilter = new avtGhostZoneFilter();
removeGhostZonesFilter->GhostDataMustBeRemoved();
removeGhostZonesFilter->SetInput(dob);
dob = removeGhostZonesFilter->GetOutput();
}
// Add the streamline filter.
streamlineFilter->SetInput(dob);
dob = streamlineFilter->GetOutput();
return dob;
#else
return input;
#endif
}
avtDataObject_p
avtWatertightQuery::ApplyFilters(avtDataObject_p inData)
{
avtContract_p contract =
inData->GetOriginatingSource()->GetGeneralContract();
//
// Create an artificial pipeline.
//
avtDataset_p ds;
CopyTo(ds, inData);
avtSourceFromAVTDataset termsrc(ds);
avtDataObject_p dob = termsrc.GetOutput();
external_nodes->SetInput(dob);
avtDataObject_p objOut = external_nodes->GetOutput();
objOut->Update(contract);
return objOut;
}
avtDataObject_p
avtOriginalDataSpatialExtentsQuery::ApplyFilters(avtDataObject_p inData)
{
avtDataRequest_p dataRequest = inData->GetOriginatingSource()->
GetGeneralContract()->GetDataRequest();
std::string dbVar = ParsingExprList::GetRealVariable(
queryAtts.GetVariables()[0]);
avtDataRequest_p new_dataRequest = new avtDataRequest(dataRequest,
dbVar.c_str());
avtContract_p contract =
new avtContract(new_dataRequest, queryAtts.GetPipeIndex());
avtDataObject_p retObj;
CopyTo(retObj, inData);
retObj->Update(contract);
return retObj;
}
void
avtIsosurfaceFilter::UpdateDataObjectInfoCB(avtDataObject_p &input,
avtDataObject_p &output, void *This)
{
avtDataAttributes &outAtts = output->GetInfo().GetAttributes();
const IsosurfaceAttributes &iso = ((const avtIsosurfaceFilter *)This)->atts;
char tmp[200];
std::string params;
if(iso.GetContourMethod() == IsosurfaceAttributes::Level)
{
SNPRINTF(tmp, 200, "contourNLevels=%d", iso.GetContourNLevels());
params = tmp;
}
else if(iso.GetContourMethod() == IsosurfaceAttributes::Value)
{
params = "contourValue=";
for(size_t i = 0; i < iso.GetContourValue().size(); ++i)
{
SNPRINTF(tmp, 200, "%lg", iso.GetContourValue()[i]);
params += tmp;
if(i < iso.GetContourValue().size()-1)
params += ", ";
}
}
else if(iso.GetContourMethod() == IsosurfaceAttributes::Percent)
{
params = "contourPercent=";
for(size_t i = 0; i < iso.GetContourPercent().size(); ++i)
{
SNPRINTF(tmp, 200, "%lg", iso.GetContourPercent()[i]);
params += tmp;
if(i < iso.GetContourValue().size()-1)
params += ", ";
}
}
outAtts.AddFilterMetaData("Isosurface", params);
}
// ****************************************************************************
// Method: avtConnComponentsLengthQuery::ApplyFilters
//
// Purpose:
// Constructs an artificial pipeline with the connected components and
// area filters necessary to obtain per component area.
//
// Programmer: Cyrus Harrison
// Creation: Wed Jun 15 13:09:43 PDT 2011
//
// ****************************************************************************
avtDataObject_p
avtConnComponentsLengthQuery::ApplyFilters(avtDataObject_p inData)
{
// Create an artificial pipeline.
avtDataset_p ds;
CopyTo(ds, inData);
avtSourceFromAVTDataset termsrc(ds);
avtDataObject_p dob = termsrc.GetOutput();
// add the area filter to the pipeline
lengthFilter->SetInput(dob);
dob = lengthFilter->GetOutput();
// add the ccl filter to the pipeline
cclFilter->SetInput(dob);
dob = cclFilter->GetOutput();
avtContract_p contract =
inData->GetOriginatingSource()->GetGeneralContract();
cclFilter->GetOutput()->Update(contract);
return cclFilter->GetOutput();
}
avtDataObject_p
avtWeightedVariableSummationQuery::ApplyFilters(avtDataObject_p inData)
{
//
// Create an artificial pipeline.
//
avtDataset_p ds;
CopyTo(ds, inData);
avtSourceFromAVTDataset termsrc(ds);
avtDataObject_p dob = termsrc.GetOutput();
//
// Set up our base class so it is ready to sum.
//
string varname;
if (GetInput()->GetInfo().GetAttributes().ValidActiveVariable())
varname = GetInput()->GetInfo().GetAttributes().GetVariableName();
else
varname = GetInput()->GetOriginatingSource()->GetFullDataRequest()->
GetVariable();
varname = GetVarname(varname);
SetSumType(varname);
int topo = GetInput()->GetInfo().GetAttributes().GetTopologicalDimension();
if (topo == 1)
{
debug5 << "WeightedVariableSum using length" << endl;
length->SetInput(dob);
dob = length->GetOutput();
}
else if (topo == 2)
{
if (GetInput()->GetInfo().GetAttributes().GetMeshCoordType() == AVT_XY)
{
debug5 << "WeightedVariableSum using Area" << endl;
area->SetInput(dob);
dob = area->GetOutput();
}
else
{
debug5 << "WeightedVariableSum using RevolvedVolume" << endl;
revolvedVolume->SetInput(dob);
dob = revolvedVolume->GetOutput();
}
}
else
{
debug5 << "WeightedVariableSum using Volume" << endl;
volume->SetInput(dob);
dob = volume->GetOutput();
}
//
// Let the derived type create a new variable if necessary.
//
dob = CreateVariable(dob);
multiply->SetInput(dob);
multiply->ClearInputVariableNames();
multiply->AddInputVariableName("avt_weights");
multiply->AddInputVariableName(varname.c_str());
//
// Cause our artificial pipeline to execute.
//
avtContract_p contract =
inData->GetOriginatingSource()->GetGeneralContract();
if (timeVarying)
{
avtDataRequest_p dataRequest = GetInput()->GetOriginatingSource()
->GetFullDataRequest();
avtDataRequest_p newDS = new
avtDataRequest(dataRequest, querySILR);
newDS->SetTimestep(queryAtts.GetTimeStep());
contract = new avtContract(newDS, contract->GetPipelineIndex());
}
if (CalculateAverage())
{
denomVariableName = "avt_weights";
// State that we want avt_weights as an output, so it doesn't get
// thrown out after the multiply.
contract->GetDataRequest()->AddSecondaryVariable("avt_weights");
}
multiply->GetOutput()->Update(contract);
return multiply->GetOutput();
}
avtInlinePipelineSource::avtInlinePipelineSource(avtDataObject_p dob)
{
realPipelineSource = dob->GetOriginatingSource();
}
avtDataObject_p
avtVariableSummationQuery::ApplyFilters(avtDataObject_p inData)
{
avtDataValidity &dval = GetInput()->GetInfo().GetValidity();
avtDataAttributes &datts = GetInput()->GetInfo().GetAttributes();
bool cellData = false;
avtCentering cent = AVT_UNKNOWN_CENT;
if (datts.ValidVariable(variableName))
{
cent = datts.GetCentering(variableName.c_str());
cellData = (cent != AVT_NODECENT);
}
else
{
// we can't determine the centering, assume zone-centered
cellData = true;
}
int bDoCustomFiltering = dval.SubdivisionOccurred() ||
( cellData && !dval.GetOriginalZonesIntact()) ||
(!cellData && !dval.GetZonesPreserved());
#ifdef PARALLEL
int bAnyDoCustomFiltering;
MPI_Allreduce(&bDoCustomFiltering, &bAnyDoCustomFiltering, 1,
MPI_INT, MPI_LOR, VISIT_MPI_COMM);
bDoCustomFiltering = bAnyDoCustomFiltering;
#endif
if (bDoCustomFiltering)
{
// This will work for time-varying data, too.
// tell parent class to sum from original element values.
// e.g. each 'original' cell/node constributes only once to
// the sum.
SumFromOriginalElement(true);
// Need to request original cell and/or node numbers
avtDataRequest_p oldSpec = inData->GetOriginatingSource()->
GetGeneralContract()->GetDataRequest();
avtDataRequest_p newDS = new
avtDataRequest(oldSpec, querySILR);
newDS->SetTimestep(queryAtts.GetTimeStep());
if (cent == AVT_ZONECENT)
{
newDS->TurnZoneNumbersOn();
}
else if (cent == AVT_NODECENT)
{
newDS->TurnNodeNumbersOn();
}
else
{
newDS->TurnZoneNumbersOn();
newDS->TurnNodeNumbersOn();
}
avtContract_p contract =
new avtContract(newDS, queryAtts.GetPipeIndex());
avtDataObject_p temp;
CopyTo(temp, inData);
condense->SetInput(temp);
avtDataObject_p rv = condense->GetOutput();
rv->Update(contract);
return rv;
}
else
{
return avtSummationQuery::ApplyFilters(inData);
}
}
