libCZI_Utilities.h

// SPDX-FileCopyrightText: 2017-2022 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <vector>
#include <tuple>
#include <limits>
#include <utility>
#include <memory>
#include <string>
#include <cstdint>
#include "libCZI_Metadata.h"
#include "libCZI_Pixels.h"
 
namespace libCZI
{
    struct LIBCZI_API GUID
    {
        std::uint32_t Data1; 
        std::uint16_t Data2; 
        std::uint16_t Data3; 
        std::uint8_t  Data4[8]; 
 
        bool operator==(const GUID& other) const
        {
            return this->Data1 == other.Data1 &&
                this->Data2 == other.Data2 &&
                this->Data3 == other.Data3 &&
                this->Data4[0] == other.Data4[0] &&
                this->Data4[1] == other.Data4[1] &&
                this->Data4[2] == other.Data4[2] &&
                this->Data4[3] == other.Data4[3] &&
                this->Data4[4] == other.Data4[4] &&
                this->Data4[5] == other.Data4[5] &&
                this->Data4[6] == other.Data4[6] &&
                this->Data4[7] == other.Data4[7];
        }
 
        bool operator!=(const GUID& other) const
        {
            return !(*this == other);
        }
 
        int compare(const GUID& other) const
        {
            if (this->Data1 != other.Data1)
            {
                return this->Data1 < other.Data1 ? -1 : 1;
            }
 
            if (this->Data2 != other.Data2)
            {
                return this->Data2 < other.Data2 ? -1 : 1;
            }
 
            if (this->Data3 != other.Data3)
            {
                return this->Data3 < other.Data3 ? -1 : 1;
            }
 
            for (int i = 0; i < 8; ++i)
            {
                if (this->Data4[i] != other.Data4[i])
                {
                    return this->Data4[i] < other.Data4[i] ? -1 : 1;
                }
            }
 
            return 0;
        }
    };
 
    class ISubBlockRepository;
    class IDisplaySettings;
    class ICompressParameters;
 
    class LIBCZI_API Utils
    {
    public:
        static char DimensionToChar(libCZI::DimensionIndex dim);
 
        static libCZI::DimensionIndex CharToDimension(char c);
 
        static int CalcMd5SumHash(libCZI::IBitmapData* bm, std::uint8_t* ptrHash, int hashSize);
 
        static int CalcMd5SumHash(const void* ptrData, size_t sizeData, std::uint8_t* ptrHash, int hashSize);
 
        static std::vector<std::uint8_t> Create8BitLookUpTableFromSplines(int tableElementCnt, float blackPoint, float whitePoint, const std::vector<libCZI::IDisplaySettings::SplineData>& splineData);
 
        static std::vector<std::uint8_t> Create8BitLookUpTableFromGamma(int tableElementCnt, float blackPoint, float whitePoint, float gamma);
 
        static std::vector<std::uint16_t> Create16BitLookUpTableFromGamma(int tableElementCnt, float blackPoint, float whitePoint, float gamma);
 
        static std::vector<libCZI::IDisplaySettings::SplineData> CalcSplineDataFromPoints(int pointCnt, std::function< std::tuple<double, double>(int idx)> getPoint);
 
        static std::shared_ptr<libCZI::IBitmapData > NearestNeighborResize(libCZI::IBitmapData* bmSrc, int dstWidth, int dstHeight);
 
        static std::shared_ptr<libCZI::IBitmapData > NearestNeighborResize(libCZI::IBitmapData* bmSrc, int dstWidth, int dstHeight, const DblRect& roiSrc, const DblRect& roiDest);
 
        static float CalcZoom(const libCZI::IntRect& logicalRect, const libCZI::IntSize& physicalSize)
        {
            if (physicalSize.w > physicalSize.h)
            {
                return static_cast<float>(physicalSize.w) / logicalRect.w;
            }
            else
            {
                return static_cast<float>(physicalSize.h) / logicalRect.h;
            }
        }
 
        static float CalcZoom(const libCZI::IntSize& logicalSize, const libCZI::IntSize& physicalSize)
        {
            if (physicalSize.w > physicalSize.h)
            {
                return static_cast<float>(physicalSize.w) / logicalSize.w;
            }
            else
            {
                return static_cast<float>(physicalSize.h) / logicalSize.h;
            }
        }
 
        static const char* PixelTypeToInformalString(libCZI::PixelType pixeltype);
 
        static std::uint8_t GetBytesPerPixel(libCZI::PixelType pixelType);
 
        static const char* CompressionModeToInformalString(libCZI::CompressionMode compressionMode);
 
        static std::string DimCoordinateToString(const libCZI::IDimCoordinate* coord);
 
        static bool StringToDimCoordinate(const char* sz, libCZI::CDimCoordinate* coord);
 
        static std::string DimBoundsToString(const libCZI::IDimBounds* bounds);
 
        static std::shared_ptr<libCZI::IIndexSet> IndexSetFromString(const std::wstring& s);
 
        static libCZI::PixelType TryDeterminePixelTypeForChannel(libCZI::ISubBlockRepository* repository, int channelIdx);
 
        static int Compare(const IDimCoordinate* a, const IDimCoordinate* b);
 
        static bool HasSameDimensions(const IDimCoordinate* a, const IDimCoordinate* b);
 
        static std::shared_ptr<ICziMetadataBuilder> CreateSubBlockMetadata(const std::function<bool(int, std::tuple<std::string, std::string>&)>& tagsEnum = nullptr);
 
        static bool EnumAllCoordinates(const libCZI::CDimBounds& bounds, const std::function<bool(std::uint64_t, const libCZI::CDimCoordinate& coord)>& func);
 
        static void FillBitmap(libCZI::IBitmapData* bm, const libCZI::RgbFloatColor& floatColor);
 
        static libCZI::CompressionMode CompressionModeFromRawCompressionIdentifier(std::int32_t m);
 
        static std::int32_t CompressionModeToCompressionIdentifier(libCZI::CompressionMode mode);
 
        static bool IsValidMindex(int mIndex)
        {
            return mIndex != (std::numeric_limits<int>::max)() && mIndex != (std::numeric_limits<int>::min)();
        }
 
        static const char* const KEY_COMPRESS_EXPLICIT_LEVEL     /*= "ExplicitLevel"*/;
 
        static const char* const KEY_COMPRESS_PRE_PROCESS        /*= "PreProcess"*/;
 
        static const char* const VALUE_COMPRESS_HILO_BYTE_UNPACK /*= "HiLoByteUnpack"*/;
 
        using CompressionOption = std::pair<libCZI::CompressionMode, std::shared_ptr<libCZI::ICompressParameters>>;
 
        static CompressionOption ParseCompressionOptions(const std::string& options);
    };
}