libCZI_DimCoordinate.h

// SPDX-FileCopyrightText: 2017-2022 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include "ImportExport.h"
#include "libCZI_exceptions.h"
#include <cstdint>
#include <functional>
#include <initializer_list>
 
namespace libCZI
{
    enum class DimensionIndex : std::uint8_t
    {
        invalid = 0,    
 
        MinDim = 1,     
 
        Z = 1,          
        C = 2,          
        T = 3,          
        R = 4,          
        S = 5,          
        I = 6,          
        H = 7,          
        V = 8,          
        B = 9,          
 
        MaxDim = 9      
    };
 
    class LIBCZI_API IDimCoordinate
    {
    public:
 
        virtual bool TryGetPosition(DimensionIndex dim, int* coordinate) const = 0;
 
        virtual ~IDimCoordinate() = default;
 
        inline bool IsValid(DimensionIndex dim) const
        {
            return this->TryGetPosition(dim, nullptr);
        }
 
        inline int GetNumberOfValidDimensions() const
        {
            int cnt = 0;
            for (auto i = static_cast<std::underlying_type<libCZI::DimensionIndex>::type>(libCZI::DimensionIndex::MinDim); i <= static_cast<std::underlying_type<libCZI::DimensionIndex>::type>(libCZI::DimensionIndex::MaxDim); ++i)
            {
                if (this->IsValid(static_cast<libCZI::DimensionIndex>(i)))
                {
                    ++cnt;
                }
            }
 
            return cnt;
        }
    };
 
    class LIBCZI_API IDimBounds
    {
    public:
 
        virtual bool TryGetInterval(DimensionIndex dim, int* startIndex, int* size) const = 0;
 
        virtual ~IDimBounds() = default;
 
        inline bool IsValid(DimensionIndex dim) const
        {
            return this->TryGetInterval(dim, nullptr, nullptr);
        }
    };
 
    class LIBCZI_API IIndexSet
    {
    public:
 
        virtual bool IsContained(int index) const = 0;
 
        virtual ~IIndexSet() = default;
    };
 
    struct DimensionAndValue
    {
        libCZI::DimensionIndex dimension;   
        int value;                          
    };
 
    struct DimensionAndStartSize
    {
        libCZI::DimensionIndex dimension;   
        int start;                          
        int size;                           
    };
 
    class LIBCZI_API CDimBase
    {
    protected:
        static std::underlying_type<libCZI::DimensionIndex>::type GetBitIndexForDimension(libCZI::DimensionIndex dim)
        {
            // TODO: add checks and asserts
            auto i = ((std::underlying_type<libCZI::DimensionIndex>::type)dim) - 1;
            return i;
        }
    };
 
    class LIBCZI_API CDimCoordinate : public CDimBase, public libCZI::IDimCoordinate
    {
    private:
        std::uint32_t validDims;
        int values[static_cast<int>(libCZI::DimensionIndex::MaxDim)];
    public:
        CDimCoordinate() : validDims(0) {}
 
        CDimCoordinate(std::initializer_list<DimensionAndValue> list) : CDimCoordinate()
        {
            for (const auto& d : list)
            {
                this->Set(d.dimension, d.value);
            }
        }
 
        explicit CDimCoordinate(const libCZI::IDimCoordinate* other) : CDimCoordinate()
        {
            if (other != nullptr)
            {
                for (auto i = (std::underlying_type<libCZI::DimensionIndex>::type)(libCZI::DimensionIndex::MinDim); i <= (std::underlying_type<libCZI::DimensionIndex>::type)(libCZI::DimensionIndex::MaxDim); ++i)
                {
                    int coord;
                    if (other->TryGetPosition((libCZI::DimensionIndex)i, &coord))
                    {
                        this->Set((libCZI::DimensionIndex)i, coord);
                    }
                }
            }
        }
 
        void Set(libCZI::DimensionIndex dimension, int value)
        {
            int index = CDimCoordinate::GetBitIndexForDimension(dimension);
            this->values[index] = value;
            this->validDims |= (1 << index);
        }
 
        void Clear(libCZI::DimensionIndex dimension)
        {
            int index = CDimCoordinate::GetBitIndexForDimension(dimension);
            this->validDims &= ~(1 << index);
        }
 
        void Clear()
        {
            this->validDims = 0;
        }
 
