materialize()

std::optional< Kakshya::VolumeData > MayaFlux::IO::VolumeReader::materialize ( const std::vector< size_t > &  indices, const glm::ivec3 &  region_min, const Kinesis::Lattice3D &  lattice  ) const

private

Build VolumeData from selected grids over an explicit region.

Parameters

indices	Grid indices, in the order fields should appear.
region_min	Voxel-index origin, in the first grid's index space.
lattice	Output lattice. Its resolution drives every read_dense_scalar/read_dense_vector call.

Returns

Populated VolumeData, or nullopt on failure.

Definition at line 232 of file VolumeReader.cpp.

{
    constexpr float k_transform_epsilon = 1e-5F;
 
    const auto reference = m_archive->grid_summary(indices.front());
    for (size_t idx : indices) {
        if (idx == indices.front()) {
            continue;
        }
        const auto summary = m_archive->grid_summary(idx);
        const bool mismatched = glm::any(glm::greaterThan(
                                     glm::abs(summary.voxel_size - reference.voxel_size), glm::vec3(k_transform_epsilon)))
            || glm::any(glm::greaterThan(
                glm::abs(summary.translation - reference.translation), glm::vec3(k_transform_epsilon)));
        if (mismatched) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "VolumeReader: grid '{}' has a different voxel size or translation than '{}', "
                "its voxel indices are read directly against the shared region and will not be aligned",
                summary.name, reference.name);
        }
    }
 
    Kakshya::VolumeData result;
    result.lattice = lattice;
    result.fields.reserve(indices.size());
 
    for (size_t idx : indices) {
        const auto summary = m_archive->grid_summary(idx);
 
        Kakshya::VolumeField field;
        field.name = summary.name;
        field.semantics.value_class = class_from_token(m_archive->grid_metadata(idx, "class"));
 
        bool precision_lost = false;
 
        if (summary.is_vector) {
            field.semantics.variance = variance_from_token(m_archive->grid_metadata(idx, "vector_type"));
 
            std::vector<glm::vec3> values;
            if (!m_archive->read_dense_vector(
                    idx, region_min, lattice.resolution, summary.background_vector, values, &precision_lost)) {
                set_error(std::string(m_archive->last_error()));
                return std::nullopt;
            }
            field.values = std::move(values);
        } else {
            std::vector<float> values;
            if (!m_archive->read_dense_scalar(
                    idx, region_min, lattice.resolution, summary.background_scalar, values, &precision_lost)) {
                set_error(std::string(m_archive->last_error()));
                return std::nullopt;
            }
            field.values = std::move(values);
        }
 
        if (precision_lost) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "VolumeReader: grid '{}' is not float/vec3f, narrowing to {} lost precision in at least one value",
                summary.name, summary.is_vector ? "vec3" : "float");
        } else if (summary.narrowed) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "VolumeReader: grid '{}' is not float/vec3f, narrowing to {} losslessly",
                summary.name, summary.is_vector ? "vec3" : "float");
        }
 
        MF_DEBUG(Journal::Component::IO, Journal::Context::FileIO,
            "VolumeReader: materialized '{}', {} cells", field.name, field.element_count());
 
        result.fields.push_back(std::move(field));
    }
 
    if (result.fields.empty()) {
        set_error("No fields materialized");
        return std::nullopt;
    }
 
    if (!result.is_consistent()) {
        set_error("Resulting VolumeData failed is_consistent()");
        return std::nullopt;
    }
 
    return result;
}

References MayaFlux::Kakshya::VolumeField::element_count(), MayaFlux::Kakshya::VolumeData::fields, MayaFlux::Journal::FileIO, MayaFlux::Journal::IO, MayaFlux::Kakshya::VolumeData::is_consistent(), MayaFlux::Kakshya::VolumeData::lattice, m_archive, MF_DEBUG, MF_WARN, MayaFlux::Kakshya::VolumeField::name, precision_lost, region_min, MayaFlux::Kinesis::Lattice3D::resolution, MayaFlux::Kakshya::VolumeField::semantics, set_error(), MayaFlux::Kinesis::LatticeSemantics::value_class, values, MayaFlux::Kakshya::VolumeField::values, and MayaFlux::Kinesis::LatticeSemantics::variance.

Referenced by extract(), and extract().

Here is the call graph for this function:

Here is the caller graph for this function: