// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DxReader::execute()
{
std::stringstream ss;
int err = 0;
m_InStream.open(getInputFile().c_str(), std::ios_base::binary);
if(!m_InStream)
{
ss.clear();
ss << " Runtime Error. The input file '" << getInputFile() << "' could not be"
<< " opened for reading. Do you have access to this file?";
setErrorCondition(-49801);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
return;
}
err = readHeader();
if(err < 0)
{
m_InStream.close();
return;
}
err = readFile();
m_InStream.close();
if(err < 0)
{
return;
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GoldfeatherReader::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if (getInputFile().empty() == true)
{
ss << ClassName() << " needs the Input File Set and it was not.";
setErrorCondition(-387);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
else if (MXAFileInfo::exists(getInputFile()) == false)
{
ss << "The input file does not exist.";
setErrorCondition(-388);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
DREAM3D::SurfaceMesh::VertListPointer_t vertices = DREAM3D::SurfaceMesh::VertList_t::CreateArray(1, DREAM3D::VertexData::SurfaceMeshNodes);
DREAM3D::SurfaceMesh::FaceListPointer_t triangles = DREAM3D::SurfaceMesh::FaceList_t::CreateArray(1, DREAM3D::FaceData::SurfaceMeshFaces);
sm->setVertices(vertices);
sm->setFaces(triangles);
DoubleArrayType::Pointer normalsPtr = DoubleArrayType::CreateArray(1, 3, DREAM3D::VertexData::SurfaceMeshNodeNormals);
//addCreatedCellData( normalsPtr->GetName());
sm->addVertexData(normalsPtr->GetName(), normalsPtr);
DoubleArrayType::Pointer pcurv1Ptr = DoubleArrayType::CreateArray(1, 1, "Principal_Curvature_1");
//addCreatedCellData( pcurv1Ptr->GetName());
sm->addVertexData(pcurv1Ptr->GetName(), pcurv1Ptr);
DoubleArrayType::Pointer pcurv2Ptr = DoubleArrayType::CreateArray(1, 1, "Principal_Curvature_2");
// addCreatedCellData( pcurv2Ptr->GetName());
sm->addVertexData(pcurv2Ptr->GetName(), pcurv2Ptr);
DoubleArrayType::Pointer pDirection1Ptr = DoubleArrayType::CreateArray(1, 3, "Principal_Direction_1");
// addCreatedCellData( pDirection1Ptr->GetName());
sm->addVertexData(pDirection1Ptr->GetName(), pDirection1Ptr);
DoubleArrayType::Pointer pDirection2Ptr = DoubleArrayType::CreateArray(1, 3, "Principal_Direction_2");
// addCreatedCellData( pDirection2Ptr->GetName());
sm->addVertexData(pDirection2Ptr->GetName(), pDirection2Ptr);
DataArray<int32_t>::Pointer faceLabelPtr = DataArray<int32_t>::CreateArray(1, 2, DREAM3D::FaceData::SurfaceMeshFaceLabels);
// addCreatedFieldData( faceLabelPtr->GetName());
sm->addFaceData(faceLabelPtr->GetName(), faceLabelPtr);
DoubleArrayType::Pointer triNormalsPtr = DoubleArrayType::CreateArray(1, 3, DREAM3D::FaceData::SurfaceMeshFaceNormals);
// addCreatedFieldData( triNormalsPtr->GetName());
sm->addFaceData(triNormalsPtr->GetName(), triNormalsPtr);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DxReader::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
VoxelDataContainer* m = getVoxelDataContainer();
if (getInputFile().empty() == true)
{
ss << ClassName() << " needs the Input File Set and it was not.";
setErrorCondition(-387);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
else if (MXAFileInfo::exists(getInputFile()) == false)
{
ss << "The input file does not exist.";
setErrorCondition(-388);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
CREATE_NON_PREREQ_DATA(m, DREAM3D, CellData, GrainIds, ss, int32_t, Int32ArrayType, 0, voxels, 1)
m->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z);
m->setOrigin(m_Origin.x, m_Origin.y, m_Origin.z);
if (m_InStream.is_open() == true)
{
m_InStream.close();
}
// We need to read the header of the input file to get the dimensions
m_InStream.open(getInputFile().c_str(), std::ios_base::binary);
if(!m_InStream)
{
ss.clear();
ss << " Runtime Error. The input file '" << getInputFile() << "' could not be"
<< " opened for reading. Do you have access to this file?";
setErrorCondition(-49800);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
return;
}
int error = readHeader();
m_InStream.close();
if (error < 0)
{
setErrorCondition(error);
ss.clear();
ss << "Error occurred trying to parse the dimensions from the input file. Is the input file a Dx file?";
addErrorMessage(getHumanLabel(), ss.str(), -11000);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int CropVolumePipeline::writeFilterParameters(AbstractFilterParametersWriter* writer, int index)
{
writer->openFilterGroup(this, index);
writer->writeValue("InputFile", getInputFile() );
writer->closeFilterGroup();
return ++index; // we want to return the next index that was just written to
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSectionsList::setupFilterParameters()
{
// getting the current parameters that were set by the parent and adding to it before resetting it
FilterParameterVector parameters = getFilterParameters();
parameters.push_front(InputFileFilterParameter::New("Input File", "InputFile", getInputFile(), FilterParameter::Parameter, "*.txt"));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSectionsList::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
AlignSections::readFilterParameters(reader, index);
reader->openFilterGroup(this, index);
setInputFile( reader->readString( "InputFile", getInputFile() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DxReader::writeFilterParameters(AbstractFilterParametersWriter* writer)
{
writer->writeValue("InputFile", getInputFile() );
writer->writeValue("Origin", getOrigin() );
writer->writeValue("Resolution", getResolution() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GoldfeatherReader::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("InputFile", getInputFile() );
}
int main(){
// Print banner
printEqualsSeparator();
printf("\tHartz Compiler\n");
printEqualsSeparator();
// grab file for compilation
char file[64];
getInputFile(file);
printf("Processing '%s' for compilation...\n", file);
// build Symbol Table
struct symbol_table *vars;
vars = (struct symbol_table *) malloc(sizeof(struct symbol_table));
memset(vars, 0, sizeof(struct symbol_table));
// Build program metadata
struct program *prog;
prog = (struct program *) malloc(sizeof(struct program));
memset(prog, 0, sizeof(struct program));
prog->input = file;
prog->in = fopen(file, "r");
prog->tbl = vars;
// begin parsing file
int ret_code = parseFile(prog);
return ret_code;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
VoxelDataContainer* m = getVoxelDataContainer();
if (getInputFile().empty() == true)
{
ss << ClassName() << " needs the Input File Set and it was not.";
setErrorCondition(-387);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
else if (MXAFileInfo::exists(getInputFile()) == false)
{
ss << "The input file does not exist.";
setErrorCondition(-388);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
else
{
const unsigned int size(1024);
char buf[size];
// Read header from data file to figure out how many points there are
std::ifstream in(getInputFile().c_str());
std::string word;
bool headerdone = false;
int xpoints, ypoints, zpoints;
float resx, resy, resz;
while (headerdone == false)
{
in.getline(buf, size);
std::string line = buf;
in >> word;
if (DIMS == word)
{
in >> xpoints >> ypoints >> zpoints;
size_t dims[3] = {xpoints, ypoints, zpoints};
m->setDimensions(dims);
m->setOrigin(0,0,0);
}
if (RES == word)
{
in >> resx >> resy >> resz;
float res[3] = {resx, resy, resz};
m->setResolution(res);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QFilterWidget* QDataContainerReaderWidget::createDeepCopy()
{
QDataContainerReaderWidget* w = new QDataContainerReaderWidget(NULL);
w->setInputFile( getInputFile() );
w->setReadVoxelData( getReadVoxelData() );
w->setReadSurfaceMeshData( getReadSurfaceMeshData() );
return w;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadH5Ebsd::writeFilterParameters(AbstractFilterParametersWriter* writer)
{
writer->writeValue("InputFile", getInputFile() );
writer->writeValue("ZStartIndex", getZStartIndex() );
writer->writeValue("ZEndIndex", getZEndIndex() );
writer->writeValue("UseTransformations", getUseTransformations() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RegularizeZSpacing::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setCellAttributeMatrixPath( reader->readDataArrayPath("CellAttributeMatrixPath", getCellAttributeMatrixPath() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
setNewZRes( reader->readValue("NewZRes", getNewZRes()) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerReader::syncProxies()
{
// If there is something in the cached proxy...
if (m_InputFileDataContainerArrayProxy.dataContainers.size() > 0)
{
DataContainerArrayProxy fileProxy = readDataContainerArrayStructure(getInputFile());
DataContainerArrayProxy cacheProxy = getInputFileDataContainerArrayProxy();
// Mesh proxies together into one proxy
DataContainerArrayProxy mergedProxy = DataContainerArrayProxy::MergeProxies(fileProxy, cacheProxy);
setInputFileDataContainerArrayProxy(mergedProxy);
}
else
{
DataContainerArrayProxy fileProxy = readDataContainerArrayStructure(getInputFile());
setInputFileDataContainerArrayProxy(fileProxy);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setInputFile(reader->readString("InputFile", getInputFile() ) );
setInputFileDataContainerArrayProxy(reader->readDataContainerArrayProxy("InputFileDataContainerArrayProxy", getInputFileDataContainerArrayProxy() ) );
syncProxies(); // Sync the file proxy and currently cached proxy together into one proxy
setOverwriteExistingDataContainers(reader->readValue("OverwriteExistingDataContainers", getOverwriteExistingDataContainers() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int GoldfeatherReader::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("InputFile", getInputFile() );
writer->closeFilterGroup();
return ++index; // we want to return the next index that was just written to
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void QDataContainerReaderWidget::writeOptions(QSettings &prefs)
{
prefs.setValue("Filter_Name", "DataContainerReader" );
prefs.setValue("InputFile", QDir::toNativeSeparators(getInputFile()) );
prefs.setValue("ReadVoxelData", getReadVoxelData() );
prefs.setValue("ReadSurfaceMeshData", getReadSurfaceMeshData() );
prefs.setValue("ReadSolidMeshData", getReadSolidMeshData() );
arraySelectionWidget->writeOptions(prefs, "ArraySelections");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void EnsembleInfoReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setDataContainerName(reader->readString("DataContainerName", getDataContainerName() ) );
setCellEnsembleAttributeMatrixName(reader->readString("CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName() ) );
setPhaseTypesArrayName(reader->readString("PhaseTypesArrayName", getPhaseTypesArrayName() ) );
setCrystalStructuresArrayName(reader->readString("CrystalStructuresArrayName", getCrystalStructuresArrayName() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VtkStructuredPointsReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setVertexDataContainerName(reader->readString("VertexDataContainerName", getVertexDataContainerName()));
setVolumeDataContainerName(reader->readString("VolumeDataContainerName", getVolumeDataContainerName() ) );
setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setVertexAttributeMatrixName(reader->readString("VertexAttributeMatrixName", getVertexAttributeMatrixName() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
setReadPointData(reader->readValue("ReadPointData", getReadPointData()));
setReadCellData(reader->readValue("ReadCellData", getReadCellData()));
reader->closeFilterGroup();
}
// ------------------------------------------------------------------------
//
// ------------------------------------------------------------------------
int32_t VtkStructuredPointsReader::readScalarData(std::istream& in, int32_t numPts)
{
char line[256], name[256], key[256], tableName[256];
int32_t numComp = 1;
char buffer[1024];
if (!(this->readString(in, buffer, 1024) && this->readString(in, line, 1024)))
{
vtkErrorMacro( << "Cannot read scalar header!" << " for file: "
<< (getInputFile().toStdString()));
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
AbstractFilter::Pointer QDataContainerReaderWidget::getFilter(bool defaultValues)
{
DataContainerReader::Pointer filter = DataContainerReader::New();
if (defaultValues == true) { return filter; }
filter->setInputFile( getInputFile().toStdString() );
filter->setReadVoxelData( getReadVoxelData() );
filter->setReadSurfaceMeshData( getReadSurfaceMeshData() );
filter->setReadSolidMeshData( getReadSolidMeshData() );
arraySelectionWidget->getArraySelections(filter.get());
return filter;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 FeatureInfoReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setCellAttributeMatrixName(reader->readDataArrayPath("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setCellFeatureAttributeMatrixName(reader->readString("CellFeatureAttributeMatrixName", getCellFeatureAttributeMatrixName() ) );
setFeatureEulerAnglesArrayName(reader->readString("FeatureEulerAnglesArrayName", getFeatureEulerAnglesArrayName() ) );
setFeaturePhasesArrayName(reader->readString("FeaturePhasesArrayName", getFeaturePhasesArrayName() ) );
setCellEulerAnglesArrayName(reader->readString("CellEulerAnglesArrayName", getCellEulerAnglesArrayName() ) );
setCellPhasesArrayName(reader->readString("CellPhasesArrayName", getCellPhasesArrayName() ) );
setFeatureIdsArrayPath(reader->readDataArrayPath("FeatureIdsArrayPath", getFeatureIdsArrayPath() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
setCreateCellLevelArrays( reader->readValue("CreateCellLevelArrays", getCreateCellLevelArrays()) );
setRenumberFeatures( reader->readValue("RenumberFeatures", getRenumberFeatures()) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RawBinaryReader::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("ScalarType", getScalarType() );
writer->writeValue("Dimensionality", getDimensionality() );
writer->writeValue("NumberOfComponents", getNumberOfComponents() );
writer->writeValue("Endian", getEndian() );
writer->writeValue("Dimensions", getDimensions() );
writer->writeValue("Origin", getOrigin() );
writer->writeValue("Resolution", getResolution() );
writer->writeValue("InputFile", getInputFile() );
writer->writeValue("OverRideOriginResolution", getOverRideOriginResolution() );
writer->writeValue("SkipHeaderBytes", getSkipHeaderBytes() );
writer->writeValue("OutputArrayName", getOutputArrayName() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
AbstractFilter::Pointer DataContainerReader::newFilterInstance(bool copyFilterParameters)
{
DataContainerReader::Pointer filter = DataContainerReader::New();
if(true == copyFilterParameters)
{
copyFilterParameterInstanceVariables(filter.get());
SIMPL_COPY_INSTANCEVAR(InputFile)
filter->setInputFile(getInputFile());
#if 0
filter->setOverwriteExistingDataContainers(getOverwriteExistingDataContainers());
filter->setDataContainerArrayProxy(getDataContainerArrayProxy());
#endif
}
return filter;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VtkStructuredPointsReader::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(InputFileFilterParameter::New("Input VTK File", "InputFile", getInputFile(), FilterParameter::Parameter));
QStringList linkedProps;
linkedProps << "VertexDataContainerName" << "VertexAttributeMatrixName";
parameters.push_back(LinkedBooleanFilterParameter::New("Read Point Data", "ReadPointData", getReadPointData(), linkedProps, FilterParameter::Parameter));
linkedProps.clear();
linkedProps << "VolumeDataContainerName" << "CellAttributeMatrixName";
parameters.push_back(LinkedBooleanFilterParameter::New("Read Cell Data", "ReadCellData", getReadCellData(), linkedProps, FilterParameter::Parameter));
parameters.push_back(StringFilterParameter::New("Point Data Data Container", "VertexDataContainerName", getVertexDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Data Data Container", "VolumeDataContainerName", getVolumeDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Point Data Attribute Matrix", "VertexAttributeMatrixName", getVertexAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Data Attribute Matrix", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
LimaStatusCode SpecificEntitiesLoader::
process(AnalysisContent& analysis) const
{
// get analysis graph
AnalysisGraph* graph=static_cast<AnalysisGraph*>(analysis.getData(m_graph));
if (graph==0)
{
LOGINIT("LP::SpecificEntities");
LERROR << "no graph '" << m_graph << "' available !";
return MISSING_DATA;
}
//create a RecognizerData (such as in ApplyRecognizer) to be able to use
//CreateSpecificEntity actions
RecognizerData* recoData=new RecognizerData;
analysis.setData("RecognizerData",recoData);
RecognizerResultData* resultData=new RecognizerResultData(m_graph);
recoData->setResultData(resultData);
try
{
SpecificEntitiesLoader::XMLHandler handler(m_language,analysis,graph);
m_parser->setContentHandler(&handler);
m_parser->setErrorHandler(&handler);
QFile file(getInputFile(analysis).c_str());
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
throw XMLException();
if (!m_parser->parse( QXmlInputSource(&file)))
{
throw XMLException();
}
}
catch (const XMLException& )
{
LOGINIT("LP::SpecificEntities");
LERROR << "Error: failed to parse XML input file";
}
// remove recognizer data (used only internally to this process unit)
recoData->deleteResultData();
resultData=0;
analysis.removeData("RecognizerData");
return SUCCESS_ID;
}