        void EnumValidDimensions(const std::function<bool(libCZI::DimensionIndex dim, int value)>& func) const
        {
            for (auto i = (std::underlying_type<libCZI::DimensionIndex>::type)(libCZI::DimensionIndex::MinDim); i <= (std::underlying_type<libCZI::DimensionIndex>::type)(libCZI::DimensionIndex::MaxDim); ++i)
            {
                int bitIndex = CDimCoordinate::GetBitIndexForDimension((libCZI::DimensionIndex)i);
                if ((this->validDims & (1 << bitIndex)) != 0)
                {
                    if (func((libCZI::DimensionIndex)i, this->values[bitIndex]) != true)
                        break;
                }
            }
        }
 
        int GetValidDimensionsCount() const
        {
            int count = 0;
            for (auto i = (std::underlying_type<libCZI::DimensionIndex>::type)(libCZI::DimensionIndex::MinDim); i <= (std::underlying_type<libCZI::DimensionIndex>::type)(libCZI::DimensionIndex::MaxDim); ++i)
            {
                int bitIndex = CDimCoordinate::GetBitIndexForDimension((libCZI::DimensionIndex)i);
                if ((this->validDims & (1 << bitIndex)) != 0)
                {
                    ++count;
                }
            }
 
            return count;
        }
 
        static CDimCoordinate Parse(const char* str);
    public: // IDimCoordinate
        bool TryGetPosition(libCZI::DimensionIndex dim, int* coordinate) const override
        {
            const int index = CDimCoordinate::GetBitIndexForDimension(dim);
            if ((this->validDims & (1 << index)) != 0)
            {
                if (coordinate != nullptr)
                {
                    *coordinate = this->values[index];
                }
 
                return true;
            }
 
            return false;
        }
    };
 
    class LIBCZI_API CDimBounds : public CDimBase, public libCZI::IDimBounds
    {
    private:
        std::uint32_t validDims;
        int start[static_cast<int>(libCZI::DimensionIndex::MaxDim)];
        int size[static_cast<int>(libCZI::DimensionIndex::MaxDim)];
    public:
        CDimBounds() : validDims(0) {}
 
        explicit CDimBounds(const IDimBounds* other) : validDims(0)
        {
            if (other != nullptr)
            {
                for (int i = static_cast<int>(libCZI::DimensionIndex::MinDim); i <= static_cast<int>(libCZI::DimensionIndex::MaxDim); ++i)
                {
                    int start, size;
                    if (other->TryGetInterval(static_cast<DimensionIndex>(i), &start, &size))
                    {
                        this->Set(static_cast<DimensionIndex>(i), start, size);
                    }
                }
            }
        }
 
        CDimBounds(std::initializer_list<DimensionAndStartSize> list) : CDimBounds()
        {
            for (auto d : list)
            {
                this->Set(d.dimension, d.start, d.size);
            }
        }
 
        void Set(libCZI::DimensionIndex dimension, int start, int size)
        {
            const int index = CDimBounds::GetBitIndexForDimension(dimension);
            this->start[index] = start;
            this->size[index] = size;
            this->validDims |= (1 << index);
        }
 
        void EnumValidDimensions(const std::function<bool(libCZI::DimensionIndex dim, int start, int size)>& func) const
        {
            for (int i = static_cast<int>(libCZI::DimensionIndex::MinDim); i <= static_cast<int>(libCZI::DimensionIndex::MaxDim); ++i)
            {
                const int bitIndex = CDimBase::GetBitIndexForDimension(static_cast<libCZI::DimensionIndex>(i));
                if ((this->validDims & (1 << bitIndex)) != 0)
                {
                    if (func(static_cast<libCZI::DimensionIndex>(i), this->start[bitIndex], this->size[bitIndex]) != true)
                    {
                        break;
                    }
                }
            }
        }
 
        void Clear(libCZI::DimensionIndex dimension)
        {
            int index = CDimBounds::GetBitIndexForDimension(dimension);
            this->validDims &= ~(1 << index);
        }
 
        void Clear()
        {
            this->validDims = 0;
        }
 
        bool IsEmpty() const
        {
            return this->validDims == 0;
        }
 
        static CDimBounds Parse(const char* str);
 
    public: // IDimBounds
        bool TryGetInterval(libCZI::DimensionIndex dim, int* startIndex, int* size) const override
        {
            const int index = CDimBounds::GetBitIndexForDimension(dim);
            if ((this->validDims & (1 << index)) != 0)
            {
                if (startIndex != nullptr)
                {
                    *startIndex = this->start[index];
                }
 
                if (size != nullptr)
                {
                    *size = this->size[index];
                }
 
                return true;
            }
 
            return false;
        }
    };
}