// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void InitializeSyntheticVolume::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setDataContainerName(reader->readString("DataContainerName", getDataContainerName() ) ); setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) ); setDimensions( reader->readIntVec3("Dimensions", getDimensions() ) ); setResolution( reader->readFloatVec3("Resolution", getResolution() ) ); setOrigin( reader->readFloatVec3("Origin", getOrigin() ) ); setInputStatsArrayPath(reader->readDataArrayPath("InputStatsArrayPath", getInputStatsArrayPath() ) ); setInputPhaseTypesArrayPath(reader->readDataArrayPath("InputPhaseTypesArrayPath", getInputPhaseTypesArrayPath() ) ); setInputStatsFile(reader->readString("InputStatsFile", getInputStatsFile() ) ); setEstimateNumberOfFeatures(reader->readValue("EstimateNumberOfFeatures", getEstimateNumberOfFeatures() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void EstablishMatrixPhase::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setOutputCellAttributeMatrixPath( reader->readDataArrayPath("OutputCellAttributeMatrixPath", getOutputCellAttributeMatrixPath() ) ); setOutputCellFeatureAttributeMatrixName( reader->readString("OutputCellFeatureAttributeMatrixName", getOutputCellFeatureAttributeMatrixName() ) ); setOutputCellEnsembleAttributeMatrixName( reader->readString("OutputCellEnsembleAttributeMatrixName", getOutputCellEnsembleAttributeMatrixName() ) ); setFeatureIdsArrayName( reader->readString("FeatureIdsArrayName", getFeatureIdsArrayName() ) ); setCellPhasesArrayName( reader->readString("CellPhasesArrayName", getCellPhasesArrayName() ) ); setUseMask(reader->readValue("UseMask", getUseMask())); setMaskArrayPath(reader->readDataArrayPath("MaskArrayPath", getMaskArrayPath())); setFeaturePhasesArrayName(reader->readString("FeaturePhasesArrayName", getFeaturePhasesArrayName())); setNumFeaturesArrayName( reader->readString("NumFeaturesArrayName", getNumFeaturesArrayName() ) ); setInputStatsArrayPath(reader->readDataArrayPath("InputStatsArrayPath", getInputStatsArrayPath() ) ); setInputPhaseTypesArrayPath(reader->readDataArrayPath("InputPhaseTypesArrayPath", getInputPhaseTypesArrayPath() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QString InitializeSyntheticVolume::estimateNumFeatures(IntVec3_t dims, FloatVec3_t res) { float totalvol = 0.0f; int32_t phase = 0; totalvol = (dims.x * res.x) * (dims.y * res.y) * (dims.z * res.z); if (totalvol == 0.0) { return "-1"; } DataContainerArray::Pointer dca = getDataContainerArray(); // Get the PhaseTypes - Remember there is a Dummy PhaseType in the first slot of the array QVector<size_t> cDims(1, 1); // This states that we are looking for an array with a single component UInt32ArrayType::Pointer phaseType = dca->getPrereqArrayFromPath<UInt32ArrayType, AbstractFilter>(NULL, getInputPhaseTypesArrayPath(), cDims); if (phaseType.get() == NULL) { QString ss = QObject::tr("Phase types array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputPhaseTypesArrayPath().serialize()); setErrorCondition(-11002); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return "0"; } QVector<size_t> statsDims(1, 1); StatsDataArray::Pointer statsPtr = dca->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), statsDims); if (statsPtr.get() == NULL) { QString ss = QObject::tr("Statistics array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputStatsArrayPath().serialize()); notifyErrorMessage(getHumanLabel(), ss, -11001); return "0"; } if (!phaseType->isAllocated()) { if (getInputStatsFile().isEmpty()) { QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file is empty"); setErrorCondition(-1000); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } QFileInfo fi(getInputStatsFile()); if (fi.exists() == false) { QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file does not exist at '%1'").arg(fi.absoluteFilePath()); setErrorCondition(-1001); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } hid_t fileId = -1; herr_t err = 0; // open the file fileId = H5Utilities::openFile(getInputStatsFile().toLatin1().constData(), true); // This will make sure if we return early from this method that the HDF5 File is properly closed. HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true); DataArrayPath dap = getInputPhaseTypesArrayPath(); // Generate the path to the AttributeMatrix QString hPath = DREAM3D::StringConstants::DataContainerGroupName + "/" + dap.getDataContainerName() + "/" + dap.getAttributeMatrixName(); // Open the AttributeMatrix Group hid_t amGid = H5Gopen(fileId, hPath.toLatin1().data(), H5P_DEFAULT ); scopedFileSentinel.addGroupId(&amGid); err = phaseType->readH5Data(amGid); if (err < 0) { QString ss = QObject::tr("Error reading phase type data"); setErrorCondition(-1003); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } if (!phaseType->isAllocated()) { QString ss = QObject::tr("Phase types Array was not allocated due to an error reading the data from the statistics file %1").arg(fi.absoluteFilePath()); setErrorCondition(-1002); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } } // Create a Reference Variable so we can use the [] syntax StatsDataArray& statsDataArray = *(statsPtr.get()); std::vector<int32_t> primaryphases; std::vector<double> primaryphasefractions; double totalprimaryfractions = 0.0; // find which phases are primary phases for (size_t i = 1; i < phaseType->getNumberOfTuples(); ++i) { if (phaseType->getValue(i) == DREAM3D::PhaseType::PrimaryPhase) { PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[i].get()); primaryphases.push_back(i); primaryphasefractions.push_back(pp->getPhaseFraction()); totalprimaryfractions = totalprimaryfractions + pp->getPhaseFraction(); } } // scale the primary phase fractions to total to 1 for (int32_t i = 0; i < primaryphasefractions.size(); i++) { primaryphasefractions[i] = primaryphasefractions[i] / totalprimaryfractions; } SIMPL_RANDOMNG_NEW() // generate the Features int32_t gid = 1; float currentvol = 0.0f; float vol = 0.0f; float diam = 0.0f; bool volgood = false; for (int32_t j = 0; j < primaryphases.size(); ++j) { float curphasetotalvol = totalvol * primaryphasefractions[j]; while (currentvol < curphasetotalvol) { volgood = false; phase = primaryphases[j]; PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[phase].get()); if (NULL == pp) { QString ss = QObject::tr("Tried to cast a statsDataArray[%1].get() to a PrimaryStatsData* " "pointer but this resulted in a NULL pointer.\n") .arg(phase).arg(phase); setErrorCondition(-666); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } while (volgood == false) { volgood = true; if (pp->getFeatureSize_DistType() == DREAM3D::DistributionType::LogNormal) { float avgdiam = pp->getFeatureSizeDistribution().at(0)->getValue(0); float sddiam = pp->getFeatureSizeDistribution().at(1)->getValue(0); diam = rg.genrand_norm(avgdiam, sddiam); diam = expf(diam); if (diam >= pp->getMaxFeatureDiameter()) { volgood = false; } if (diam < pp->getMinFeatureDiameter()) { volgood = false; } vol = (4.0f / 3.0f) * (M_PI) * ((diam * 0.5f) * (diam * 0.5f) * (diam * 0.5f)); } } currentvol = currentvol + vol; gid++; } } return QString::number(gid); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void InitializeSyntheticVolume::dataCheck() { setErrorCondition(0); // Create the output Data Container DataContainer::Pointer m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName()); if(getErrorCondition() < 0) { return; } ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry); m->setGeometry(image); // Sanity Check the Dimensions and Resolution INIT_SYNTH_VOLUME_CHECK(Dimensions.x, -5000); INIT_SYNTH_VOLUME_CHECK(Dimensions.y, -5001); INIT_SYNTH_VOLUME_CHECK(Dimensions.z, -5002); INIT_SYNTH_VOLUME_CHECK(Resolution.x, -5003); INIT_SYNTH_VOLUME_CHECK(Resolution.y, -5004); INIT_SYNTH_VOLUME_CHECK(Resolution.z, -5005); // Set the Dimensions, Resolution and Origin of the output data container m->getGeometryAs<ImageGeom>()->setDimensions(m_Dimensions.x, m_Dimensions.y, m_Dimensions.z); m->getGeometryAs<ImageGeom>()->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z); m->getGeometryAs<ImageGeom>()->setOrigin(m_Origin.x, m_Origin.y, m_Origin.z); // Create our output Cell and Ensemble Attribute Matrix objects QVector<size_t> tDims(3, 0); tDims[0] = m_Dimensions.x; tDims[1] = m_Dimensions.y; tDims[2] = m_Dimensions.z; AttributeMatrix::Pointer cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell); if(getErrorCondition() < 0 && cellAttrMat.get() == NULL) { return; } QVector<size_t> cDims(1, 1); // This states that we are looking for an array with a single component UInt32ArrayType::Pointer phaseType = getDataContainerArray()->getPrereqArrayFromPath<UInt32ArrayType, AbstractFilter>(this, getInputPhaseTypesArrayPath(), cDims); if(getErrorCondition() < 0 && phaseType.get() == NULL) { return; } QVector<size_t> statsDims(1, 1); StatsDataArray::Pointer statsPtr = getDataContainerArray()->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), statsDims); if(getErrorCondition() < 0 && statsPtr.get() == NULL) { return; } if(m_EstimateNumberOfFeatures) { m_EstimatedPrimaryFeatures = estimateNumFeatures(m_Dimensions, m_Resolution); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void InitializeSyntheticVolume::setupFilterParameters() { FilterParameterVector parameters; QStringList linkedProps("EstimatedPrimaryFeatures"); linkedProps << "InputStatsFile"; parameters.push_back(LinkedBooleanFilterParameter::New("Estimate Number of Features", "EstimateNumberOfFeatures", getEstimateNumberOfFeatures(), linkedProps, FilterParameter::Parameter)); parameters.push_back(InputFileFilterParameter::New("Input Statistics File", "InputStatsFile", getInputStatsFile(), FilterParameter::Parameter, "*.dream3d")); PreflightUpdatedValueFilterParameter::Pointer param = PreflightUpdatedValueFilterParameter::New("Estimated Primary Features", "EstimatedPrimaryFeatures", getEstimatedPrimaryFeatures(), FilterParameter::Parameter); param->setReadOnly(true); parameters.push_back(param); parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::RequiredArray)); { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::StatsDataArray, 1, DREAM3D::AttributeMatrixType::CellEnsemble, DREAM3D::Defaults::AnyGeometry); QVector<uint32_t> geomTypes; geomTypes.push_back(DREAM3D::GeometryType::ImageGeometry); geomTypes.push_back(DREAM3D::GeometryType::UnknownGeometry); req.dcGeometryTypes = geomTypes; parameters.push_back(DataArraySelectionFilterParameter::New("Statistics", "InputStatsArrayPath", getInputStatsArrayPath(), FilterParameter::RequiredArray, req)); } { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::UInt32, 1, DREAM3D::AttributeMatrixType::CellEnsemble, DREAM3D::Defaults::AnyGeometry); QVector<uint32_t> geomTypes; geomTypes.push_back(DREAM3D::GeometryType::ImageGeometry); geomTypes.push_back(DREAM3D::GeometryType::UnknownGeometry); req.dcGeometryTypes = geomTypes; parameters.push_back(DataArraySelectionFilterParameter::New("Phase Types", "InputPhaseTypesArrayPath", getInputPhaseTypesArrayPath(), FilterParameter::RequiredArray, req)); } parameters.push_back(StringFilterParameter::New("Synthetic Volume Data Container", "DataContainerName", getDataContainerName(), FilterParameter::CreatedArray)); parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray)); parameters.push_back(StringFilterParameter::New("Cell Attribute Matrix", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray)); parameters.push_back(IntVec3FilterParameter::New("Dimensions", "Dimensions", getDimensions(), FilterParameter::Parameter)); parameters.push_back(FloatVec3FilterParameter::New("Resolution", "Resolution", getResolution(), FilterParameter::Parameter)); parameters.push_back(FloatVec3FilterParameter::New("Origin", "Origin", getOrigin(), FilterParameter::Parameter)); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void EstablishMatrixPhase::dataCheck() { setErrorCondition(0); DataArrayPath tempPath; getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getOutputCellAttributeMatrixPath().getDataContainerName()); QVector<size_t> cDims(1, 1); m_PhaseTypesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<uint32_t>, AbstractFilter>(this, getInputPhaseTypesArrayPath(), cDims); if( NULL != m_PhaseTypesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_PhaseTypes = m_PhaseTypesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ m_StatsDataArray = getDataContainerArray()->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), cDims); if(m_StatsDataArray.lock() == NULL) { QString ss = QObject::tr("Statistics array is not initialized correctly. The path is %1").arg(getInputStatsArrayPath().serialize()); setErrorCondition(-308); notifyErrorMessage(getHumanLabel(), ss, -308); } cDims[0] = 1; // Cell Data tempPath.update(getOutputCellAttributeMatrixPath().getDataContainerName(), getOutputCellAttributeMatrixPath().getAttributeMatrixName(), getFeatureIdsArrayName() ); m_FeatureIdsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, -1, cDims); /* Assigns the shared_ptr<>(this, tempPath, -1, dims); Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_FeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_FeatureIds = m_FeatureIdsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ tempPath.update(getOutputCellAttributeMatrixPath().getDataContainerName(), getOutputCellAttributeMatrixPath().getAttributeMatrixName(), getCellPhasesArrayName() ); m_CellPhasesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, cDims); /* Assigns the shared_ptr<>(this, tempPath, 0, dims); Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_CellPhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_CellPhases = m_CellPhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if (m_UseMask == true) { m_MaskPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<bool>, AbstractFilter>(this, getMaskArrayPath(), cDims); if (NULL != m_MaskPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_Mask = m_MaskPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ } if(getErrorCondition() < 0) { return; } DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getOutputCellAttributeMatrixPath().getDataContainerName()); QVector<size_t> tDims(1, 0); AttributeMatrix::Pointer cellFeatureAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getOutputCellFeatureAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellFeature); if(getErrorCondition() < 0 || NULL == cellFeatureAttrMat.get()) { return; } tDims[0] = m_PhaseTypesPtr.lock()->getNumberOfTuples(); AttributeMatrix::Pointer cellEnsembleAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getOutputCellEnsembleAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellEnsemble); if(getErrorCondition() < 0 || NULL == cellEnsembleAttrMat.get()) { return; } // Feature Data tempPath.update(getOutputCellAttributeMatrixPath().getDataContainerName(), getOutputCellFeatureAttributeMatrixName(), getFeaturePhasesArrayName() ); m_FeaturePhasesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_FeaturePhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_FeaturePhases = m_FeaturePhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ // Ensemble Data tempPath.update(getOutputCellAttributeMatrixPath().getDataContainerName(), getOutputCellEnsembleAttributeMatrixName(), getNumFeaturesArrayName() ); m_NumFeaturesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_NumFeaturesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_NumFeatures = m_NumFeaturesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void EstablishMatrixPhase::setupFilterParameters() { FilterParameterVector parameters; QStringList linkedProps("MaskArrayPath"); parameters.push_back(LinkedBooleanFilterParameter::New("Use Mask", "UseMask", getUseMask(), linkedProps, FilterParameter::Parameter)); parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray)); { AttributeMatrixSelectionFilterParameter::RequirementType req = AttributeMatrixSelectionFilterParameter::CreateRequirement(DREAM3D::AttributeMatrixType::Cell, DREAM3D::GeometryType::ImageGeometry); parameters.push_back(AttributeMatrixSelectionFilterParameter::New("Cell Attribute Matrix", "OutputCellAttributeMatrixPath", getOutputCellAttributeMatrixPath(), FilterParameter::RequiredArray, req)); } parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray)); parameters.push_back(StringFilterParameter::New("Feature Ids", "FeatureIdsArrayName", getFeatureIdsArrayName(), FilterParameter::CreatedArray)); parameters.push_back(StringFilterParameter::New("Phases", "CellPhasesArrayName", getCellPhasesArrayName(), FilterParameter::CreatedArray)); { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::TypeNames::Bool, 1, DREAM3D::AttributeMatrixObjectType::Element); parameters.push_back(DataArraySelectionFilterParameter::New("Mask", "MaskArrayPath", getMaskArrayPath(), FilterParameter::RequiredArray, req)); } parameters.push_back(SeparatorFilterParameter::New("Cell Feature Data", FilterParameter::CreatedArray)); parameters.push_back(StringFilterParameter::New("Cell Feature Attribute Matrix", "OutputCellFeatureAttributeMatrixName", getOutputCellFeatureAttributeMatrixName(), FilterParameter::CreatedArray)); parameters.push_back(StringFilterParameter::New("Phases", "FeaturePhasesArrayName", getFeaturePhasesArrayName(), FilterParameter::CreatedArray)); parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::RequiredArray)); { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::StatsDataArray, 1, DREAM3D::AttributeMatrixType::CellEnsemble, DREAM3D::Defaults::AnyGeometry); QVector<uint32_t> geomTypes; geomTypes.push_back(DREAM3D::GeometryType::ImageGeometry); geomTypes.push_back(DREAM3D::GeometryType::UnknownGeometry); req.dcGeometryTypes = geomTypes; parameters.push_back(DataArraySelectionFilterParameter::New("Statistics", "InputStatsArrayPath", getInputStatsArrayPath(), FilterParameter::RequiredArray, req)); } { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(DREAM3D::TypeNames::UInt32, 1, DREAM3D::AttributeMatrixType::CellEnsemble, DREAM3D::Defaults::AnyGeometry); QVector<uint32_t> geomTypes; geomTypes.push_back(DREAM3D::GeometryType::ImageGeometry); geomTypes.push_back(DREAM3D::GeometryType::UnknownGeometry); req.dcGeometryTypes = geomTypes; parameters.push_back(DataArraySelectionFilterParameter::New("Phase Types", "InputPhaseTypesArrayPath", getInputPhaseTypesArrayPath(), FilterParameter::RequiredArray, req)); } parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::CreatedArray)); parameters.push_back(StringFilterParameter::New("Cell Ensemble Attribute Matrix", "OutputCellEnsembleAttributeMatrixName", getOutputCellEnsembleAttributeMatrixName(), FilterParameter::CreatedArray)); parameters.push_back(StringFilterParameter::New("Number of Features", "NumFeaturesArrayName", getNumFeaturesArrayName(), FilterParameter::CreatedArray)); setFilterParameters(parameters); }