libCZI_DimCoordinate.h

//******************************************************************************
// 
// libCZI is a reader for the CZI fileformat written in C++
// Copyright (C) 2017  Zeiss Microscopy GmbH
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// 
// To obtain a commercial version please contact Zeiss Microscopy GmbH.
// 
//******************************************************************************

#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;

        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;

        inline bool IsValid(DimensionIndex dim) const
        {
            return this->TryGetInterval(dim, nullptr, nullptr);
        }
    };

    class LIBCZI_API IIndexSet
    {
    public:

        virtual bool IsContained(int index) const = 0;
    };

    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[(int)(libCZI::DimensionIndex::MaxDim)];
    public:
        CDimCoordinate() : validDims(0) {}

        CDimCoordinate(std::initializer_list<DimensionAndValue> list) : CDimCoordinate()
        {
            for (auto d : list)
            {
                this->Set(d.dimension, d.value);
            }
        }

        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)
        {
            auto index = CDimCoordinate::GetBitIndexForDimension(dimension);
            this->validDims &= ~(1 << index);
        }

        void Clear()
        {
            this->validDims = 0;
        }

        void EnumValidDimensions(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
        virtual bool TryGetPosition(libCZI::DimensionIndex dim, int* coordinate) const
        {
            auto 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[(int)(libCZI::DimensionIndex::MaxDim)];
        int size[(int)(libCZI::DimensionIndex::MaxDim)];
    public:
        CDimBounds() : validDims(0) {};

        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)
        {
            int index = CDimBounds::GetBitIndexForDimension(dimension);
            this->start[index] = start;
            this->size[index] = size;
            this->validDims |= (1 << index);
        }

        void EnumValidDimensions(std::function<bool(libCZI::DimensionIndex dim, int start, int size)> func) const
        {
            for (int i = (int)(libCZI::DimensionIndex::MinDim); i <= (int)(libCZI::DimensionIndex::MaxDim); ++i)
            {
                int bitIndex = CDimBase::GetBitIndexForDimension((libCZI::DimensionIndex) i);
                if ((this->validDims & (1 << bitIndex)) != 0)
                {
                    if (func((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
        virtual bool TryGetInterval(libCZI::DimensionIndex dim, int* startIndex, int* size) 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;
        }
    };
}