detect_data_dimensions() [1/3]

std::vector< Kakshya::DataDimension > MayaFlux::Kakshya::detect_data_dimensions

(

const DataVariant &

data

)

Detect data dimensions from a DataVariant.

Parameters

data	DataVariant to analyze

Returns

Vector of DataDimension descriptors

This function analyzes the structure of the provided DataVariant and extracts dimension information, including size, stride, and semantic roles.

Definition at line 184 of file DataUtils.cpp.

{
    std::cerr << "Inferring structure from single DataVariant...\n"
              << "This is not advisable as the method makes naive assumptions that can lead to massive computational errors\n"
              << "If the variant is part of a container, region, or segment, please use the appropriate method instead.\n"
              << "If the variant is part of a vector, please use infer_from_data_variant_vector instead.\n"
              << "If you are sure you want to proceed, please ignore this warning.\n";
 
    return std::visit([](const auto& vec) -> std::vector<DataDimension> {
        using ValueType = typename std::decay_t<decltype(vec)>::value_type;
 
        std::vector<DataDimension> dims;
 
        if constexpr (DecimalData<ValueType>) {
            dims.emplace_back(DataDimension::time(vec.size()));
 
        } else if constexpr (ComplexData<ValueType>) {
            dims.emplace_back(DataDimension::frequency(vec.size()));
 
        } else if constexpr (IntegerData<ValueType>) {
            // uint8_t, uint16_t, uint32_t -> flattened 2D (images typically)
            // Need to guess reasonable 2D dimensions from 1D size
            uint64_t total_size = vec.size();
 
            if (total_size == 0) {
                dims.emplace_back(DataDimension::spatial(0, 'x'));
                dims.emplace_back(DataDimension::spatial(0, 'y'));
            } else {
                auto sqrt_size = static_cast<uint64_t>(std::sqrt(total_size));
                if (sqrt_size * sqrt_size == total_size) {
                    dims.emplace_back(DataDimension::spatial(sqrt_size, 'x'));
                    dims.emplace_back(DataDimension::spatial(sqrt_size, 'y'));
                } else {
                    uint64_t width = sqrt_size;
                    uint64_t height = total_size / width;
                    while (width * height != total_size && width > 1) {
                        width--;
                        height = total_size / width;
                    }
                    dims.emplace_back(DataDimension::spatial(height, 'y'));
                    dims.emplace_back(DataDimension::spatial(width, 'x'));
                }
            }
        } else if constexpr (GlmData<ValueType>) {
            constexpr size_t components = glm_component_count<ValueType>();
            DataDimension::Role role = DataDimension::Role::CUSTOM;
 
            if constexpr (GlmVec2Type<ValueType>) {
                role = DataDimension::Role::UV;
            } else if constexpr (GlmVec3Type<ValueType>) {
                role = DataDimension::Role::POSITION;
            } else if constexpr (GlmVec4Type<ValueType>) {
                role = DataDimension::Role::COLOR;
            } else if constexpr (GlmMatrixType<ValueType>) {
                role = DataDimension::Role::CUSTOM;
            }
 
            dims.push_back(DataDimension::grouped(
                "glm_structured_data",
                static_cast<uint64_t>(vec.size()),
                static_cast<uint8_t>(components),
                role));
        } else {
            dims.emplace_back(DataDimension::time(vec.size()));
        }
 
        return dims;
    },
        data);
}

References MayaFlux::Kakshya::DataDimension::COLOR, MayaFlux::Kakshya::DataDimension::CUSTOM, MayaFlux::Kakshya::DataDimension::frequency(), MayaFlux::Kakshya::DataDimension::grouped(), MayaFlux::Kakshya::DataDimension::POSITION, MayaFlux::Kakshya::DataDimension::spatial(), MayaFlux::Kakshya::DataDimension::time(), and MayaFlux::Kakshya::DataDimension::UV.

Referenced by MayaFlux::Yantra::infer_from_data_variant(), and MayaFlux::Yantra::infer_from_data_variant_vector().

Here is the call graph for this function:

Here is the caller graph for this function: