// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WritePoleFigure::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Image Format");
parameter->setPropertyName("ImageFormat");
QVector<QString> choices;
choices.push_back("tif");
choices.push_back("bmp");
choices.push_back("png");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(IntFilterParameter::New("Lambert Image Size (Pixels)", "LambertSize", getLambertSize(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Number of Colors", "NumColors", getNumColors(), FilterParameter::Parameter));
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Image Layout");
parameter->setPropertyName("ImageLayout");
QVector<QString> choices;
choices.push_back("Horizontal");
choices.push_back("Vertical");
choices.push_back("Square");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(StringFilterParameter::New("Image Prefix", "ImagePrefix", getImagePrefix(), FilterParameter::Parameter));
parameters.push_back(OutputPathFilterParameter::New("Output Path", "OutputPath", getOutputPath(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Image Size (Square Pixels)", "ImageSize", getImageSize(), FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Float, 3, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Euler Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Int32, 1, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Phases", "CellPhasesArrayPath", getCellPhasesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Bool, 1, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Mask", "GoodVoxelsArrayPath", getGoodVoxelsArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::UInt32, 1, SIMPL::AttributeMatrixType::CellEnsemble, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Crystal Structures", "CrystalStructuresArrayPath", getCrystalStructuresArrayPath(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindFeatureHistogram::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Number of Bins");
parameter->setPropertyName("NumberOfBins");
parameters.push_back(parameter);
}
QStringList linkedProps("BiasedFeaturesArrayPath");
parameters.push_back(LinkedBooleanFilterParameter::New("Remove Biased Features", "RemoveBiasedFeatures", getRemoveBiasedFeatures(), linkedProps, FilterParameter::Parameter));
{
DataArraySelectionFilterParameter::RequirementType req;
parameters.push_back(DataArraySelectionFilterParameter::New("Feature Array To Bin", "SelectedFeatureArrayPath", getSelectedFeatureArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req;
parameters.push_back(DataArraySelectionFilterParameter::New("FeaturePhases", "FeaturePhasesArrayPath", getFeaturePhasesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req;
parameters.push_back(DataArraySelectionFilterParameter::New("BiasedFeatures", "BiasedFeaturesArrayPath", getBiasedFeaturesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArrayCreationFilterParameter::RequirementType req;
parameters.push_back(DataArrayCreationFilterParameter::New("New Ensemble Array", "NewEnsembleArrayArrayPath", getNewEnsembleArrayArrayPath(), FilterParameter::CreatedArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConvertData::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Scalar Type");
parameter->setPropertyName("ScalarType");
QVector<QString> choices;
choices.push_back("signed int 8 bit");
choices.push_back("unsigned int 8 bit");
choices.push_back("signed int 16 bit");
choices.push_back("unsigned int 16 bit");
choices.push_back("signed int 32 bit");
choices.push_back("unsigned int 32 bit");
choices.push_back("signed int 64 bit");
choices.push_back("unsigned int 64 bit");
choices.push_back(" Float 32 bit");
choices.push_back(" Double 64 bit");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(DataArraySelectionFilterParameter::New("Attribute Array to Convert", "SelectedCellArrayPath", getSelectedCellArrayPath(), FilterParameter::RequiredArray));
parameters.push_back(StringFilterParameter::New("Converted Attribute Array", "OutputArrayName", getOutputArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FitFeatureData::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Distribution Type");
parameter->setPropertyName("DistributionType");
QVector<QString> choices;
choices.push_back("Beta");
choices.push_back("Log-Normal");
choices.push_back("Power Law");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
QStringList linkedProps("BiasedFeaturesArrayPath");
parameters.push_back(LinkedBooleanFilterParameter::New("Remove Biased Features", "RemoveBiasedFeatures", getRemoveBiasedFeatures(), linkedProps, FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Feature Data", FilterParameter::RequiredArray));
parameters.push_back(DataArraySelectionFilterParameter::New("Feature Array to Fit", "SelectedFeatureArrayPath", getSelectedFeatureArrayPath(), FilterParameter::RequiredArray));
parameters.push_back(DataArraySelectionFilterParameter::New("Phases", "FeaturePhasesArrayPath", getFeaturePhasesArrayPath(), FilterParameter::RequiredArray));
parameters.push_back(DataArraySelectionFilterParameter::New("Biased Features", "BiasedFeaturesArrayPath", getBiasedFeaturesArrayPath(), FilterParameter::RequiredArray));
parameters.push_back(SeparatorFilterParameter::New("Ensemble Data", FilterParameter::CreatedArray));
parameters.push_back(DataArrayCreationFilterParameter::New("Fit Parameters", "NewEnsembleArrayArray", getNewEnsembleArrayArray(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void OpenCloseBadData::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> parameters;
{
ChoiceFilterParameter::Pointer option = ChoiceFilterParameter::New();
option->setHumanLabel("Direction of Operation");
option->setPropertyName("Direction");
option->setWidgetType(FilterParameter::ChoiceWidget);
option->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("Dilate");
choices.push_back("Erode");
option->setChoices(choices);
parameters.push_back(option);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Number of Iterations");
option->setPropertyName("NumIterations");
option->setWidgetType(FilterParameter::IntWidget);
option->setValueType("int");
parameters.push_back(option);
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ImageCalculator::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(FilterParameter::New("First Array to Process", "SelectedCellArrayPath1", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath1(), false, ""));
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Operator");
parameter->setPropertyName("Operator");
parameter->setWidgetType(FilterParameterWidgetType::ChoiceWidget);
QVector<QString> choices;
choices.push_back("Add");
choices.push_back("Subtract");
choices.push_back("Multiply");
choices.push_back("Divide");
choices.push_back("AND");
choices.push_back("OR");
choices.push_back("XOR");
choices.push_back("Min");
choices.push_back("Max");
choices.push_back("Mean");
choices.push_back("Difference");
parameter->setChoices(choices);
parameters.push_back(parameter);
}
parameters.push_back(FilterParameter::New("Second Array to Process", "SelectedCellArrayPath2", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath2(), false, ""));
parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, ""));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InsertAtoms::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(FloatVec3FilterParameter::New("Lattice Constants (Angstroms)", "LatticeConstants", getLatticeConstants(), FilterParameter::Parameter));
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Crystal Basis");
parameter->setPropertyName("Basis");
QVector<QString> choices;
choices.push_back("Simple Cubic");
choices.push_back("Body Centered Cubic");
choices.push_back("Face Centered Cubic");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(SeparatorFilterParameter::New("Face Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::Int32, 2, DREAM3D::AttributeMatrixType::Face, DREAM3D::GeometryType::TriangleGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Face Labels", "SurfaceMeshFaceLabelsArrayPath", getSurfaceMeshFaceLabelsArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Cell Feature Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::Float, 4, DREAM3D::AttributeMatrixType::CellFeature, DREAM3D::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Average Quaternions", "AvgQuatsArrayPath", getAvgQuatsArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(StringFilterParameter::New("Data Container", "VertexDataContainerName", getVertexDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Vertex Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Vertex Attribute Matrix", "VertexAttributeMatrixName", getVertexAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Atom Feature Labels", "AtomFeatureLabelsArrayName", getAtomFeatureLabelsArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FlattenImage::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Flattening Method");
parameter->setPropertyName("FlattenMethod");
QVector<QString> choices;
choices.push_back("Average");
choices.push_back("Luminosity");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::UInt8, DREAM3D::Defaults::AnyComponentSize, DREAM3D::AttributeMatrixType::Cell, DREAM3D::GeometryType::ImageGeometry);
QVector< QVector<size_t> > cDims;
cDims.push_back(QVector<size_t>(1, 3));
cDims.push_back(QVector<size_t>(1, 4));
req.componentDimensions = cDims;
parameters.push_back(DataArraySelectionFilterParameter::New("Image Data", "ImageDataArrayPath", getImageDataArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Flat Image Data", "FlatImageDataArrayName", getFlatImageDataArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ErodeDilateBadData::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Operation");
parameter->setPropertyName("Direction");
QVector<QString> choices;
choices.push_back("Dilate");
choices.push_back("Erode");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(IntFilterParameter::New("Number of Iterations", "NumIterations", getNumIterations(), FilterParameter::Parameter));
parameters.push_back(BooleanFilterParameter::New("X Direction", "XDirOn", getXDirOn(), FilterParameter::Parameter));
parameters.push_back(BooleanFilterParameter::New("Y Direction", "YDirOn", getYDirOn(), FilterParameter::Parameter));
parameters.push_back(BooleanFilterParameter::New("Z Direction", "ZDirOn", getZDirOn(), FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::Int32, 1, DREAM3D::AttributeMatrixType::Cell, DREAM3D::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Feature Ids", "FeatureIdsArrayPath", getFeatureIdsArrayPath(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MultiThresholdCells::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Output Array Name");
parameter->setPropertyName("OutputArrayName");
parameter->setWidgetType(FilterParameter::ChoiceWidget);
parameter->setValueType("string");
parameter->setEditable(true);
std::vector<std::string> choices;
choices.push_back(DREAM3D::CellData::GoodVoxels);
parameter->setChoices(choices);
parameters.push_back(parameter);
}
{
FilterParameter::Pointer parameter = FilterParameter::New();
parameter->setHumanLabel("Select Arrays to Threshold");
parameter->setPropertyName("ComparisonInputs");
parameter->setWidgetType(FilterParameter::CellArrayComparisonSelectionWidget);
parameter->setValueType("std::vector<ComparisonInput_t>");
parameters.push_back(parameter);
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ImageMath::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(FilterParameter::New("Array to Operate On", "SelectedCellArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath(), false, ""));
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Operator");
parameter->setPropertyName("Operator");
parameter->setWidgetType(FilterParameterWidgetType::ChoiceWidget);
QVector<QString> choices;
choices.push_back("Add");
choices.push_back("Subtract");
choices.push_back("Multiply");
choices.push_back("Divide");
choices.push_back("Min");
choices.push_back("Max");
choices.push_back("Gamma");
choices.push_back("Log");
choices.push_back("Exp");
choices.push_back("Square");
choices.push_back("Square Root");
choices.push_back("Invert");
parameter->setChoices(choices);
parameters.push_back(parameter);
}
parameters.push_back(FilterParameter::New("Value", "Value", FilterParameterWidgetType::DoubleWidget, getValue(), false, ""));
QStringList linkedProps;
linkedProps << "NewCellArrayName";
parameters.push_back(LinkedBooleanFilterParameter::New("Save As New Array", "SaveAsNewArray", getSaveAsNewArray(), linkedProps, false));
parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, ""));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindFaceAverage::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> parameters;
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Face Array Name");
option->setPropertyName("SelectedFaceArrayName");
option->setWidgetType(FilterParameter::SurfaceMeshFaceArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
parameters.push_back(option);
}
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Average Type");
parameter->setPropertyName("AverageMethod");
parameter->setWidgetType(FilterParameter::ChoiceWidget);
parameter->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("Number Average");
choices.push_back("Area Weighted Average");
parameter->setChoices(choices);
parameters.push_back(parameter);
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WriteImages::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Image Format");
parameter->setPropertyName("ImageFormat");
QVector<QString> choices;
choices.push_back("tif");
choices.push_back("bmp");
choices.push_back("png");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Plane");
parameter->setPropertyName("Plane");
QVector<QString> choices;
choices.push_back("XY");
choices.push_back("XZ");
choices.push_back("YZ");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
{
QStringList linkedProps;
linkedProps << "ImagePrefix";
parameters.push_back(LinkedBooleanFilterParameter::New("File Prefix", "FilePrefix", getFilePrefix(), linkedProps, FilterParameter::Parameter));
}
parameters.push_back(OutputPathFilterParameter::New("Output Directory Path", "OutputPath", getOutputPath(), FilterParameter::Parameter));
parameters.push_back(StringFilterParameter::New("Image File Prefix", "ImagePrefix", getImagePrefix(), FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray));
parameters.push_back(DataArraySelectionFilterParameter::New("Color Data", "ColorsArrayPath", getColorsArrayPath(), FilterParameter::RequiredArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConvertOrientations::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Input Orientation Type");
parameter->setPropertyName("InputType");
QVector<QString> inputChoices = OrientationConverter<float>::GetOrientationTypeStrings();
parameter->setChoices(inputChoices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Output Orientation Type");
parameter->setPropertyName("OutputType");
QVector<QString> inputChoices = OrientationConverter<float>::GetOrientationTypeStrings();
parameter->setChoices(inputChoices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
{
DataArraySelectionFilterParameter::RequirementType req;
req.daTypes = QVector<QString>(2, DREAM3D::TypeNames::Double);
req.daTypes[1] = DREAM3D::TypeNames::Float;
parameters.push_back(DataArraySelectionFilterParameter::New("Input Orientations", "InputOrientationArrayPath", getInputOrientationArrayPath(), FilterParameter::RequiredArray, req, 0));
}
parameters.push_back(StringFilterParameter::New("Output Orientations", "OutputOrientationArrayName", getOutputOrientationArrayName(), FilterParameter::CreatedArray, 0));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RotateEulerRefFrame::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> parameters;
{
ChoiceFilterParameter::Pointer option = ChoiceFilterParameter::New();
option->setHumanLabel("Rotation Axis");
option->setPropertyName("RotationAxis");
option->setWidgetType(FilterParameter::FloatVec3Widget);
option->setValueType("FloatVec3Widget_t");
option->setUnits("ijk");
parameters.push_back(option);
}
{
ChoiceFilterParameter::Pointer option = ChoiceFilterParameter::New();
option->setHumanLabel("Rotation Angle");
option->setPropertyName("RotationAngle");
option->setWidgetType(FilterParameter::DoubleWidget);
option->setValueType("float");
option->setCastableValueType("double");
option->setUnits("Degrees");
parameters.push_back(option);
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConvertData::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> parameters;
/* Place all your option initialization code here */
/* To Display a Combobox with a list of current Voxel Cell Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Voxel Cell Array Name");
option->setPropertyName("SelectedCellArrayName");
option->setWidgetType(FilterParameter::VoxelCellArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
parameters.push_back(option);
}
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Scalar Type");
parameter->setPropertyName("ScalarType");
parameter->setWidgetType(FilterParameter::ChoiceWidget);
parameter->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("signed int 8 bit");
choices.push_back("unsigned int 8 bit");
choices.push_back("signed int 16 bit");
choices.push_back("unsigned int 16 bit");
choices.push_back("signed int 32 bit");
choices.push_back("unsigned int 32 bit");
choices.push_back("signed int 64 bit");
choices.push_back("unsigned int 64 bit");
choices.push_back(" Float 32 bit");
choices.push_back(" Double 64 bit");
parameter->setChoices(choices);
parameters.push_back(parameter);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Output Array Name");
option->setPropertyName("OutputArrayName");
option->setWidgetType(FilterParameter::StringWidget);
option->setValueType("string");
parameters.push_back(option);
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
ChoiceFilterParameter::Pointer ChoiceFilterParameter::New(const QString& humanLabel, const QString& propertyName, const int& defaultValue,
QVector<QString> choices,
bool editable,
Category category, int groupIndex)
{
ChoiceFilterParameter::Pointer ptr = ChoiceFilterParameter::New();
ptr->setHumanLabel(humanLabel);
ptr->setPropertyName(propertyName);
ptr->setDefaultValue(defaultValue);
ptr->setCategory(category);
ptr->setChoices(choices);
ptr->setEditable(editable);
ptr->setGroupIndex(groupIndex);
return ptr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FlattenImage::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> parameters;
{
ChoiceFilterParameter::Pointer option = ChoiceFilterParameter::New();
option->setHumanLabel("Flattening Method");
option->setPropertyName("FlattenMethod");
option->setWidgetType(FilterParameter::ChoiceWidget);
option->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("Lightness");
choices.push_back("Average");
choices.push_back("Luminosity");
option->setChoices(choices);
parameters.push_back(option);
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ChangeAngleRepresentation::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Conversion Type");
parameter->setPropertyName("ConversionType");
QVector<QString> choices;
choices.push_back("Degrees to Radians");
choices.push_back("Radians to Degrees");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(DataArraySelectionFilterParameter::New("Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), FilterParameter::RequiredArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FlattenImage::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Flattening Method");
parameter->setPropertyName("FlattenMethod");
QVector<QString> choices;
choices.push_back("Average");
choices.push_back("Luminosity");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray));
parameters.push_back(DataArraySelectionFilterParameter::New("Image Data", "ImageDataArrayPath", getImageDataArrayPath(), FilterParameter::RequiredArray));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Flat Image Data", "FlatImageDataArrayName", getFlatImageDataArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FitFeatureData::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Distribution Type");
parameter->setPropertyName("DistributionType");
QVector<QString> choices;
choices.push_back("Beta");
choices.push_back("Log-Normal");
choices.push_back("Power Law");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
QStringList linkedProps("BiasedFeaturesArrayPath");
parameters.push_back(LinkedBooleanFilterParameter::New("Remove Biased Features", "RemoveBiasedFeatures", getRemoveBiasedFeatures(), linkedProps, FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Feature Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(SIMPL::Defaults::AnyPrimitive, 1, SIMPL::AttributeMatrixObjectType::Feature);
parameters.push_back(DataArraySelectionFilterParameter::New("Feature Array to Fit", "SelectedFeatureArrayPath", getSelectedFeatureArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(SIMPL::TypeNames::Int32, 1, SIMPL::AttributeMatrixObjectType::Feature);
parameters.push_back(DataArraySelectionFilterParameter::New("Phases", "FeaturePhasesArrayPath", getFeaturePhasesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(SIMPL::TypeNames::Bool, 1, SIMPL::AttributeMatrixObjectType::Feature);
parameters.push_back(DataArraySelectionFilterParameter::New("Biased Features", "BiasedFeaturesArrayPath", getBiasedFeaturesArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Ensemble Data", FilterParameter::CreatedArray));
{
DataArrayCreationFilterParameter::RequirementType req = DataArrayCreationFilterParameter::CreateRequirement(SIMPL::AttributeMatrixObjectType::Ensemble);
parameters.push_back(DataArrayCreationFilterParameter::New("Fit Parameters", "NewEnsembleArrayArray", getNewEnsembleArrayArray(), FilterParameter::CreatedArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ChangeAngleRepresentation::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Conversion Type");
parameter->setPropertyName("ConversionType");
QVector<QString> choices;
choices.push_back("Degrees to Radians");
choices.push_back("Radians to Degrees");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::TypeNames::Float, DREAM3D::Defaults::AnyComponentSize, DREAM3D::AttributeMatrixObjectType::Element);
parameters.push_back(DataArraySelectionFilterParameter::New("Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void Threshold::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> options;
{
FilterParameter::Pointer parameter = FilterParameter::New();
parameter->setHumanLabel("Array to Process");
parameter->setPropertyName("SelectedCellArrayName");
parameter->setWidgetType(FilterParameter::VoxelCellArrayNameSelectionWidget);
parameter->setValueType("string");
parameter->setUnits("");
options.push_back(parameter);
}
{
FilterParameter::Pointer parameter = FilterParameter::New();
parameter->setHumanLabel("Overwrite Array");
parameter->setPropertyName("OverwriteArray");
parameter->setWidgetType(FilterParameter::BooleanWidget);
parameter->setValueType("bool");
options.push_back(parameter);
}
{
FilterParameter::Pointer parameter = FilterParameter::New();
parameter->setHumanLabel("Created Array Name");
parameter->setPropertyName("NewCellArrayName");
parameter->setWidgetType(FilterParameter::StringWidget);
parameter->setValueType("string");
options.push_back(parameter);
}
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Threshold Method");
parameter->setPropertyName("Method");
parameter->setWidgetType(FilterParameter::ChoiceWidget);
parameter->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("Huang");
choices.push_back("Intermodes");
choices.push_back("IsoData");
choices.push_back("Kittler Illingworth");
choices.push_back("Li");
choices.push_back("Maximum Entropy");
choices.push_back("Moments");
choices.push_back("Otsu");
choices.push_back("Renyi Entropy");
choices.push_back("Shanbhag");
choices.push_back("Triangle");
choices.push_back("Yen");
choices.push_back("Manual Selection");
//choices.push_back("Robust Automatic");
parameter->setChoices(choices);
options.push_back(parameter);
}
{
FilterParameter::Pointer parameter = FilterParameter::New();
parameter->setHumanLabel("Manual Parameter");
parameter->setPropertyName("ManualParameter");
parameter->setWidgetType(FilterParameter::IntWidget);
parameter->setValueType("int");
options.push_back(parameter);
}
{
FilterParameter::Pointer parameter = FilterParameter::New();
parameter->setHumanLabel("Slice at a Time");
parameter->setPropertyName("Slice");
parameter->setWidgetType(FilterParameter::BooleanWidget);
parameter->setValueType("bool");
options.push_back(parameter);
}
setFilterParameters(options);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void TestFilter::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> options;
/* Place all your option initialization code here */
/* For String input use this code */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("STL Output Prefix");
option->setPropertyName("StlFilePrefix");
option->setWidgetType(FilterParameter::StringWidget);
option->setValueType("string");
options.push_back(option);
}
/* For an Integer use this code*/
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Max Iterations");
option->setPropertyName("MaxIterations");
option->setWidgetType(FilterParameter::IntWidget);
option->setValueType("int");
options.push_back(option);
}
/* For a Floating point value use this code*/
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Misorientation Tolerance");
option->setPropertyName("MisorientationTolerance");
option->setWidgetType(FilterParameter::DoubleWidget);
option->setValueType("float");
option->setCastableValueType("double");
options.push_back(option);
}
/* For an input file use this code*/
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Input File");
option->setPropertyName("InputFile");
option->setWidgetType(FilterParameter::InputFileWidget);
option->setValueType("string");
options.push_back(option);
}
/* For an input path use this code*/
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Input Path");
option->setPropertyName("InputPath");
option->setWidgetType(FilterParameter::InputPathWidget);
option->setValueType("string");
options.push_back(option);
}
/* For an output file use this code*/
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Output File");
option->setPropertyName("OutputFile");
option->setWidgetType(FilterParameter::OutputFileWidget);
option->setValueType("string");
options.push_back(option);
}
/* For an output path use this code*/
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Output Path");
option->setPropertyName("OutputPath");
option->setWidgetType(FilterParameter::OutputPathWidget);
option->setValueType("string");
options.push_back(option);
}
/* For a simple true/false boolean use this code*/
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Write Alignment Shift File");
option->setPropertyName("WriteAlignmentShifts");
option->setWidgetType(FilterParameter::BooleanWidget);
option->setValueType("bool");
options.push_back(option);
}
/* For presenting a set of choices to the user use this code*/
{
ChoiceFilterParameter::Pointer option = ChoiceFilterParameter::New();
option->setHumanLabel("Conversion Type");
option->setPropertyName("ConversionType");
option->setWidgetType(FilterParameter::ChoiceWidget);
option->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("Degrees To Radians");
choices.push_back("Radians To Degrees");
option->setChoices(choices);
options.push_back(option);
}
/* To Display a Combobox with a list of current Voxel Cell Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Voxel Cell Array Name");
option->setPropertyName("SelectedCellArrayName");
option->setWidgetType(FilterParameter::VoxelCellArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current Voxel Field Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Voxel Field Array Name");
option->setPropertyName("SelectedFieldArrayName");
option->setWidgetType(FilterParameter::VoxelFieldArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current Voxel Ensemble Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Voxel Ensemble Array Name");
option->setPropertyName("SelectedEnsembleArrayName");
option->setWidgetType(FilterParameter::VoxelEnsembleArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current SurfaceMesh Point Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("SurfaceMesh Point Array Name");
option->setPropertyName("SurfaceMeshPointArrayName");
option->setWidgetType(FilterParameter::SurfaceMeshVertexArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current SurfaceMesh Face Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("SurfaceMesh Face Array Name");
option->setPropertyName("SurfaceMeshFaceArrayName");
option->setWidgetType(FilterParameter::SurfaceMeshFaceArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current SurfaceMesh Edge Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("SurfaceMesh Edge Array Name");
option->setPropertyName("SurfaceMeshEdgeArrayName");
option->setWidgetType(FilterParameter::SurfaceMeshEdgeArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current SolidMesh Point Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("SolidMesh Point Array Name");
option->setPropertyName("SolidMeshPointArrayName");
option->setWidgetType(FilterParameter::SolidMeshVertexArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current SolidMesh Face Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("SolidMesh Face Array Name");
option->setPropertyName("SolidMeshFaceArrayName");
option->setWidgetType(FilterParameter::SolidMeshFaceArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* To Display a Combobox with a list of current SolidMesh Edge Arrays in it */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("SolidMesh Edge Array Name");
option->setPropertyName("SolidMeshEdgeArrayName");
option->setWidgetType(FilterParameter::SolidMeshEdgeArrayNameSelectionWidget);
option->setValueType("string");
option->setUnits("");
options.push_back(option);
}
/* Display a group of 3 text boxes to collect 3 integer values */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Dimensions");
option->setPropertyName("Dimensions");
option->setWidgetType(FilterParameter::IntVec3Widget);
option->setValueType("IntVec3Widget_t");
option->setUnits("XYZ");
options.push_back(option);
}
/* Display a group of 3 text boxes to collect 3 float values */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Origin");
option->setPropertyName("Origin");
option->setWidgetType(FilterParameter::FloatVec3Widget);
option->setValueType("FloatVec3Widget_t");
option->setUnits("XYZ");
options.push_back(option);
}
/* To Compare Arrays like a threshold filter */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Voxel Cell Arrays to Threshold");
option->setPropertyName("CellComparisonInputs");
option->setWidgetType(FilterParameter::CellArrayComparisonSelectionWidget);
option->setValueType("std::vector<ComparisonInput_t>");
options.push_back(option);
}
/* Display the AxisAngleWidget to collect Axis-Angle pairs from the user */
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Crystal Rotations");
option->setPropertyName("AxisAngleRotations");
option->setWidgetType(FilterParameter::AxisAngleWidget);
options.push_back(option);
}
setFilterParameters(options);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RawBinaryReader::setupFilterParameters()
{
std::vector<FilterParameter::Pointer> parameters;
/* Place all your option initialization code here */
{
FilterParameter::Pointer parameter = FilterParameter::New();
parameter->setHumanLabel("Input File");
parameter->setPropertyName("InputFile");
parameter->setWidgetType(FilterParameter::InputFileWidget);
parameter->setValueType("string");
parameter->setFileExtension("*.raw *.bin");
parameters.push_back(parameter);
}
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Scalar Type");
parameter->setPropertyName("ScalarType");
parameter->setWidgetType(FilterParameter::ChoiceWidget);
parameter->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("signed int 8 bit");
choices.push_back("unsigned int 8 bit");
choices.push_back("signed int 16 bit");
choices.push_back("unsigned int 16 bit");
choices.push_back("signed int 32 bit");
choices.push_back("unsigned int 32 bit");
choices.push_back("signed int 64 bit");
choices.push_back("unsigned int 64 bit");
choices.push_back(" Float 32 bit");
choices.push_back(" Double 64 bit");
parameter->setChoices(choices);
parameters.push_back(parameter);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Dimensionality");
option->setPropertyName("Dimensionality");
option->setWidgetType(FilterParameter::IntWidget);
option->setValueType("int");
parameters.push_back(option);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Number Of Components");
option->setPropertyName("NumberOfComponents");
option->setWidgetType(FilterParameter::IntWidget);
option->setValueType("int");
parameters.push_back(option);
}
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Endian");
parameter->setPropertyName("Endian");
parameter->setWidgetType(FilterParameter::ChoiceWidget);
parameter->setValueType("unsigned int");
std::vector<std::string> choices;
choices.push_back("Little");
choices.push_back("Big");
parameter->setChoices(choices);
parameters.push_back(parameter);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Dimensions");
option->setPropertyName("Dimensions");
option->setWidgetType(FilterParameter::IntVec3Widget);
option->setValueType("IntVec3Widget_t");
option->setUnits("XYZ");
parameters.push_back(option);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Origin");
option->setPropertyName("Origin");
option->setWidgetType(FilterParameter::FloatVec3Widget);
option->setValueType("FloatVec3Widget_t");
option->setUnits("XYZ");
parameters.push_back(option);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Resolution");
option->setPropertyName("Resolution");
option->setWidgetType(FilterParameter::FloatVec3Widget);
option->setValueType("FloatVec3Widget_t");
option->setUnits("XYZ");
parameters.push_back(option);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Over Ride Origin & Resolution");
option->setPropertyName("OverRideOriginResolution");
option->setWidgetType(FilterParameter::BooleanWidget);
option->setValueType("bool");
parameters.push_back(option);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Skip Header Bytes");
option->setPropertyName("SkipHeaderBytes");
option->setWidgetType(FilterParameter::IntWidget);
option->setValueType("int");
parameters.push_back(option);
}
{
FilterParameter::Pointer option = FilterParameter::New();
option->setHumanLabel("Output Array Name");
option->setPropertyName("OutputArrayName");
option->setWidgetType(FilterParameter::StringWidget);
option->setValueType("string");
parameters.push_back(option);
}
setFilterParameters(parameters);
}