reconstruct_data_variant_from_double()

Kakshya::DataVariant MayaFlux::Yantra::OperationHelper::reconstruct_data_variant_from_double ( const std::vector< double > &  double_data, const DataStructureInfo &  structure_info  )

staticprivate

Reconstruct DataVariant from double data and structure info.

interleave_channels (called before this function) produces sample-major layout: [x0,y0,z0, x1,y1,z1, ...]. Eigen default storage is column-major. With rows=components and cols=elements, Eigen::Map reads column 0 as [x0,y0,z0], column 1 as [x1,y1,z1], which matches the interleaved order.

Definition at line 126 of file OperationHelper.cpp.

{
    if (double_data.empty()) {
        return Kakshya::DataVariant { std::vector<double> {} };
    }
 
    auto interp = detail::modality_to_interpretation(
        structure_info.modality, structure_info.original_type);
 
    if (interp == Kakshya::MatrixInterpretation::SCALAR) {
        if (structure_info.original_type == std::type_index(typeid(std::vector<float>))) {
            std::vector<float> float_data;
            float_data.reserve(double_data.size());
            std::ranges::transform(double_data, std::back_inserter(float_data),
                [](double v) { return static_cast<float>(v); });
            return Kakshya::DataVariant { std::move(float_data) };
        }
 
        if (structure_info.original_type == std::type_index(typeid(std::vector<uint8_t>))) {
            std::vector<uint8_t> u8_data;
            u8_data.reserve(double_data.size());
            std::ranges::transform(double_data, std::back_inserter(u8_data),
                [](double v) { return static_cast<uint8_t>(std::clamp(v, 0.0, 255.0)); });
            return Kakshya::DataVariant { std::move(u8_data) };
        }
 
        if (structure_info.original_type == std::type_index(typeid(std::vector<uint16_t>))) {
            std::vector<uint16_t> u16_data;
            u16_data.reserve(double_data.size());
            std::ranges::transform(double_data, std::back_inserter(u16_data),
                [](double v) { return static_cast<uint16_t>(std::clamp(v, 0.0, 65535.0)); });
            return Kakshya::DataVariant { std::move(u16_data) };
        }
 
        if (structure_info.original_type == std::type_index(typeid(std::vector<uint32_t>))) {
            std::vector<uint32_t> u32_data;
            u32_data.reserve(double_data.size());
            std::ranges::transform(double_data, std::back_inserter(u32_data),
                [](double v) { return static_cast<uint32_t>(std::max(v, 0.0)); });
            return Kakshya::DataVariant { std::move(u32_data) };
        }
 
        return Kakshya::DataVariant { double_data };
    }
 
    size_t rows = detail::interpretation_row_count(interp);
 
    if (double_data.size() % rows != 0) {
        return Kakshya::DataVariant { double_data };
    }
 
    /**
     * interleave_channels (called before this function) produces
     * sample-major layout: [x0,y0,z0, x1,y1,z1, ...].
     * Eigen default storage is column-major.  With rows=components
     * and cols=elements, Eigen::Map reads column 0 as [x0,y0,z0],
     * column 1 as [x1,y1,z1], which matches the interleaved order.
     */
    auto r = static_cast<Eigen::Index>(rows);
    auto c = static_cast<Eigen::Index>(double_data.size() / rows);
 
    Eigen::Map<const Eigen::MatrixXd> mapped(double_data.data(), r, c);
 
    return Kakshya::from_eigen_matrix(mapped, interp);
}

References MayaFlux::Kakshya::from_eigen_matrix(), MayaFlux::Yantra::detail::interpretation_row_count(), MayaFlux::Yantra::DataStructureInfo::modality, MayaFlux::Yantra::detail::modality_to_interpretation(), MayaFlux::Yantra::DataStructureInfo::original_type, and MayaFlux::Kakshya::SCALAR.

Referenced by reconstruct_from_double().

Here is the call graph for this function:

Here is the caller graph for this function: