// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AlignSections::dataCheck() { setErrorCondition(0); DataArrayPath tempPath; ImageGeom::Pointer image = getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getDataContainerName()); if(getErrorCondition() < 0) { return; } if (image->getXPoints() <= 1 || image->getYPoints() <= 1 || image->getZPoints() <= 1) { QString ss = QObject::tr("The Image Geometry is not 3D and cannot be run through this filter. The dimensions are (%1,%2,%3)").arg(image->getXPoints()).arg(image->getYPoints()).arg(image->getZPoints()); setErrorCondition(-3010); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), ""); getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, tempPath, -301); if (true == m_WriteAlignmentShifts && m_AlignmentShiftFileName.isEmpty() == true) { QString ss = QObject::tr("The alignment shift file name is empty"); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FileWriter::execute() { setErrorCondition(0); // Make sure any directory path is also available as the user may have just typed // in a path without actually creating the full path QFileInfo fi(m_OutputFile); QString parentPath = fi.path(); QDir dir; if (!dir.mkpath(parentPath)) { setErrorCondition(-200); QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } int32_t err = writeHeader(); if (err < 0) { QString ss = QObject::tr("Error writing the header portion of the file"); setErrorCondition(err); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } err = writeFile(); if (err < 0) { QString ss = QObject::tr("Error writing the data to the file"); setErrorCondition(err); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- 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 RenameAttributeMatrix::dataCheck() { setErrorCondition(0); if (m_NewAttributeMatrix.isEmpty() == true) { setErrorCondition(-11004); QString ss = QObject::tr("The new Attribute Matrix name must be set"); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } QString amName = getSelectedAttributeMatrixPath().getAttributeMatrixName(); DataContainer::Pointer dc = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getSelectedAttributeMatrixPath().getDataContainerName()); getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, getSelectedAttributeMatrixPath(), -301); if(getErrorCondition() < 0) { return; } bool check = dc->renameAttributeMatrix(amName, getNewAttributeMatrix() ); if (check == false) { setErrorCondition(-11006); QString ss = QObject::tr("Attempt to rename Attribute Matrix '%1' to '%2' failed").arg(amName).arg(getNewAttributeMatrix()); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void MoveData::dataCheck() { setErrorCondition(0); DataArrayPath amSrcPath = getAttributeMatrixSource(); DataArrayPath amDestPath = getAttributeMatrixDestination(); DataArrayPath daSrcPath = getDataArraySource(); if (getWhatToMove() == k_MoveAttributeMatrix) { DataContainer::Pointer amDestDataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerDestination()); DataContainer::Pointer amSrcDataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, amSrcPath.getDataContainerName()); AttributeMatrix::Pointer amSrcAttributeMatrix = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, amSrcPath, -301); if(getErrorCondition() < 0) { return; } if (amSrcDataContainer->getName() == amDestDataContainer->getName()) { QString ss = QObject::tr("The source and destination Data Container are the same. Is this what you meant to do?"); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return; } amDestDataContainer->addAttributeMatrix(amSrcAttributeMatrix->getName(), amSrcAttributeMatrix); amSrcDataContainer->removeAttributeMatrix(amSrcAttributeMatrix->getName()); } else if (getWhatToMove() == k_MoveDataArray ) { AttributeMatrix::Pointer daSrcAttributeMatrix = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, daSrcPath, -301); AttributeMatrix::Pointer daDestAttributeMatrix = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, amDestPath, -301); IDataArray::Pointer daSrcDataArray = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, daSrcPath); if(getErrorCondition() < 0) { return; } if (daDestAttributeMatrix->getNumTuples() != daSrcDataArray->getNumberOfTuples()) { setErrorCondition(-11019); QString ss = QObject::tr("The number of tuples of source Attribute Array (%1) and destination Attribute Matrix (%2) do not match").arg(daSrcDataArray->getNumberOfTuples()).arg(daDestAttributeMatrix->getNumTuples()); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } else if (amSrcPath == amDestPath) { QString ss = QObject::tr("The source and destination Attribute Matrix are the same. Is this what you meant to do?"); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return; } daDestAttributeMatrix->addAttributeArray(daSrcPath.getDataArrayName(), daSrcDataArray); daSrcAttributeMatrix->removeAttributeArray(daSrcPath.getDataArrayName()); } else { setErrorCondition(-11020); QString ss = QObject::tr("Neither an Attribute Matrix nor an Attribute Array was selected to be moved"); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ConvertOrientations::dataCheck() { setErrorCondition(0); if(getInputType() == getOutputType()) { QString ss = QObject::tr("Input and output orientation representation types must be different"); setErrorCondition(-1000); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } if( getInputType() < OrientationConverter<float>::GetMinIndex() || getInputType() > OrientationConverter<float>::GetMaxIndex() ) { QString ss = QObject::tr("There was an error with teh selection of the input orientation type. The valid values range from 0 to %1").arg(OrientationConverter<float>::GetMaxIndex()); setErrorCondition(-1001); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } if( getOutputType() < OrientationConverter<float>::GetMinIndex() || getOutputType() > OrientationConverter<float>::GetMaxIndex() ) { QString ss = QObject::tr("There was an error with the selection of the output orientation type. The valid values range from 0 to %1").arg(OrientationConverter<float>::GetMaxIndex()); setErrorCondition(-1002); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } // We need to return NOW because the next lines assume we have and index that is within // the valid bounds if(getErrorCondition() < 0) { return; } // Figure out what kind of Array the user selected // Get the input data and create the output Data appropriately IDataArray::Pointer iDataArrayPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getInputOrientationArrayPath()); DataArrayPath outputArrayPath = getInputOrientationArrayPath(); outputArrayPath.setDataArrayName(getOutputOrientationArrayName()); FloatArrayType::Pointer fArray = std::dynamic_pointer_cast<FloatArrayType>(iDataArrayPtr); if(NULL != fArray.get()) { QVector<int32_t> componentCounts = OrientationConverter<float>::GetComponentCounts(); QVector<size_t> outputCDims(1, componentCounts[getOutputType()]); getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, outputArrayPath, 0, outputCDims); } DoubleArrayType::Pointer dArray = std::dynamic_pointer_cast<DoubleArrayType>(iDataArrayPtr); if(NULL != dArray.get()) { QVector<int32_t> componentCounts = OrientationConverter<double>::GetComponentCounts(); QVector<size_t> outputCDims(1, componentCounts[getOutputType()]); getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<double>, AbstractFilter, double>(this, outputArrayPath, 0, outputCDims); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- 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 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 VisualizeGBCDPoleFigure::dataCheck() { setErrorCondition(0); getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getGBCDArrayPath().getDataContainerName()); if (getOutputFile().isEmpty() == true) { QString ss = QObject::tr( "The output file must be set"); setErrorCondition(-1000); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } QFileInfo fi(getOutputFile()); QDir parentPath = fi.path(); if (parentPath.exists() == false && getInPreflight()) { QString ss = QObject::tr( "The directory path for the output file does not exist. DREAM.3D will attempt to create this path during execution of the filter"); notifyWarningMessage(getHumanLabel(), ss, -1); } if (fi.suffix().compare("") == 0) { setOutputFile(getOutputFile().append(".vtk")); } QVector<size_t> cDims(1, 1); m_CrystalStructuresPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<unsigned int>, AbstractFilter>(this, getCrystalStructuresArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if (NULL != m_CrystalStructuresPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_CrystalStructures = m_CrystalStructuresPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ IDataArray::Pointer tmpGBCDPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getGBCDArrayPath()); if(getErrorCondition() < 0) { return; } if (NULL != tmpGBCDPtr.get()) { QVector<size_t> cDims = tmpGBCDPtr->getComponentDimensions(); m_GBCDPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<double>, AbstractFilter>(this, getGBCDArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_GBCDPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_GBCD = m_GBCDPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ } if (NULL != m_GBCDPtr.lock().get() && getPhaseOfInterest() >= m_GBCDPtr.lock()->getNumberOfTuples()) { QString ss = QObject::tr("The phase index is larger than the number of Ensembles").arg(ClassName()); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int VoxelDataContainerWriter::writeEnsembleData(hid_t dcGid) { std::stringstream ss; int err = 0; VoxelDataContainer* m = getVoxelDataContainer(); // Write the Ensemble data err = H5Utilities::createGroupsFromPath(H5_ENSEMBLE_DATA_GROUP_NAME, dcGid); if(err < 0) { ss.str(""); ss << "Error creating HDF Group " << H5_ENSEMBLE_DATA_GROUP_NAME << std::endl; setErrorCondition(-66); notifyErrorMessage( ss.str(), err); H5Gclose(dcGid); // Close the Data Container Group return err; } err = H5Lite::writeStringAttribute(dcGid, H5_ENSEMBLE_DATA_GROUP_NAME, H5_NAME, H5_ENSEMBLE_DATA_DEFAULT); hid_t ensembleGid = H5Gopen(dcGid, H5_ENSEMBLE_DATA_GROUP_NAME, H5P_DEFAULT); if(err < 0) { ss.str(""); ss << "Error opening ensemble Group " << H5_ENSEMBLE_DATA_GROUP_NAME << std::endl; setErrorCondition(-67); notifyErrorMessage( ss.str(), err); H5Gclose(dcGid); // Close the Data Container Group return err; } NameListType names = m->getEnsembleArrayNameList(); for (NameListType::iterator iter = names.begin(); iter != names.end(); ++iter) { IDataArray::Pointer array = m->getEnsembleData(*iter); err = array->writeH5Data(ensembleGid); if(err < 0) { ss.str(""); ss << "Error writing Ensemble array '" << *iter << "' to the HDF5 File"; notifyErrorMessage( ss.str(), err); setErrorCondition(err); H5Gclose(ensembleGid); // Close the Cell Group H5Gclose(dcGid); // Close the Data Container Group return err; } } H5Gclose(ensembleGid); return err; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RegularizeZSpacing::dataCheck() { setErrorCondition(0); if (getNewZRes() <= 0) { QString ss = QObject::tr("The new Z resolution Y (%1) must be positive").arg(getNewZRes()); setErrorCondition(-5555); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } std::ifstream inFile; inFile.open(m_InputFile.toLatin1().data()); if (!inFile.good()) { QString ss = QObject::tr("Unable to open input file with name '%1'").arg(getInputFile()); setErrorCondition(-5556); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } ImageGeom::Pointer image = getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getCellAttributeMatrixPath().getDataContainerName()); AttributeMatrix::Pointer cellAttrMat = getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, getCellAttributeMatrixPath(), -301); if(getErrorCondition() < 0) { return; } float zval = 0.0f; for (size_t iter = 0; iter < image->getZPoints() + 1; iter++) { inFile >> zval; } size_t zP = static_cast<size_t>(zval / getNewZRes()); if(zP == 0) { zP = 1; } if (getInPreflight()) { image->setDimensions(image->getXPoints(), image->getYPoints(), zP); QVector<size_t> tDims(3, 0); tDims[0] = image->getXPoints(); tDims[1] = image->getYPoints(); tDims[2] = zP; cellAttrMat->resizeAttributeArrays(tDims); } inFile.close(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AvizoRectilinearCoordinateWriter::execute() { int err = 0; setErrorCondition(err); VoxelDataContainer* m = getVoxelDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The DataContainer Object was NULL", -999); return; } setErrorCondition(0); // Make sure any directory path is also available as the user may have just typed // in a path without actually creating the full path std::string parentPath = MXAFileInfo::parentPath(m_OutputFile); if(!MXADir::mkdir(parentPath, true)) { std::stringstream ss; ss << "Error creating parent path '" << parentPath << "'"; notifyErrorMessage(ss.str(), -1); setErrorCondition(-1); return; } int64_t totalPoints = m->getTotalPoints(); size_t totalFields = m->getNumFieldTuples(); size_t totalEnsembleTuples = m->getNumEnsembleTuples(); dataCheck(false, totalPoints, totalFields, totalEnsembleTuples); MXAFileWriter64 writer(m_OutputFile); if(false == writer.initWriter()) { std::stringstream ss; ss << "Error opening file '" << parentPath << "'"; notifyErrorMessage(ss.str(), -1); setErrorCondition(-1); return; } std::string header = generateHeader(); writer.writeString(header); err = writeData(writer); /* Let the GUI know we are done with this filter */ notifyStatusMessage("Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int VoxelDataContainerWriter::writeFaceData(hid_t dcGid) { std::stringstream ss; int err = 0; VoxelDataContainer* m = getVoxelDataContainer(); // Write the Voxel Data err = H5Utilities::createGroupsFromPath(H5_FACE_DATA_GROUP_NAME, dcGid); if(err < 0) { ss.str(""); ss << "Error creating HDF Group " << H5_FACE_DATA_GROUP_NAME << std::endl; setErrorCondition(-63); notifyErrorMessage( ss.str(), err); H5Gclose(dcGid); // Close the Data Container Group return err; } hid_t FaceGroupId = H5Gopen(dcGid, H5_FACE_DATA_GROUP_NAME, H5P_DEFAULT); if(err < 0) { ss.str(""); ss << "Error writing string attribute to HDF Group " << H5_FACE_DATA_GROUP_NAME << std::endl; setErrorCondition(-64); notifyErrorMessage( ss.str(), err); H5Gclose(dcGid); // Close the Data Container Group return err; } NameListType names = m->getFaceArrayNameList(); for (NameListType::iterator iter = names.begin(); iter != names.end(); ++iter) { ss.str(""); ss << "Writing Face Data '" << *iter << "' to HDF5 File" << std::endl; notifyStatusMessage(ss.str()); IDataArray::Pointer array = m->getFaceData(*iter); err = array->writeH5Data(FaceGroupId); if(err < 0) { ss.str(""); ss << "Error writing array '" << *iter << "' to the HDF5 File"; notifyErrorMessage( ss.str(), err); setErrorCondition(err); H5Gclose(FaceGroupId); // Close the Face Group H5Gclose(dcGid); // Close the Data Container Group return err; } } H5Gclose(FaceGroupId); // Close the Face Group return err; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ImportR3DStack::readXYSize(int &x, int &y) { if (m_R3DFileList.size() == 0) { x = -1; y = -1; return; } QString r3dFName = QString::fromStdString(m_R3DFileList[0]); QByteArray buf; QFile in(r3dFName); if (!in.open(QIODevice::ReadOnly | QIODevice::Text)) { QString msg = QString("R3D file could not be opened: ") + r3dFName; setErrorCondition(-14000); notifyErrorMessage(msg.toStdString(), getErrorCondition()); } buf = in.readLine(); // Read first line which is the x and y sizes QList<QByteArray> tokens = buf.split(','); if(tokens.size() < 2) { setErrorCondition(-2002); notifyErrorMessage("Header line is an incorrect length", getErrorCondition()); x = -1; y = -1; return; } bool ok = false; x = tokens.at(0).toInt(&ok, 10); if (!ok) { setErrorCondition(-2000); notifyErrorMessage("Width dimension entry was not an integer", getErrorCondition()); return; } y = tokens.at(1).toInt(&ok, 10); if(!ok) { setErrorCondition(-2001); notifyErrorMessage("Height dimension entry was not an integer", getErrorCondition()); return; } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteImages::dataCheck() { setErrorCondition(0); getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getColorsArrayPath().getDataContainerName()); QDir dir(getOutputPath()); if (getOutputPath().isEmpty() == true) { setErrorCondition(-1003); notifyErrorMessage(getHumanLabel(), "The output directory must be set", getErrorCondition()); } else if (dir.exists() == false) { QString ss = QObject::tr("The output directory path does not exist. DREAM.3D will attempt to create this path during execution"); notifyWarningMessage(getHumanLabel(), ss, -1); } IDataArray::Pointer iDa = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getColorsArrayPath()); if (getErrorCondition() < 0) { return; } QVector<size_t> cDims = iDa->getComponentDimensions(); if (cDims[0] == 1) { m_ColorsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<uint8_t>, AbstractFilter>(this, getColorsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if (NULL != m_ColorsPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_Colors = m_ColorsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ } else if (cDims[0] == 3) { m_ColorsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<uint8_t>, AbstractFilter>(this, getColorsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if (NULL != m_ColorsPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_Colors = m_ColorsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ } else if (cDims[0] == 4) { m_ColorsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<uint8_t>, AbstractFilter>(this, getColorsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if (NULL != m_ColorsPtr.lock().get()) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_Colors = m_ColorsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ } else { setErrorCondition(-1006); notifyErrorMessage(getHumanLabel(), "Number of components must be 1 (grayscale), 3 (RGB) or 4 (ARGB) arrays", getErrorCondition()); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AvizoUniformCoordinateWriter::dataCheck() { setErrorCondition(0); DataContainer::Pointer dc = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getFeatureIdsArrayPath().getDataContainerName(), false); if (getErrorCondition() < 0 || NULL == dc.get()) { return; } ImageGeom::Pointer image = dc->getPrereqGeometry<ImageGeom, AbstractFilter>(this); if (getErrorCondition() < 0 || NULL == image.get()) { return; } if(m_OutputFile.isEmpty() == true) { QString ss = QObject::tr("The output file must be set before executing this filter."); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } if(m_WriteFeatureIds == true) { QVector<size_t> dims(1, 1); m_FeatureIdsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeatureIdsArrayPath(), 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 */ } } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void CopyFeatureArrayToElementArray::dataCheck() { setErrorCondition(0); if (getCreatedArrayName().isEmpty() == true) { setErrorCondition(-11002); notifyErrorMessage(getHumanLabel(), "The new Element array name must be set", getErrorCondition()); return; } QVector<size_t> cDims(1, 1); m_FeatureIdsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeatureIdsArrayPath(), cDims); /* 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 */ m_InArrayPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getSelectedFeatureArrayPath()); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ DataArrayPath tempPath(getFeatureIdsArrayPath().getDataContainerName(), getFeatureIdsArrayPath().getAttributeMatrixName(), ""); getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, tempPath, -301); if(getErrorCondition() < 0 ) { return; } tempPath.update(getFeatureIdsArrayPath().getDataContainerName(), getFeatureIdsArrayPath().getAttributeMatrixName(), getCreatedArrayName()); TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, m_InArrayPtr.lock()->getComponentDimensions(), m_InArrayPtr.lock()); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteStlFile::dataCheck() { setErrorCondition(0); TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath().getDataContainerName()); QVector<IDataArray::Pointer> dataArrays; if(getErrorCondition() >= 0) { dataArrays.push_back(triangles->getTriangles()); } if (m_OutputStlDirectory.isEmpty() == true) { setErrorCondition(-1003); notifyErrorMessage(getHumanLabel(), "The output directory must be set", -1003); } QVector<size_t> cDims(1, 2); m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); } if (m_GroupByPhase == true) { m_SurfaceMeshFacePhasesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFacePhasesArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_SurfaceMeshFacePhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_SurfaceMeshFacePhases = m_SurfaceMeshFacePhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFacePhasesPtr.lock()); } } getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrays); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::dataCheck() { setErrorCondition(0); if (m_OutputFile.isEmpty() == true) { setErrorCondition(-1003); notifyErrorMessage(getHumanLabel(), "The output file must be set", getErrorCondition()); } QFileInfo fi(m_OutputFile); QDir parentPath = fi.path(); if (parentPath.exists() == false) { QString ss = QObject::tr( "The directory path for the output file does not exist. DREAM.3D will attempt to create this path during execution of the filter"); notifyWarningMessage(getHumanLabel(), ss, -1); } QVector<IDataArray::Pointer> dataArrays; TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath().getDataContainerName()); if(getErrorCondition() >= 0) { dataArrays.push_back(triangles->getTriangles()); } QVector<size_t> cDims(1, 2); m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); } getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrays); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ReadStlFile::dataCheck() { setErrorCondition(0); DataArrayPath tempPath; if (m_StlFilePath.isEmpty() == true) { setErrorCondition(-1003); notifyErrorMessage(getHumanLabel(), "The input file must be set", -1003); } // Create a SufaceMesh Data Container with Faces, Vertices, Feature Labels and optionally Phase labels DataContainer::Pointer sm = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getSurfaceMeshDataContainerName()); if(getErrorCondition() < 0) { return; } SharedVertexList::Pointer sharedVertList = TriangleGeom::CreateSharedVertexList(0); TriangleGeom::Pointer triangleGeom = TriangleGeom::CreateGeometry(0, sharedVertList, DREAM3D::Geometry::TriangleGeometry); sm->setGeometry(triangleGeom); QVector<size_t> tDims(1, 0); sm->createNonPrereqAttributeMatrix<AbstractFilter>(this, getFaceAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Face); QVector<size_t> cDims(1, 3); tempPath.update(getSurfaceMeshDataContainerName(), getFaceAttributeMatrixName(), getFaceNormalsArrayName() ); m_FaceNormalsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<double>, AbstractFilter, double>(this, tempPath, 0, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_FaceNormalsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_FaceNormals = m_FaceNormalsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GenerateNodeTriangleConnectivity::execute() { int err = 0; std::stringstream ss; setErrorCondition(err); SurfaceMeshDataContainer* m = getSurfaceMeshDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The SurfaceMesh DataContainer Object was NULL", -999); return; } setErrorCondition(0); // Just to double check we have everything. dataCheck(false, 0,0,0); if (getErrorCondition() < 0) { return; } notifyStatusMessage("Starting"); // Generate the connectivity data generateConnectivity(); /* Let the GUI know we are done with this filter */ notifyStatusMessage("Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RequiredZThickness::execute() { setErrorCondition(0); dataCheck(); if(getErrorCondition() < 0) { return; } DataContainer::Pointer dataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerSelection()); if (getErrorCondition() < 0) { return; } ImageGeom::Pointer image = dataContainer->getGeometryAs<ImageGeom>(); size_t dims[3] = { 0, 0, 0 }; image->getDimensions(dims); if (dims[2] < getNumZVoxels()) { QString str; QTextStream ss(&str); ss << "Number of Z Voxels does not meet required value during execution of the filter. \n"; ss << " Required Z Voxels: " << m_NumZVoxels << "\n"; ss << " Current Z Voxels: " << dims[2]; setErrorCondition(-7788); notifyErrorMessage(getHumanLabel(), str, getErrorCondition()); bool needMoreData = true; emit decisionMade(needMoreData); } notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AlignSectionsFeatureCentroid::dataCheck() { setErrorCondition(0); // Set the DataContainerName and AttributematrixName for the Parent Class (AlignSections) to Use. // These are checked for validity in the Parent Class dataCheck setDataContainerName(m_GoodVoxelsArrayPath.getDataContainerName()); setCellAttributeMatrixName(m_GoodVoxelsArrayPath.getAttributeMatrixName()); AlignSections::dataCheck(); if(getErrorCondition() < 0) { return; } ImageGeom::Pointer image = getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, m_GoodVoxelsArrayPath.getDataContainerName()); if(getErrorCondition() < 0) { return; } if (m_ReferenceSlice > image->getZPoints()) { QString ss = QObject::tr("The Image Geometry extent (%1) is smaller than the supplied reference slice (%2)").arg(image->getZPoints()).arg(m_ReferenceSlice); setErrorCondition(-5556); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } QVector<size_t> cDims(1, 1); m_GoodVoxelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<bool>, AbstractFilter>(this, getGoodVoxelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_GoodVoxelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_GoodVoxels = m_GoodVoxelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() < 0) { return; } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void PerPhaseMinSize::preflight() { dataCheck(true, 1, 1, 1); VoxelDataContainer* m = getVoxelDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The DataContainer Object was NULL", -999); return; } RenumberGrains::Pointer renumber_grains = RenumberGrains::New(); renumber_grains->setObservers(this->getObservers()); renumber_grains->setVoxelDataContainer(m); renumber_grains->setMessagePrefix(getMessagePrefix()); renumber_grains->preflight(); int err = renumber_grains->getErrorCondition(); if (err < 0) { setErrorCondition(renumber_grains->getErrorCondition()); addErrorMessages(renumber_grains->getPipelineMessages()); return; } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AdjustVolumeOrigin::execute() { VoxelDataContainer* m = getVoxelDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The DataContainer Object was NULL", -999); return; } setErrorCondition(0); std::stringstream ss; // Set the Voxel Volume First, since this is easy if (m_ApplyToVoxelVolume ==true) { m->setOrigin(m_Origin.x, m_Origin.y, m_Origin.z); } if (m_ApplyToSurfaceMesh == true) { updateSurfaceMesh(); } if (m_ApplyToSolidMesh == true) { updatesSolidMesh(); } notifyStatusMessage("Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int32_t VisualizeGBCDPoleFigure::writeCoords(FILE* f, const char* axis, const char* type, int64_t npoints, float min, float step) { int32_t err = 0; fprintf(f, "%s %lld %s\n", axis, (long long int)(npoints), type); float* data = new float[npoints]; float d; for (int64_t idx = 0; idx < npoints; ++idx) { d = idx * step + min; SIMPLib::Endian::FromSystemToBig::convert(d); data[idx] = d; } size_t totalWritten = fwrite(static_cast<void*>(data), sizeof(float), static_cast<size_t>(npoints), f); delete[] data; if (totalWritten != static_cast<size_t>(npoints) ) { QString ss = QObject::tr("Error writing binary VTK data to file '%1'").arg(m_OutputFile); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); fclose(f); return getErrorCondition(); } return err; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void MinNeighbors::dataCheck() { setErrorCondition(0); QVector<DataArrayPath> dataArrayPaths; if (getMinNumNeighbors() < 0) { QString ss = QObject::tr("The minimum number of neighbors (%1) must be 0 or positive").arg(getMinNumNeighbors()); setErrorCondition(-5555); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getFeatureIdsArrayPath().getDataContainerName()); QVector<size_t> cDims(1, 1); m_FeatureIdsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeatureIdsArrayPath(), cDims); /* 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 */ m_NumNeighborsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getNumNeighborsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_NumNeighborsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_NumNeighbors = m_NumNeighborsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() >= 0) { dataArrayPaths.push_back(getNumNeighborsArrayPath()); } if (getApplyToSinglePhase() == true) { m_FeaturePhasesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeaturePhasesArrayPath(), 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 */ if(getErrorCondition() >= 0) { dataArrayPaths.push_back(getFeaturePhasesArrayPath()); } } getDataContainerArray()->validateNumberOfTuples(this, dataArrayPaths); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AlignSectionsFeature::execute() { setErrorCondition(0); VoxelDataContainer* m = getVoxelDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The DataContainer Object was NULL", -999); return; } int64_t totalPoints = m->getTotalPoints(); size_t numgrains = m->getNumFieldTuples(); size_t numensembles = m->getNumEnsembleTuples(); dataCheck(false, totalPoints, numgrains, numensembles); if (getErrorCondition() < 0) { return; } AlignSections::execute(); // If there is an error set this to something negative and also set a message notifyStatusMessage("Aligning Sections Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QVector<bool> RemoveFlaggedFeatures::remove_flaggedfeatures() { size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples(); bool good = false; int32_t gnum; size_t totalFeatures = m_FlaggedFeaturesPtr.lock()->getNumberOfTuples(); QVector<bool> activeObjects(totalFeatures, true); for (size_t i = 1; i < totalFeatures; i++) { if (m_FlaggedFeatures[i] == false) { good = true; } else { activeObjects[i] = false; } } if (good == false) { setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), "All Features were flagged and would all be removed. The filter has quit.", -1); return activeObjects; } for (size_t i = 0; i < totalPoints; i++) { gnum = m_FeatureIds[i]; if (activeObjects[gnum] == false) { if (m_FillRemovedFeatures == false) { m_FeatureIds[i] = 0; } else { m_FeatureIds[i] = -1; } } } return activeObjects; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AddOrientationNoise::execute() { int err = 0; setErrorCondition(err); DREAM3D_RANDOMNG_NEW() VoxelDataContainer* m = getVoxelDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The DataContainer Object was NULL", -999); return; } int64_t totalPoints = m->getTotalPoints(); size_t totalFields = m->getNumFieldTuples(); dataCheck(false, totalPoints, totalFields, m->getNumEnsembleTuples()); if (getErrorCondition() < 0) { return; } m_Magnitude = m_Magnitude*m_pi/180.0; add_orientation_noise(); // If there is an error set this to something negative and also set a message notifyStatusMessage("AddOrientationNoises Completed"); }