create_variants()

template<typename T >

static std::vector< DataVariant > MayaFlux::Kakshya::DataDimension::create_variants ( DataModality  modality, const std::vector< uint64_t > &  shape, T  default_value, OrganizationStrategy  org = OrganizationStrategy::PLANAR  )

inlinestaticprivate

Create data variants for a specific modality.

Template Parameters

T	Data type for storage

Parameters

modality	Target data modality
shape	Dimensional sizes
default_value	Initial value for elements
org	Organization strategy

Returns

Vector of DataVariant objects

Definition at line 514 of file NDData.hpp.

    {
        std::vector<DataVariant> variants;
 
        if (org == OrganizationStrategy::INTERLEAVED) {
            uint64_t total = std::accumulate(shape.begin(), shape.end(), uint64_t(1), std::multiplies<>());
            variants.emplace_back(std::vector<T>(total, default_value));
            return variants;
        }
 
        switch (modality) {
        case DataModality::AUDIO_1D:
            variants.emplace_back(std::vector<T>(shape[0], default_value));
            break;
 
        case DataModality::AUDIO_MULTICHANNEL: {
            uint64_t samples = shape[0];
            uint64_t channels = shape[1];
            variants.reserve(channels);
            for (uint64_t ch = 0; ch < channels; ++ch) {
                variants.emplace_back(std::vector<T>(samples, default_value));
            }
            break;
        }
 
        case DataModality::IMAGE_2D:
            variants.emplace_back(std::vector<T>(shape[0] * shape[1], default_value));
            break;
 
        case DataModality::IMAGE_COLOR: {
            uint64_t height = shape[0];
            uint64_t width = shape[1];
            uint64_t channels = shape[2];
            uint64_t pixels = height * width;
            variants.reserve(channels);
            for (uint64_t ch = 0; ch < channels; ++ch) {
                variants.emplace_back(std::vector<T>(pixels, default_value));
            }
            break;
        }
 
        case DataModality::DEPTH_MAP: {
            uint64_t pixels = shape[0] * shape[1];
            uint64_t components = shape[2];
            variants.reserve(components);
            for (uint64_t c = 0; c < components; ++c) {
                variants.emplace_back(std::vector<T>(pixels, default_value));
            }
            break;
        }
 
        case DataModality::SPECTRAL_2D:
            variants.emplace_back(std::vector<T>(shape[0] * shape[1], default_value));
            break;
 
        case DataModality::VOLUMETRIC_3D:
            variants.emplace_back(std::vector<T>(shape[0] * shape[1] * shape[2], default_value));
            break;
 
        case DataModality::VIDEO_GRAYSCALE: {
            uint64_t frames = shape[0];
            uint64_t height = shape[1];
            uint64_t width = shape[2];
            uint64_t frame_size = height * width;
            variants.reserve(frames);
            for (uint64_t f = 0; f < frames; ++f) {
                variants.emplace_back(std::vector<T>(frame_size, default_value));
            }
            break;
        }
 
        case DataModality::VIDEO_COLOR: {
            uint64_t frames = shape[0];
            uint64_t height = shape[1];
            uint64_t width = shape[2];
            uint64_t channels = shape[3];
            uint64_t frame_size = height * width;
            variants.reserve(frames * channels);
            for (uint64_t f = 0; f < frames; ++f) {
                for (uint64_t ch = 0; ch < channels; ++ch) {
                    variants.emplace_back(std::vector<T>(frame_size, default_value));
                }
            }
            break;
        }
 
        case DataModality::VIDEO_DEPTH: {
            uint64_t frames = shape[0];
            uint64_t pixels = shape[1] * shape[2];
            uint64_t components = shape[3];
            variants.reserve(components);
            for (uint64_t c = 0; c < components; ++c) {
                variants.emplace_back(std::vector<T>(frames * pixels, default_value));
            }
            break;
        }
 
        default:
            uint64_t total = std::accumulate(shape.begin(), shape.end(), uint64_t(1), std::multiplies<>());
            variants.emplace_back(std::vector<T>(total, default_value));
            break;
        }
 
        return variants;
    }

References channels, height, pixels, total, and width.