detect_data_dimensions() [2/3]

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

(

const std::vector< DataVariant > &

variants

)

Definition at line 255 of file DataUtils.cpp.

{
    std::cerr << "Inferring structure from DataVariant vector...\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 you are sure you want to proceed, please ignore this warning.\n";
 
    if (variants.empty()) {
        std::vector<DataDimension> dims;
        dims.emplace_back("empty_variants", 0, 1, DataDimension::Role::CUSTOM);
        return dims;
    }
 
    std::vector<DataDimension> dimensions;
    size_t variant_count = variants.size();
 
    size_t first_variant_size = std::visit([](const auto& vec) -> size_t {
        return vec.size();
    },
        variants[0]);
 
    bool consistent_glm = std::ranges::all_of(variants, [](const auto& variant) {
        return std::visit([](const auto& vec) -> bool {
            using ValueType = typename std::decay_t<decltype(vec)>::value_type;
            return GlmData<ValueType>;
        },
            variant);
    });
 
    bool consistent_decimal = std::ranges::all_of(variants, [](const auto& variant) {
        return std::visit([](const auto& vec) -> bool {
            using ValueType = typename std::decay_t<decltype(vec)>::value_type;
            return MayaFlux::DecimalData<ValueType>;
        },
            variant);
    });
 
    bool consistent_complex = std::ranges::all_of(variants, [](const auto& variant) {
        return std::visit([](const auto& vec) -> bool {
            using ValueType = typename std::decay_t<decltype(vec)>::value_type;
            return MayaFlux::ComplexData<ValueType>;
        },
            variant);
    });
 
    bool consistent_integer = std::ranges::all_of(variants, [](const auto& variant) {
        return std::visit([](const auto& vec) -> bool {
            using ValueType = typename std::decay_t<decltype(vec)>::value_type;
            return MayaFlux::IntegerData<ValueType>;
        },
            variant);
    });
 
    if (consistent_glm) {
        dimensions.emplace_back(DataDimension::channel(variant_count));
 
        std::visit([&](const auto& first_vec) {
            using ValueType = typename std::decay_t<decltype(first_vec)>::value_type;
            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;
            }
 
            dimensions.emplace_back(DataDimension::grouped(
                "glm_elements",
                first_variant_size,
                static_cast<uint8_t>(components),
                role));
        },
            variants[0]);
 
        return dimensions;
    }
 
    if (variant_count == 1) {
        if (consistent_decimal) {
            dimensions.emplace_back(DataDimension::time(first_variant_size, "samples"));
        } else if (consistent_complex) {
            dimensions.emplace_back(DataDimension::frequency(first_variant_size, "frequency_data"));
        } else if (consistent_integer) {
            dimensions.emplace_back(DataDimension::spatial(first_variant_size, 'x', 1, "data_points"));
        } else {
            dimensions.emplace_back("unknown_data", first_variant_size, 1,
                DataDimension::Role::CUSTOM);
        }
 
    } else if (variant_count == 2 && (consistent_decimal || consistent_complex || consistent_integer)) {
        dimensions.emplace_back(DataDimension::channel(2));
        if (consistent_decimal) {
            dimensions.emplace_back(DataDimension::time(first_variant_size, "samples"));
        } else if (consistent_complex) {
            dimensions.emplace_back(DataDimension::frequency(first_variant_size, "bins"));
        } else {
            dimensions.emplace_back(DataDimension::spatial(first_variant_size, 'x', 1, "elements"));
        }
 
    } else if (variant_count <= 16 && (consistent_decimal || consistent_complex || consistent_integer)) {
        dimensions.emplace_back(DataDimension::channel(variant_count));
        if (consistent_decimal) {
            dimensions.emplace_back(DataDimension::time(first_variant_size, "samples"));
        } else if (consistent_complex) {
            dimensions.emplace_back(DataDimension::frequency(first_variant_size, "bins"));
        } else {
            dimensions.emplace_back(DataDimension::spatial(first_variant_size, 'x', 1, "pixels"));
        }
 
    } else if (consistent_decimal || consistent_complex || consistent_integer) {
        if (consistent_decimal) {
            dimensions.emplace_back(DataDimension::time(variant_count, "time_blocks"));
            dimensions.emplace_back("block_samples", first_variant_size, 1,
                DataDimension::Role::CUSTOM);
        } else if (consistent_complex) {
            dimensions.emplace_back(DataDimension::time(variant_count, "time_windows"));
            dimensions.emplace_back(DataDimension::frequency(first_variant_size, "frequency_bins"));
        } else {
            dimensions.emplace_back(DataDimension::time(variant_count, "frames"));
            dimensions.emplace_back(DataDimension::spatial(first_variant_size, 'x', 1, "frame_data"));
        }
 
    } else {
        dimensions.emplace_back("mixed_variants", variant_count, 1,
            DataDimension::Role::CUSTOM);
        dimensions.emplace_back("variant_data", first_variant_size, 1,
            DataDimension::Role::CUSTOM);
    }
 
    return dimensions;
}

References MayaFlux::Kakshya::DataDimension::channel(), 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.

Here is the call graph for this function: