// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void INLWriter::dataCheck() { setErrorCondition(0); getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getFeatureIdsArrayPath().getDataContainerName()); if (getOutputFile().isEmpty() == true) { QString ss = QObject::tr("The output file must be set"); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } QFileInfo fi(getOutputFile()); 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<DataArrayPath> cellDataArrayPaths; QVector<DataArrayPath> ensembleDataArrayPaths; 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 */ if(getErrorCondition() >= 0) { cellDataArrayPaths.push_back(getFeatureIdsArrayPath()); } m_CellPhasesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getCellPhasesArrayPath(), cDims); /* 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(getErrorCondition() >= 0) { cellDataArrayPaths.push_back(getCellPhasesArrayPath()); } m_CrystalStructuresPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<uint32_t>, 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 */ if(getErrorCondition() >= 0) { ensembleDataArrayPaths.push_back(getCrystalStructuresArrayPath()); } m_NumFeaturesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getNumFeaturesArrayPath(), 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 */ if(getErrorCondition() >= 0) { ensembleDataArrayPaths.push_back(getNumFeaturesArrayPath()); } m_MaterialNamePtr = getDataContainerArray()->getPrereqArrayFromPath<StringDataArray, AbstractFilter>(this, getMaterialNameArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if(getErrorCondition() >= 0) { ensembleDataArrayPaths.push_back(getMaterialNameArrayPath()); } cDims[0] = 3; m_CellEulerAnglesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getCellEulerAnglesArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_CellEulerAnglesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_CellEulerAngles = m_CellEulerAnglesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() >= 0) { cellDataArrayPaths.push_back(getCellEulerAnglesArrayPath()); } getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, cellDataArrayPaths); getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, ensembleDataArrayPaths); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteStatsGenOdfAngleFile::dataCheck() { setErrorCondition(0); QString ss; if (getOutputFile().isEmpty() == true) { ss = QObject::tr( "The output file must be set"); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } QFileInfo fi(getOutputFile()); QDir parentPath = fi.path(); if (parentPath.exists() == false) { ss = QObject::tr( "The directory path for the output file does not exist"); notifyWarningMessage(getHumanLabel(), ss, -1); } QVector<size_t> cDims(1, 1); m_CellPhasesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getCellPhasesArrayPath(), cDims); /* 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 */ } cDims[0] = 3; m_CellEulerAnglesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getCellEulerAnglesArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_CellEulerAnglesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_CellEulerAngles = m_CellEulerAnglesPtr.lock()->getPointer(0); /* Now assign the raw pointer to data from the DataArray<T> object */ } if (getUseGoodVoxels() == true) { // The good voxels array is optional, If it is available we are going to use it, otherwise we are going to create it cDims[0] = 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 */ } } else { m_GoodVoxels = NULL; } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- 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()); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void TestFilter::writeFilterParameters(AbstractFilterParametersWriter* writer) { /* Place code that will write the inputs values into a file. reference the AbstractFilterParametersWriter class for the proper API to use. */ writer->writeValue("StlFilePrefix", getStlFilePrefix() ); writer->writeValue("MaxIterations", getMaxIterations() ); writer->writeValue("MisorientationTolerance", getMisorientationTolerance() ); writer->writeValue("InputFile", getInputFile() ); writer->writeValue("InputPath", getInputPath() ); writer->writeValue("OutputFile", getOutputFile() ); writer->writeValue("OutputPath", getOutputPath() ); writer->writeValue("WriteAlignmentShifts", getWriteAlignmentShifts() ); writer->writeValue("ConversionType", getConversionType() ); writer->writeValue("SelectedCellArrayName", getSelectedCellArrayName() ); writer->writeValue("SelectedFieldArrayName", getSelectedFieldArrayName() ); writer->writeValue("SelectedEnsembleArrayName", getSelectedEnsembleArrayName() ); writer->writeValue("SurfaceMeshPointArrayName", getSurfaceMeshPointArrayName() ); writer->writeValue("SurfaceMeshFaceArrayName", getSurfaceMeshFaceArrayName() ); writer->writeValue("SurfaceMeshEdgeArrayName", getSurfaceMeshEdgeArrayName() ); writer->writeValue("SolidMeshPointArrayName", getSolidMeshPointArrayName() ); writer->writeValue("SolidMeshFaceArrayName", getSolidMeshFaceArrayName() ); writer->writeValue("SolidMeshEdgeArrayName", getSolidMeshEdgeArrayName() ); writer->writeValue("Dimensions", getDimensions() ); writer->writeValue("Origin", getOrigin() ); writer->writeValue("CellComparisonInputs", m_CellComparisonInputs); writer->writeValue("AxisAngleRotations", m_AxisAngleRotations); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int AbaqusSurfaceMeshWriter::writeFilterParameters(AbstractFilterParametersWriter* writer, int index) { writer->openFilterGroup(this, index); writer->writeValue("OutputFile", getOutputFile() ); writer->closeFilterGroup(); return ++index; // we want to return the next index that was just written to }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteStatsGenOdfAngleFile::setupFilterParameters() { FilterParameterVector parameters; /* For String input use this code */ parameters.push_back(OutputFileFilterParameter::New("Output File", "OutputFile", getOutputFile(), FilterParameter::Parameter)); parameters.push_back(BooleanFilterParameter::New("Convert to Degrees", "ConvertToDegrees", getConvertToDegrees(), FilterParameter::Parameter)); QStringList linkedProps("GoodVoxelsArrayPath"); parameters.push_back(LinkedBooleanFilterParameter::New("Only Write Good Elements", "UseGoodVoxels", getUseGoodVoxels(), linkedProps, FilterParameter::Parameter)); parameters.push_back(SeparatorFilterParameter::New("Element Data", FilterParameter::RequiredArray)); { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::TypeNames::Float, 3, DREAM3D::AttributeMatrixObjectType::Element); parameters.push_back(DataArraySelectionFilterParameter::New("Euler Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), FilterParameter::RequiredArray, req)); } { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::TypeNames::Int32, 1, DREAM3D::AttributeMatrixObjectType::Element); parameters.push_back(DataArraySelectionFilterParameter::New("Phases", "CellPhasesArrayPath", getCellPhasesArrayPath(), FilterParameter::RequiredArray, req)); } { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(DREAM3D::TypeNames::Bool, 1, DREAM3D::AttributeMatrixObjectType::Element); parameters.push_back(DataArraySelectionFilterParameter::New("Mask", "GoodVoxelsArrayPath", getGoodVoxelsArrayPath(), FilterParameter::RequiredArray, req)); } setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GenericExample::readFilterParameters(AbstractFilterParametersReader* reader, int index) { /* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE BEGIN*/ reader->openFilterGroup(this, index); setStlFilePrefix( reader->readValue("StlFilePrefix", getStlFilePrefix()) ); setMaxIterations( reader->readValue("MaxIterations", getMaxIterations()) ); setMisorientationTolerance( reader->readValue("MisorientationTolerance", getMisorientationTolerance()) ); setInputFile( reader->readValue("InputFile", getInputFile()) ); setInputPath( reader->readValue("InputPath", getInputPath()) ); setOutputFile( reader->readValue("OutputFile", getOutputFile()) ); setOutputPath( reader->readValue("OutputPath", getOutputPath()) ); setWriteAlignmentShifts( reader->readValue("WriteAlignmentShifts", getWriteAlignmentShifts()) ); setConversionType( reader->readValue("ConversionType", getConversionType()) ); setDimensions( reader->readValue("Dimensions", getDimensions()) ); setOrigin( reader->readValue("Origin", getOrigin()) ); setCrystalSymmetryRotations( reader->readValue("CrystalSymmetryRotations", getCrystalSymmetryRotations()) ); setSelectedVoxelCellArrayName( reader->readValue("SelectedVoxelCellArrayName", getSelectedVoxelCellArrayName()) ); setSelectedVoxelFieldArrayName( reader->readValue("SelectedVoxelFieldArrayName", getSelectedVoxelFieldArrayName()) ); setSelectedVoxelEnsembleArrayName( reader->readValue("SelectedVoxelEnsembleArrayName", getSelectedVoxelEnsembleArrayName()) ); setSelectedSurfaceMeshPointArrayName( reader->readValue("SelectedSurfaceMeshPointArrayName", getSelectedSurfaceMeshPointArrayName()) ); setSelectedSurfaceMeshFaceArrayName( reader->readValue("SelectedSurfaceMeshFaceArrayName", getSelectedSurfaceMeshFaceArrayName()) ); setSelectedSurfaceMeshEdgeArrayName( reader->readValue("SelectedSurfaceMeshEdgeArrayName", getSelectedSurfaceMeshEdgeArrayName()) ); setSelectedSolidMeshPointArrayName( reader->readValue("SelectedSolidMeshPointArrayName", getSelectedSolidMeshPointArrayName()) ); setSelectedSolidMeshFaceArrayName( reader->readValue("SelectedSolidMeshFaceArrayName", getSelectedSolidMeshFaceArrayName()) ); setSelectedSolidMeshEdgeArrayName( reader->readValue("SelectedSolidMeshEdgeArrayName", getSelectedSolidMeshEdgeArrayName()) ); setStrVector( reader->readValue("StrVector", getStrVector() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void SPParksWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
/* { "topFace" : "~/burp/faceZ/.png", "bottomFace" : "~/burp/faceZ-/.png", "leftFace" : "~/burp/faceY/.png", "rightFace" : "~/burp/faceY-/.png", "frontFace" : "~/burp/faceX/.png", "backFace" : "~/burp/faceX-/.png", "frameStart" : 1, "frameStop" : 499, "outputWidth" : 4094, "antialiasing" : 1, "aaPattern" : "grid", "frames": [ {"cubemap": 1, "fov": 180, "pitch" : 0, "yaw" : 0, "roll" : 0, "zoom" : 0}, {"cubemap": 1, "fov": 180, "pitch" : 1, "yaw" : 2, "roll" : 3, "zoom" : 4}, {"cubemap": 1, "fov": 180, "pitch" : 2, "yaw" : 3, "roll" : 4, "zoom" : 1}, {"cubemap": 1, "fov": 180, "pitch" : 3, "yaw" : 4, "roll" : 1, "zoom" : 2}, {"cubemap": 1, "fov": 180, "pitch" : 4, "yaw" : 1, "roll" : 2, "zoom" : 3} ] } */ void JSonIO::saveJSon(QString filePath){ QFile jsonFile(filePath); if (!jsonFile.open(QIODevice::WriteOnly | QIODevice::Text)){ parserState = 1; return; } QVariantMap root; root.insert("outputFile", getOutputFile()); root.insert("topFace", getTopFace()); root.insert("bottomFace", getBottomFace()); root.insert("leftFace", getLeftFace()); root.insert("rightFace", getRightFace()); root.insert("frontFace", getFrontFace()); root.insert("backFace", getBackFace()); root.insert("frameStart", getFrameStart()); root.insert("frameStop", getFrameStop()); root.insert("outputWidth", getOutputWidth()); root.insert("antialiasing", getAntialiasing()); root.insert("aaPattern", getAaPattern()); root.insert("frames", frames); QJson::Serializer serializer; QByteArray json = serializer.serialize(root); QTextStream out(&jsonFile); out.setCodec("UTF-8"); out << json; jsonFile.close(); qDebug() << "Saved to " << filePath; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int GenericExample::writeFilterParameters(AbstractFilterParametersWriter* writer, int index) { writer->openFilterGroup(this, index); /* Place code that will write the inputs values into a file. reference the AbstractFilterParametersWriter class for the proper API to use. */ writer->writeValue("StlFilePrefix", getStlFilePrefix()); writer->writeValue("MaxIterations", getMaxIterations()); writer->writeValue("MisorientationTolerance", getMisorientationTolerance()); writer->writeValue("InputFile", getInputFile()); writer->writeValue("InputPath", getInputPath()); writer->writeValue("OutputFile", getOutputFile()); writer->writeValue("OutputPath", getOutputPath()); writer->writeValue("WriteAlignmentShifts", getWriteAlignmentShifts()); writer->writeValue("ConversionType", getConversionType()); writer->writeValue("Dimensions", getDimensions()); writer->writeValue("Origin", getOrigin()); writer->writeValue("CrystalSymmetryRotations", getCrystalSymmetryRotations()); writer->writeValue("SelectedVoxelCellArrayName", getSelectedVoxelCellArrayName()); writer->writeValue("SelectedVoxelFieldArrayName", getSelectedVoxelFieldArrayName()); writer->writeValue("SelectedVoxelEnsembleArrayName", getSelectedVoxelEnsembleArrayName()); writer->writeValue("SelectedSurfaceMeshPointArrayName", getSelectedSurfaceMeshPointArrayName()); writer->writeValue("SelectedSurfaceMeshFaceArrayName", getSelectedSurfaceMeshFaceArrayName()); writer->writeValue("SelectedSurfaceMeshEdgeArrayName", getSelectedSurfaceMeshEdgeArrayName()); writer->writeValue("SelectedSolidMeshPointArrayName", getSelectedSolidMeshPointArrayName()); writer->writeValue("SelectedSolidMeshFaceArrayName", getSelectedSolidMeshFaceArrayName()); writer->writeValue("SelectedSolidMeshEdgeArrayName", getSelectedSolidMeshEdgeArrayName()); writer->writeValue("StrVector", getStrVector()); writer->closeFilterGroup(); return ++index; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSurfaceMeshFaceLabelsArrayPath(reader->readDataArrayPath("SurfaceMeshFaceLabelsArrayPath", getSurfaceMeshFaceLabelsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void INLWriter::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(OutputFileFilterParameter::New("Output File", "OutputFile", getOutputFile(), FilterParameter::Parameter, "*.txt", "INL Format")); parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray)); { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Int32, 1, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry); parameters.push_back(DataArraySelectionFilterParameter::New("Feature Ids", "FeatureIdsArrayPath", getFeatureIdsArrayPath(), 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::Float, 3, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry); parameters.push_back(DataArraySelectionFilterParameter::New("Euler Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), 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)); } { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::Defaults::AnyPrimitive, 1, SIMPL::AttributeMatrixType::CellEnsemble, SIMPL::GeometryType::ImageGeometry); parameters.push_back(DataArraySelectionFilterParameter::New("Material Names", "MaterialNameArrayPath", getMaterialNameArrayPath(), FilterParameter::RequiredArray, req)); } { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Int32, 1, SIMPL::AttributeMatrixType::CellEnsemble, SIMPL::GeometryType::ImageGeometry); parameters.push_back(DataArraySelectionFilterParameter::New("Number of Features", "NumFeaturesArrayPath", getNumFeaturesArrayPath(), FilterParameter::RequiredArray, req)); } setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(OutputFileFilterParameter::New("Output File", "OutputFile", getOutputFile(), FilterParameter::Parameter, "*.inp")); parameters.push_back(SeparatorFilterParameter::New("Face Data", FilterParameter::RequiredArray)); parameters.push_back(DataArraySelectionFilterParameter::New("Face Labels", "SurfaceMeshFaceLabelsArrayPath", getSurfaceMeshFaceLabelsArrayPath(), FilterParameter::RequiredArray)); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- void AvizoUniformCoordinateWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); setWriteBinaryFile( reader->readValue("WriteBinaryFile", getWriteBinaryFile()) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void SPParksWriter::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(OutputFileFilterParameter::New("Output File", "OutputFile", getOutputFile(), FilterParameter::Parameter, "*.spparks", "SPParks Sites File")); parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray)); parameters.push_back(DataArraySelectionFilterParameter::New("Feature Ids", "FeatureIdsArrayPath", getFeatureIdsArrayPath(), FilterParameter::RequiredArray)); setFilterParameters(parameters); }
void LibreOffice::build(NSIS *installer, Version version) { isError = false; download(version); if (!isError) { QStringList files(tempFiles); QStringList msiOptions("ADDLOCAL=ALL"); QStringList removeComponents; if (!getConfig("Use automatic update", true).toBool()) { removeComponents << "gm_o_Onlineupdate"; } if (!removeComponents.isEmpty()) { msiOptions << "REMOVE=" + removeComponents.join(","); } msiOptions << QString("CREATEDESKTOPLINK=%1").arg(getConfig("Desktop shortcut", false).toBool()); msiOptions << QString("QUICKSTART=%1").arg(getConfig("Enable Quickstarter by default", false).toBool()); qDebug() << "MSI options:" << msiOptions; QString src(loadResource(":NSIS/LibreOffice/main.nsh")); src.replace("${MsiFile}", QFileInfo(tempFiles.first()).fileName()); src.replace("${MsiOptions}", msiOptions.join(" ")); // Use configuration template if configured QString configTemplate(getConfig("Configuration template").toString()); if (!configTemplate.isEmpty()) { QFileInfo file(configTemplate); if (file.isReadable()) { files << configTemplate; src += loadResource(":NSIS/LibreOffice/configtemplate.nsh") .replace("${ConfigTemplate}", file.fileName()) .replace("${ShortVersion}", version.truncate(2)) ; } else { Application::critical(tr("The configuration template '%1' cannot be read.").arg(configTemplate)); isError = true; } } if (!isError) { installer->build( objectName(), getOutputFile(), NSIS::Zlib, 800, QStringList() << "soffice.exe" << "soffice.bin", files, src ); } } cleanup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void LosAlamosFFTWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setCellEulerAnglesArrayPath(reader->readDataArrayPath("CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath() ) ); setCellPhasesArrayPath(reader->readDataArrayPath("CellPhasesArrayPath", getCellPhasesArrayPath() ) ); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); /* Code to read the values goes between these statements */ /* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE BEGIN*/ setOutputFile(reader->readValue("OutputFile", getOutputFile())); /* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE END*/ reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void VisualizeGBCDGMT::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setGBCDArrayPath(reader->readDataArrayPath("GBCDArrayPath", getGBCDArrayPath())); setCrystalStructuresArrayPath(reader->readDataArrayPath("CrystalStructuresArrayPath", getCrystalStructuresArrayPath())); setOutputFile(reader->readString("OutputFile", getOutputFile())); setMisorientationRotation(reader->readAxisAngle("MisorientationRotation", getMisorientationRotation(), -1) ); setPhaseOfInterest(reader->readValue("PhaseOfInterest", getPhaseOfInterest())); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void LosAlamosFFTWriter::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(OutputFileFilterParameter::New("Output File", "OutputFile", getOutputFile(), FilterParameter::Parameter, "*.txt", "FFT Format")); parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray)); parameters.push_back(DataArraySelectionFilterParameter::New("Feature Ids", "FeatureIdsArrayPath", getFeatureIdsArrayPath(), FilterParameter::RequiredArray)); parameters.push_back(DataArraySelectionFilterParameter::New("Phases", "CellPhasesArrayPath", getCellPhasesArrayPath(), FilterParameter::RequiredArray)); parameters.push_back(DataArraySelectionFilterParameter::New("Euler Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), FilterParameter::RequiredArray)); setFilterParameters(parameters); }
void ossimQtIgenController::updateOutputFilenameFromWriter() { if (!theDialog || !theDialog->theOutputFileLineEdit || !theWriter) { return; } ossimFilename writersOutputFile = theWriter->getFilename(); if (writersOutputFile.empty()) { return; } QString fileName = writersOutputFile.c_str(); if (fileName == getOutputFile()) { return; } // Make sure output filename is not the same as input. #if 0 QString source_file = getImageFileName(); if (source_file == fileName) { QString caption = "Sorry:"; QString text = "Output file cannot be the same as input file."; QMessageBox::information( this, caption, text, QMessageBox::Ok ); return; } #endif // Check to see if file exist and prompt user for overwrite. if (writersOutputFile.exists()) { QString caption("Question:"); QString text = "Overwrite existing file: "; text += fileName; int answer = QMessageBox::question( theDialog, caption, text, QMessageBox::Yes, QMessageBox::No); if (answer == QMessageBox::No) { theDialog->theOutputFileLineEdit->setText(""); return; } } theDialog->theOutputFileLineEdit->setText(fileName); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteStatsGenOdfAngleFile::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setConvertToDegrees(reader->readValue("ConvertToDegrees", getConvertToDegrees() ) ); setOutputFile( reader->readString("OutputFile", getOutputFile())); setUseGoodVoxels(reader->readValue("UseGoodVoxels", getUseGoodVoxels() ) ); setGoodVoxelsArrayPath(reader->readDataArrayPath("GoodVoxelsArrayPath", getGoodVoxelsArrayPath() ) ); setCellEulerAnglesArrayPath(reader->readDataArrayPath("CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath() ) ); setCellPhasesArrayPath(reader->readDataArrayPath("CellPhasesArrayPath", getCellPhasesArrayPath() ) ); reader->closeFilterGroup(); }
Convertor::Convertor(std::string filename) { mInputFile = filename; if(!getOutputFile()) return; getClassName(); if(!initialize()) return; run(); stop(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AvizoUniformCoordinateWriter::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(OutputFileFilterParameter::New("Output File", "OutputFile", getOutputFile(), FilterParameter::Parameter, "*.am", "Amira Mesh")); parameters.push_back(BooleanFilterParameter::New("Write Binary File", "WriteBinaryFile", getWriteBinaryFile(), FilterParameter::Parameter)); parameters.push_back(DataArraySelectionFilterParameter::New("FeatureIds", "FeatureIdsArrayPath", getFeatureIdsArrayPath(), FilterParameter::RequiredArray)); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(OutputFileFilterParameter::New("Output File", "OutputFile", getOutputFile(), FilterParameter::Parameter, "*.inp")); 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)); } setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void INLWriter::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setCellEulerAnglesArrayPath(reader->readDataArrayPath("CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath() ) ); setCrystalStructuresArrayPath(reader->readDataArrayPath("CrystalStructuresArrayPath", getCrystalStructuresArrayPath() ) ); setCellPhasesArrayPath(reader->readDataArrayPath("CellPhasesArrayPath", getCellPhasesArrayPath() ) ); setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) ); setNumFeaturesArrayPath(reader->readDataArrayPath("NumFeaturesArrayPath", getNumFeaturesArrayPath() ) ); setMaterialNameArrayPath(reader->readDataArrayPath("MaterialNameArrayPath", getMaterialNameArrayPath())); setOutputFile( reader->readString( "OutputFile", getOutputFile() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AbaqusSurfaceMeshWriter::execute() { int err = 0; std::stringstream ss; SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer(); dataCheck(false, 1, 1, 1); if(getErrorCondition() < 0) { return; } // 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(getOutputFile()); if(!MXADir::mkdir(parentPath, true)) { std::stringstream ss; ss << "Error creating parent path '" << parentPath << "'"; notifyErrorMessage(ss.str(), -1); setErrorCondition(-1); return; } DREAM3D::SurfaceMesh::VertListPointer_t nodesPtr = sm->getVertices(); DREAM3D::SurfaceMesh::FaceListPointer_t trianglePtr = sm->getFaces(); // Get the Labels(GrainIds or Region Ids) for the triangles Int32ArrayType::Pointer faceLabelsPtr = boost::dynamic_pointer_cast<Int32ArrayType>(sm->getFaceData(DREAM3D::FaceData::SurfaceMeshFaceLabels)); int32_t* faceLabels = faceLabelsPtr->GetPointer(0); // Store all the unique Spins std::set<int> uniqueSpins; for (int i = 0; i < trianglePtr->GetNumberOfTuples(); i++) { uniqueSpins.insert(faceLabels[i*2]); uniqueSpins.insert(faceLabels[i*2+1]); } FILE* f = fopen(m_OutputFile.c_str(), "wb"); ScopedFileMonitor fileMonitor(f); err = writeHeader(f, nodesPtr->GetNumberOfTuples(), trianglePtr->GetNumberOfTuples(), uniqueSpins.size()-1); err = writeNodes(f); err = writeTriangles(f); err = writeGrains(f); setErrorCondition(0); notifyStatusMessage("Complete"); return; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void AvizoUniformCoordinateWriter::execute() { int err = 0; setErrorCondition(err); dataCheck(); if(getErrorCondition() < 0) { return; } // 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)) { QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } QFile writer(getOutputFile()); if (!writer.open(QIODevice::WriteOnly | QIODevice::Text)) { QString ss = QObject::tr("Avizo Output file could not be opened: %1").arg(getOutputFile()); setErrorCondition(-100); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } QDataStream out(&writer); generateHeader(out); err = writeData(out); /* Let the GUI know we are done with this filter */ notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void EbsdToH5Ebsd::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setOutputFile( reader->readValue("OutputFile", getOutputFile()) ); setZStartIndex( reader->readValue("ZStartIndex", getZStartIndex()) ); setZEndIndex( reader->readValue("ZEndIndex", getZEndIndex()) ); setZResolution( reader->readValue("ZResolution", getZResolution()) ); setSampleTransformationAngle( reader->readValue("SampleTransformationAngle", getSampleTransformationAngle()) ); setSampleTransformationAxis( reader->readValue("SampleTransformationAxis", getSampleTransformationAxis()) ); setEulerTransformationAngle( reader->readValue("EulerTransformationAngle", getEulerTransformationAngle()) ); setEulerTransformationAxis( reader->readValue("EulerTransformationAxis", getEulerTransformationAxis()) ); setRefFrameZDir( static_cast<Ebsd::RefFrameZDir>( reader->readValue("RefFrameZDir", getRefFrameZDir() ) ) ); setEbsdFileList( reader->readValue("EbsdFileList", getEbsdFileList()) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int32_t SPParksWriter::writeHeader() { setErrorCondition(0); dataCheck(); if(getErrorCondition() < 0) { return getErrorCondition(); } DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_FeatureIdsArrayPath.getDataContainerName()); size_t udims[3] = { 0, 0, 0 }; m->getGeometryAs<ImageGeom>()->getDimensions(udims); size_t totalpoints = m->getGeometryAs<ImageGeom>()->getNumberOfElements(); std::ofstream outfile; outfile.open(getOutputFile().toLatin1().data(), std::ios_base::binary); if (!outfile) { QString ss = QObject::tr("Error opening output file '%1'").arg(getOutputFile()); setErrorCondition(-100); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return getErrorCondition(); } outfile << "-" << "\n"; outfile << "3 dimension" << "\n"; outfile << totalpoints << " sites" << "\n"; outfile << "26 max neighbors" << "\n"; outfile << "0 " << udims[0] << " xlo xhi" << "\n"; outfile << "0 " << udims[1] << " ylo yhi" << "\n"; outfile << "0 " << udims[2] << " zlo zhi" << "\n"; outfile << "\n"; outfile << "Values" << "\n"; outfile << "\n"; outfile.close(); return 0; }