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