// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CopyAttributeArray::dataCheck()
{
setErrorCondition(0);
if(m_NewArrayName.isEmpty() == true)
{
setErrorCondition(-11009);
QString ss = QObject::tr("The new Attribute Array name must be set");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
QString daName = getSelectedArrayPath().getDataArrayName();
IDataArray::Pointer dataArray = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getSelectedArrayPath());
if(getErrorCondition() < 0) { return; }
DataArrayPath path(getSelectedArrayPath().getDataContainerName(), getSelectedArrayPath().getAttributeMatrixName(), "");
AttributeMatrix::Pointer attrMat = getDataContainerArray()->getAttributeMatrix(path);
IDataArray::Pointer pNew = dataArray->deepCopy();
pNew->setName(m_NewArrayName); // Set the name of the array
int32_t err = attrMat->addAttributeArray(m_NewArrayName, pNew);
if (0 != err)
{
setErrorCondition(err);
QString ss = QObject::tr("Attempt to copy Attribute Array '%1' to '%2' failed").arg(daName).arg(m_NewArrayName);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RemoveComponentFromArray::dataCheck()
{
setErrorCondition(0);
m_InArrayPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getSelectedArrayPath());
if (m_SaveRemovedComponent == true)
{
if (m_NewArrayArrayName.isEmpty() == true)
{
setErrorCondition(-11001);
notifyErrorMessage(getHumanLabel(), "Removed Component array name must be set.", getErrorCondition());
return;
}
}
if (m_ReducedArrayArrayName.isEmpty() == true)
{
setErrorCondition(-11002);
notifyErrorMessage(getHumanLabel(), "Reduced array name must be set.", getErrorCondition());
return;
}
if(getErrorCondition() < 0) { return; }
if (m_InArrayPtr.lock()->getNumberOfComponents() < 2)
{
setErrorCondition(-11003);
QString ss = QObject::tr("Selected array '%1' must have more than 1 component. The number of components is %2").arg(getSelectedArrayPath().getDataArrayName()).arg(m_InArrayPtr.lock()->getNumberOfComponents());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
if(m_CompNumber >= m_InArrayPtr.lock()->getNumberOfComponents())
{
setErrorCondition(-11004);
QString ss = QObject::tr("Component to extract (%1) is larger than the number of components (%2) for array selected: '%1'").arg(m_CompNumber).arg(m_InArrayPtr.lock()->getNumberOfComponents()).arg(getSelectedArrayPath().getDataArrayName());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
QVector<size_t> cDims(1, 1);
if (m_SaveRemovedComponent == true)
{
DataArrayPath tempPath(getSelectedArrayPath().getDataContainerName(), getSelectedArrayPath().getAttributeMatrixName(), getNewArrayArrayName());
m_NewArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, cDims, m_InArrayPtr.lock());
}
cDims[0] = m_InArrayPtr.lock()->getNumberOfComponents() - 1;
DataArrayPath tempPath2(getSelectedArrayPath().getDataContainerName(), getSelectedArrayPath().getAttributeMatrixName(), getReducedArrayArrayName());
m_ReducedArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath2, cDims, m_InArrayPtr.lock());
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CopyAttributeArray::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setSelectedArrayPath( reader->readDataArrayPath("SelectedArrayPath", getSelectedArrayPath()) );
setNewArrayName( reader->readString( "NewArrayName", getNewArrayName() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConditionalSetValue::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setConditionalArrayPath(reader->readDataArrayPath("ConditionalArrayPath", getConditionalArrayPath()));
setSelectedArrayPath(reader->readDataArrayPath("SelectedArrayPath", getSelectedArrayPath()));
setReplaceValue(reader->readValue("ReplaceValue", getReplaceValue()));
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RemoveComponentFromArray::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setNewArrayArrayName(reader->readString("NewArrayArrayName", getNewArrayArrayName() ) );
setNewArrayArrayName(reader->readString("ReducedArrayArrayName", getReducedArrayArrayName() ) );
setCompNumber(reader->readValue("CompNumber", getCompNumber() ) );
setSelectedArrayPath( reader->readDataArrayPath( "SelectedArrayPath", getSelectedArrayPath() ) );
setSaveRemovedComponent(reader->readValue("SaveRemovedComponent", getSaveRemovedComponent()));
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConditionalSetValue::dataCheck()
{
setErrorCondition(0);
QVector<DataArrayPath> dataArrayPaths;
m_ArrayPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getSelectedArrayPath());
if (getErrorCondition() < 0) { return; }
if (getErrorCondition() >= 0) { dataArrayPaths.push_back(getSelectedArrayPath()); }
if (m_ArrayPtr.lock()->getNumberOfComponents() > 1)
{
QString ss = QObject::tr("Selected array '%1' must be a scalar array (1 component). The number of components is %2").arg(getSelectedArrayPath().getDataArrayName()).arg(m_ArrayPtr.lock()->getNumberOfComponents());
setErrorCondition(-11002);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
QVector<size_t> cDims(1, 1);
m_ConditionalArrayPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<bool>, AbstractFilter>(this, getConditionalArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if (NULL != m_ConditionalArrayPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{
m_ConditionalArray = m_ConditionalArrayPtr.lock()->getPointer(0);
} /* Now assign the raw pointer to data from the DataArray<T> object */
if (getErrorCondition() >= 0) { dataArrayPaths.push_back(getConditionalArrayPath()); }
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrayPaths);
QString dType = m_ArrayPtr.lock()->getTypeAsString();
if (dType.compare(DREAM3D::TypeNames::Int8) == 0) { checkValuesInt<int8_t>(this, m_ReplaceValue, DREAM3D::TypeNames::Int8); }
else if (dType.compare(DREAM3D::TypeNames::UInt8) == 0) { checkValuesInt<uint8_t>(this, m_ReplaceValue, DREAM3D::TypeNames::UInt8); }
else if (dType.compare(DREAM3D::TypeNames::Int16) == 0) { checkValuesInt<int16_t>(this, m_ReplaceValue, DREAM3D::TypeNames::Int16); }
else if (dType.compare(DREAM3D::TypeNames::UInt16) == 0) { checkValuesInt<uint16_t>(this, m_ReplaceValue, DREAM3D::TypeNames::UInt16); }
else if (dType.compare(DREAM3D::TypeNames::Int32) == 0) { checkValuesInt<int32_t>(this, m_ReplaceValue, DREAM3D::TypeNames::Int32); }
else if (dType.compare(DREAM3D::TypeNames::UInt32) == 0) { checkValuesInt<uint32_t>(this, m_ReplaceValue, DREAM3D::TypeNames::UInt32); }
else if (dType.compare(DREAM3D::TypeNames::Int64) == 0) { checkValuesInt<int64_t>(this, m_ReplaceValue, DREAM3D::TypeNames::Int64); }
else if (dType.compare(DREAM3D::TypeNames::UInt64) == 0) { checkValuesInt<uint64_t>(this, m_ReplaceValue, DREAM3D::TypeNames::UInt64); }
else if (dType.compare(DREAM3D::TypeNames::Float) == 0) { checkValuesFloatDouble<float>(this, m_ReplaceValue, DREAM3D::TypeNames::Float); }
else if (dType.compare(DREAM3D::TypeNames::Double) == 0) { checkValuesFloatDouble<double>(this, m_ReplaceValue, DREAM3D::TypeNames::Double); }
else if (dType.compare(DREAM3D::TypeNames::Bool) == 0)
{
if (m_ReplaceValue != 0.0)
{
m_ReplaceValue = 1.0; // anything that is not a zero is a one
}
}
else
{
setErrorCondition(-4060);
QString ss = QObject::tr("Incorrect data scalar type");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConditionalSetValue::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(DoubleFilterParameter::New("New Value", "ReplaceValue", getReplaceValue(), FilterParameter::Parameter));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::TypeNames::Bool, 1, DREAM3D::AttributeMatrixObjectType::Any);
parameters.push_back(DataArraySelectionFilterParameter::New("Conditional Array", "ConditionalArrayPath", getConditionalArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::Defaults::AnyPrimitive, 1, DREAM3D::AttributeMatrixObjectType::Any);
parameters.push_back(DataArraySelectionFilterParameter::New("Attribute Array", "SelectedArrayPath", getSelectedArrayPath(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CopyAttributeArray::setupFilterParameters()
{
FilterParameterVector parameters;
{
DataArraySelectionFilterParameter::RequirementType req;
parameters.push_back(DataArraySelectionFilterParameter::New("Attribute Array to Copy", "SelectedArrayPath", getSelectedArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(StringFilterParameter::New("Copied Attribute Array", "NewArrayName", getNewArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RemoveComponentFromArray::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(IntFilterParameter::New("Component Number to Remove", "CompNumber", getCompNumber(), FilterParameter::Parameter));
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::Defaults::AnyPrimitive, DREAM3D::Defaults::AnyComponentSize, DREAM3D::AttributeMatrixObjectType::Any);
parameters.push_back(DataArraySelectionFilterParameter::New("Multicomponent Attribute Array", "SelectedArrayPath", getSelectedArrayPath(), FilterParameter::RequiredArray, req));
parameters.push_back(StringFilterParameter::New("Removed Component Attribute Array", "NewArrayArrayName", getNewArrayArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Reduced Attribute Array", "ReducedArrayArrayName", getReducedArrayArrayName(), FilterParameter::CreatedArray));
QStringList linkedProps;
linkedProps.clear();
linkedProps << "NewArrayArrayName";
parameters.push_back(LinkedBooleanFilterParameter::New("Save Removed Component in New Array", "SaveRemovedComponent", getSaveRemovedComponent(), linkedProps, FilterParameter::Parameter));
setFilterParameters(parameters);
}
