read_sample()

std::optional< SpatialSample > MayaFlux::IO::SpatialReader::read_sample	(	const std::string &	stream_name,
		size_t	index
	)		const

Read one sample of a stream.

Fields the format does not carry for the stream's topology are empty: ids and velocities for a curves stream, vertex_counts_per_curve for points, and ids or velocities a points stream was written without.

Parameters

stream_name	Name from get_stream_names().
index	Sample index, below get_sample_count().

Returns

The sample, valid as described in the class doc, or nullopt for an unknown stream, an index out of range or a read failure; the reason is in get_last_error(). An unknown stream or index is not logged.

Definition at line 394 of file SpatialReader.cpp.

{
    if (!m_impl->archive.valid()) {
        set_error("read_sample: no archive open");
        return std::nullopt;
    }
 
    const auto it = m_impl->records.find(stream_name);
    if (it == m_impl->records.end()) {
        set_error("read_sample: no stream named '" + stream_name + "'");
        return std::nullopt;
    }
 
    auto& record = it->second;
    if (index >= record.sample_count) {
        set_error("read_sample: index " + std::to_string(index) + " out of range for '"
            + stream_name + "' (" + std::to_string(record.sample_count) + " samples)");
        return std::nullopt;
    }
 
    try {
        const ISampleSelector selector(static_cast<index_t>(index));
        SampleStorage fresh;
        ICompoundProperty arb;
 
        if (auto* points = std::get_if<IPoints>(&record.object)) {
            auto& schema = points->getSchema();
            IPointsSchema::Sample sample;
            schema.get(sample, selector);
 
            fresh.positions = copy_array<glm::vec3>(sample.getPositions());
            fresh.ids = copy_array<uint64_t>(sample.getIds());
            fresh.velocities = copy_array<glm::vec3>(sample.getVelocities());
            arb = schema.getArbGeomParams();
        } else if (auto* curves = std::get_if<ICurves>(&record.object)) {
            auto& schema = curves->getSchema();
            ICurvesSchema::Sample sample;
            schema.get(sample, selector);
 
            fresh.positions = copy_array<glm::vec3>(sample.getPositions());
            fresh.vertex_counts_per_curve = copy_array<int32_t>(sample.getCurvesNumVertices());
            arb = schema.getArbGeomParams();
 
            if (!record.warned_curve_type
                && (sample.getType() != kLinear || sample.getWrap() != kNonPeriodic)) {
                record.warned_curve_type = true;
                MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                    "SpatialReader: '{}' is not linear and non periodic, its control points are "
                    "returned as plain polylines",
                    stream_name);
            }
        }
 
        if (arb.valid()) {
            for (const auto& decl : record.attributes) {
                auto attribute = read_attribute(arb, decl, selector);
                if (!attribute) {
                    MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                        "SpatialReader: '{}' sample {}: attribute '{}' has an unsupported scope or "
                        "no values, skipped",
                        stream_name, index, decl.name);
                    continue;
                }
                fresh.attributes.push_back(std::move(*attribute));
            }
        }
 
        record.storage = std::move(fresh);
        return SpatialSample {
            .topology = record.topology,
            .positions = record.storage.positions,
            .vertex_counts_per_curve = record.storage.vertex_counts_per_curve,
            .ids = record.storage.ids,
            .velocities = record.storage.velocities,
            .attributes = record.storage.attributes,
        };
    } catch (const std::exception& e) {
        set_error(std::string("read_sample: ") + e.what());
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "SpatialReader::read_sample: '{}' sample {}: {}", stream_name, index, e.what());
        return std::nullopt;
    }
}

References MayaFlux::Journal::FileIO, index, MayaFlux::Journal::IO, m_impl, MF_ERROR, MF_WARN, points, set_error(), and MayaFlux::IO::SpatialSample::topology.

Here is the call graph for this function: