// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int StatsDataArray::writeH5Data(hid_t parentId, QVector<size_t> tDims) { herr_t err = 0; hid_t gid = QH5Utilities::createGroup(parentId, m_Name); if (gid < 0) { return -1; } HDF5ScopedGroupSentinel scopedFileSentinel(&gid, false); // This makes sure our H5Group is closed up as we exit this function // We start numbering our phases at 1. Anything in slot 0 is considered "Dummy" or invalid for(qint32 i = 1; i < m_StatsDataArray.size(); ++i) { if (m_StatsDataArray[i].get() != NULL) { QString indexString = QString::number(i); hid_t tupleId = QH5Utilities::createGroup(gid, indexString); err = QH5Lite::writeStringAttribute(gid, indexString, DREAM3D::StringConstants::StatsType, m_StatsDataArray[i]->getStatsType() ); err = QH5Lite::writeScalarAttribute(gid, indexString, DREAM3D::StringConstants::PhaseType, m_StatsDataArray[i]->getPhaseType() ); err = m_StatsDataArray[i]->writeHDF5Data(tupleId); err = QH5Utilities::closeHDF5Object(tupleId); } } QVector<size_t> cDims(1, 1); err = H5DataArrayWriter::writeDataArrayAttributes<StatsDataArray>(parentId, this, tDims, cDims); return err; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QString InitializeSyntheticVolume::estimateNumFeatures(IntVec3_t dims, FloatVec3_t res) { float totalvol = 0.0f; int32_t phase = 0; totalvol = (dims.x * res.x) * (dims.y * res.y) * (dims.z * res.z); if (totalvol == 0.0) { return "-1"; } DataContainerArray::Pointer dca = getDataContainerArray(); // Get the PhaseTypes - Remember there is a Dummy PhaseType in the first slot of the array QVector<size_t> cDims(1, 1); // This states that we are looking for an array with a single component UInt32ArrayType::Pointer phaseType = dca->getPrereqArrayFromPath<UInt32ArrayType, AbstractFilter>(NULL, getInputPhaseTypesArrayPath(), cDims); if (phaseType.get() == NULL) { QString ss = QObject::tr("Phase types array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputPhaseTypesArrayPath().serialize()); setErrorCondition(-11002); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return "0"; } QVector<size_t> statsDims(1, 1); StatsDataArray::Pointer statsPtr = dca->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), statsDims); if (statsPtr.get() == NULL) { QString ss = QObject::tr("Statistics array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputStatsArrayPath().serialize()); notifyErrorMessage(getHumanLabel(), ss, -11001); return "0"; } if (!phaseType->isAllocated()) { if (getInputStatsFile().isEmpty()) { QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file is empty"); setErrorCondition(-1000); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } QFileInfo fi(getInputStatsFile()); if (fi.exists() == false) { QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file does not exist at '%1'").arg(fi.absoluteFilePath()); setErrorCondition(-1001); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } hid_t fileId = -1; herr_t err = 0; // open the file fileId = H5Utilities::openFile(getInputStatsFile().toLatin1().constData(), true); // This will make sure if we return early from this method that the HDF5 File is properly closed. HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true); DataArrayPath dap = getInputPhaseTypesArrayPath(); // Generate the path to the AttributeMatrix QString hPath = DREAM3D::StringConstants::DataContainerGroupName + "/" + dap.getDataContainerName() + "/" + dap.getAttributeMatrixName(); // Open the AttributeMatrix Group hid_t amGid = H5Gopen(fileId, hPath.toLatin1().data(), H5P_DEFAULT ); scopedFileSentinel.addGroupId(&amGid); err = phaseType->readH5Data(amGid); if (err < 0) { QString ss = QObject::tr("Error reading phase type data"); setErrorCondition(-1003); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } if (!phaseType->isAllocated()) { QString ss = QObject::tr("Phase types Array was not allocated due to an error reading the data from the statistics file %1").arg(fi.absoluteFilePath()); setErrorCondition(-1002); notifyWarningMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } } // Create a Reference Variable so we can use the [] syntax StatsDataArray& statsDataArray = *(statsPtr.get()); std::vector<int32_t> primaryphases; std::vector<double> primaryphasefractions; double totalprimaryfractions = 0.0; // find which phases are primary phases for (size_t i = 1; i < phaseType->getNumberOfTuples(); ++i) { if (phaseType->getValue(i) == DREAM3D::PhaseType::PrimaryPhase) { PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[i].get()); primaryphases.push_back(i); primaryphasefractions.push_back(pp->getPhaseFraction()); totalprimaryfractions = totalprimaryfractions + pp->getPhaseFraction(); } } // scale the primary phase fractions to total to 1 for (int32_t i = 0; i < primaryphasefractions.size(); i++) { primaryphasefractions[i] = primaryphasefractions[i] / totalprimaryfractions; } SIMPL_RANDOMNG_NEW() // generate the Features int32_t gid = 1; float currentvol = 0.0f; float vol = 0.0f; float diam = 0.0f; bool volgood = false; for (int32_t j = 0; j < primaryphases.size(); ++j) { float curphasetotalvol = totalvol * primaryphasefractions[j]; while (currentvol < curphasetotalvol) { volgood = false; phase = primaryphases[j]; PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[phase].get()); if (NULL == pp) { QString ss = QObject::tr("Tried to cast a statsDataArray[%1].get() to a PrimaryStatsData* " "pointer but this resulted in a NULL pointer.\n") .arg(phase).arg(phase); setErrorCondition(-666); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return "-1"; } while (volgood == false) { volgood = true; if (pp->getFeatureSize_DistType() == DREAM3D::DistributionType::LogNormal) { float avgdiam = pp->getFeatureSizeDistribution().at(0)->getValue(0); float sddiam = pp->getFeatureSizeDistribution().at(1)->getValue(0); diam = rg.genrand_norm(avgdiam, sddiam); diam = expf(diam); if (diam >= pp->getMaxFeatureDiameter()) { volgood = false; } if (diam < pp->getMinFeatureDiameter()) { volgood = false; } vol = (4.0f / 3.0f) * (M_PI) * ((diam * 0.5f) * (diam * 0.5f) * (diam * 0.5f)); } } currentvol = currentvol + vol; gid++; } } return QString::number(gid); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int H5FilterParametersWriter::WritePipelineToFile(FilterPipeline::Pointer pipeline, QString filePath, QString name, IObserver* obs) { if (NULL == pipeline.get()) { if (NULL != obs) { PipelineMessage pm(H5FilterParametersWriter::ClassName(), "FilterPipeline Object was NULL for writing", -1, PipelineMessage::Error); obs->processPipelineMessage(pm); } return -1; } QFileInfo fileInfo(filePath); // WRITE THE PIPELINE TO THE HDF5 FILE H5FilterParametersWriter::Pointer writer = H5FilterParametersWriter::New(); hid_t fileId = -1; fileId = QH5Utilities::createFile(filePath); if (fileId < 0) { if (NULL != obs) { PipelineMessage pm(H5FilterParametersWriter::ClassName(), "Output .dream3d file could not be created.", -1, PipelineMessage::Error); obs->processPipelineMessage(pm); } return -1; } // This will make sure if we return early from this method that the HDF5 File is properly closed. // This will also take care of making sure all groups and file ids are closed // before this method returns. HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true); // Write our File Version string to the Root "/" group QH5Lite::writeStringAttribute(fileId, "/", DREAM3D::HDF5::FileVersionName, DREAM3D::HDF5::FileVersion); QH5Lite::writeStringAttribute(fileId, "/", DREAM3D::HDF5::DREAM3DVersion, DREAM3DLib::Version::Complete() ); hid_t pipelineGroupId = QH5Utilities::createGroup(fileId, DREAM3D::StringConstants::PipelineGroupName); scopedFileSentinel.addGroupId(&pipelineGroupId); writer->setGroupId(pipelineGroupId); FilterPipeline::FilterContainerType& filters = pipeline->getFilterContainer(); // Loop over each filter and write it's input parameters to the file int count = filters.size(); int index = 0; for (qint32 i = 0; i < count; ++i) { AbstractFilter::Pointer filter = filters.at(i); if (NULL != filter.get()) { index = filter->writeFilterParameters(writer.get(), index); } else { AbstractFilter::Pointer badFilter = AbstractFilter::New(); writer->openFilterGroup(badFilter.get(), i); writer->writeValue("Unknown Filter", "ERROR: Filter instance was NULL within the PipelineFilterWidget instance. Report this error to the DREAM3D Developers"); writer->closeFilterGroup(); } } return 0; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void DataContainerReader::readData(bool preflight, DataContainerArrayProxy& proxy, DataContainerArray::Pointer dca) { setErrorCondition(0); QString ss; int32_t err = 0; QString m_FileVersion; float fVersion = 0.0f; bool check = false; // qDebug() << "DataContainerReader::readData() " << m_InputFile; // Read the Meta Data and Array names from the file hid_t fileId = QH5Utilities::openFile(m_InputFile, true); // Open the file Read Only if (fileId < 0) { ss = QObject::tr("Error opening input file '%1'").arg(m_InputFile); setErrorCondition(-150); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } // This will make sure if we return early from this method that the HDF5 File is properly closed. HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true); // Check to see if version of .dream3d file is prior to new data container names err = QH5Lite::readStringAttribute(fileId, "/", DREAM3D::HDF5::FileVersionName, m_FileVersion); fVersion = m_FileVersion.toFloat(&check); if (fVersion < 5.0 || err < 0) { QH5Utilities::closeFile(fileId); fileId = QH5Utilities::openFile(m_InputFile, false); // Re-Open the file as Read/Write err = H5Lmove(fileId, "VoxelDataContainer", fileId, DREAM3D::Defaults::DataContainerName.toLatin1().data(), H5P_DEFAULT, H5P_DEFAULT); err = H5Lmove(fileId, "SurfaceMeshDataContainer", fileId, DREAM3D::Defaults::DataContainerName.toLatin1().data(), H5P_DEFAULT, H5P_DEFAULT); err = QH5Lite::writeStringAttribute(fileId, "/", DREAM3D::HDF5::FileVersionName, "5.0"); QH5Utilities::closeFile(fileId); fileId = QH5Utilities::openFile(m_InputFile, true); // Re-Open the file as Read Only } if (fVersion < 7.0) { ss = QObject::tr("File unable to be read - file structure older than 7.0"); setErrorCondition(-250); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } hid_t dcaGid = H5Gopen(fileId, DREAM3D::StringConstants::DataContainerGroupName.toLatin1().data(), 0); if (dcaGid < 0) { setErrorCondition(-1923123); QString ss = QObject::tr("Error attempting to open the HDF5 Group '%1'").arg(DREAM3D::StringConstants::DataContainerGroupName); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } scopedFileSentinel.addGroupId(&dcaGid); err = dca->readDataContainersFromHDF5(preflight, dcaGid, proxy, this); if (err < 0) { setErrorCondition(err); QString ss = QObject::tr("Error trying to read the DataContainers from the file '%1'").arg(getInputFile()); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } err = H5Gclose(dcaGid); dcaGid = -1; err = readDataContainerBundles(fileId, dca); if (err < 0) { setErrorCondition(err); QString ss = QObject::tr("Error trying to read the DataContainerBundles from the file '%1'").arg(getInputFile()); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } if (!getInPreflight()) { err = readExistingPipelineFromFile(fileId); if(err < 0) { setErrorCondition(err); QString ss = QObject::tr("Error trying to read the existing pipeline from the file '%1'").arg(getInputFile()); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } } }