// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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;
}