From 277546a574b1214c754a6b9c144cf9e49272593c Mon Sep 17 00:00:00 2001 From: Georg Hagen Date: Sat, 6 Dec 2025 23:56:55 +0100 Subject: [PATCH] Add convenience functions --- openVulkanoCpp/Image/TiffWrapper.hpp | 141 ++++++++++++++++++++++----- 1 file changed, 116 insertions(+), 25 deletions(-) diff --git a/openVulkanoCpp/Image/TiffWrapper.hpp b/openVulkanoCpp/Image/TiffWrapper.hpp index e45a69d..e8c2710 100644 --- a/openVulkanoCpp/Image/TiffWrapper.hpp +++ b/openVulkanoCpp/Image/TiffWrapper.hpp @@ -15,6 +15,50 @@ namespace OpenVulkano { + class TiffCompression + { + public: + enum Compression: uint8_t { UNKNOWN = 0, NONE, LZW, JPEG, DEFLATE, ZSTD }; + + TiffCompression() : compression(NONE) {} + TiffCompression(Compression compression) : compression(compression) {} + TiffCompression(const TiffCompression&) = default; + TiffCompression(TiffCompression&&) = default; + + TiffCompression& operator =(const Compression comp) { compression = comp; return *this; } + TiffCompression& operator =(const TiffCompression&) = default; + TiffCompression& operator =(TiffCompression&&) = default; + + [[nodiscard]] uint16_t GetTiffType() const + { + switch (compression) + { + case LZW: return COMPRESSION_LZW; + case JPEG: return COMPRESSION_JPEG; + case DEFLATE: return COMPRESSION_DEFLATE; + case ZSTD: return COMPRESSION_ZSTD; + default: break; + } + return COMPRESSION_NONE; + } + + static TiffCompression FromTiffType(const uint16_t comp) + { + switch (comp) + { + case COMPRESSION_NONE: return NONE; + case COMPRESSION_LZW: return LZW; + case COMPRESSION_JPEG: return JPEG; + case COMPRESSION_DEFLATE: return DEFLATE; + case COMPRESSION_ZSTD: return ZSTD; + } + return UNKNOWN; + } + + private: + Compression compression; + }; + class TiffWrapper final { TIFF* tiff = nullptr; @@ -47,26 +91,29 @@ namespace OpenVulkano bool Flush() { return TIFFFlush(tiff); } bool FlushData() { return TIFFFlushData(tiff); } + //region TIFF fields template void SetField(uint32_t tag, Args&&... args) { TIFFSetField(tiff, tag, std::forward(args)...); } void UnsetField(uint32_t tag) { TIFFUnsetField(tiff, tag); } - [[nodiscard]] int GetField(const uint32_t tag) const { return TIFFGetField(tiff, tag); } + template + bool GetField(const uint32_t tag, Args&&... args) const { return TIFFGetField(tiff, tag, std::forward(args)...); } int VGetField(const uint32_t tag, va_list ap) { return TIFFVGetField(tiff, tag, ap); } [[nodiscard]] int GetFieldDefaulted(const uint32_t tag) { return TIFFGetFieldDefaulted(tiff, tag); } int VGetFieldDefaulted(const uint32_t tag, va_list ap) { return TIFFVGetFieldDefaulted(tiff, tag, ap); } + //endregion - int GetTagListCount() { return TIFFGetTagListCount(tiff); } - uint32_t GetTagListEntry(const int tagIndex) { return TIFFGetTagListEntry(tiff, tagIndex); } + [[nodiscard]] int GetTagListCount() const { return TIFFGetTagListCount(tiff); } + [[nodiscard]] uint32_t GetTagListEntry(const int tagIndex) const { return TIFFGetTagListEntry(tiff, tagIndex); } - const TIFFField* FindField(const uint32_t tag, const TIFFDataType dt) { return TIFFFindField(tiff, tag, dt); } - const TIFFField* FieldWithTag(const uint32_t tag) { return TIFFFieldWithTag(tiff, tag); } - const TIFFField* FieldWithName(const char* tag) { return TIFFFieldWithName(tiff, tag); } + [[nodiscard]] const TIFFField* FindField(const uint32_t tag, const TIFFDataType dt) { return TIFFFindField(tiff, tag, dt); } + [[nodiscard]] const TIFFField* FieldWithTag(const uint32_t tag) { return TIFFFieldWithTag(tiff, tag); } + [[nodiscard]] const TIFFField* FieldWithName(const char* tag) { return TIFFFieldWithName(tiff, tag); } - TIFFTagMethods * AccessTagMethods() { return TIFFAccessTagMethods(tiff); } - void* GetClientInfo(const char* name) { return TIFFGetClientInfo(tiff, name); } + [[nodiscard]] TIFFTagMethods* AccessTagMethods() const { return TIFFAccessTagMethods(tiff); } + [[nodiscard]] void* GetClientInfo(const char* name) const { return TIFFGetClientInfo(tiff, name); } void SetClientInfo(void* data, const char* name) { TIFFSetClientInfo(tiff, data, name); } bool ReadDirectory() { return TIFFReadDirectory(tiff); } @@ -92,7 +139,7 @@ namespace OpenVulkano [[nodiscard]] tmsize_t TileSize() const { return TIFFTileSize(tiff); } [[nodiscard]] uint64_t VTileSize64(const uint32_t numRows) const { return TIFFVTileSize64(tiff, numRows); } [[nodiscard]] tmsize_t VTileSize(const uint32_t numRows) const { return TIFFVTileSize(tiff, numRows); } - [[nodiscard]] uint32_t DefaultStripSize(unsigned int request) { return TIFFDefaultStripSize(tiff, request); } + [[nodiscard]] uint32_t DefaultStripSize(uint32_t request) { return TIFFDefaultStripSize(tiff, request); } [[nodiscard]] Math::Vector2ui DefaultTileSize() const { Math::Vector2ui res; @@ -164,10 +211,10 @@ namespace OpenVulkano void PrintDirectory(FILE* file, long flags) { TIFFPrintDirectory(tiff, file, flags); } - int ReadScanline(void * buf, unsigned int row, unsigned short int sample) { + int ReadScanline(void * buf, uint32_t row, unsigned short int sample) { return TIFFReadScanline(tiff, buf, row, sample); } - int WriteScanline(void * buf, unsigned int row, unsigned short int sample) { + int WriteScanline(void * buf, uint32_t row, unsigned short int sample) { return TIFFWriteScanline(tiff, buf, row, sample); } int ReadRGBAImage(uint32_t rwidth, uint32_t rheight, uint32_t* raster, int stop) { @@ -193,49 +240,93 @@ namespace OpenVulkano return TIFFRGBAImageOK(tiff, p0); } [[nodiscard]] std::string FileName() const { return TIFFFileName(tiff); } - uint32_t ComputeTile(unsigned int x, unsigned int y, unsigned int z, unsigned short int s) { + uint32_t ComputeTile(uint32_t x, uint32_t y, uint32_t z, unsigned short int s) { return TIFFComputeTile(tiff, x, y, z, s); } - int CheckTile(unsigned int x, unsigned int y, unsigned int z, unsigned short int s) { + int CheckTile(uint32_t x, uint32_t y, uint32_t z, unsigned short int s) { return TIFFCheckTile(tiff, x, y, z, s); } [[nodiscard]] uint32_t NumberOfTiles() const { return TIFFNumberOfTiles(tiff); } - tmsize_t ReadTile(void * buf, unsigned int x, unsigned int y, unsigned int z, unsigned short int s) { + tmsize_t ReadTile(void * buf, uint32_t x, uint32_t y, uint32_t z, unsigned short int s) { return TIFFReadTile(tiff, buf, x, y, z, s); } - tmsize_t WriteTile(void * buf, unsigned int x, unsigned int y, unsigned int z, unsigned short int s) { + tmsize_t WriteTile(void* buf, uint32_t x, uint32_t y, uint32_t z = 0, uint16_t s = 0) { return TIFFWriteTile(tiff, buf, x, y, z, s); } - uint32_t ComputeStrip(unsigned int p0, unsigned short int p1) { - return TIFFComputeStrip(tiff, p0, p1); + uint32_t ComputeStrip(uint32_t row, uint16_t sample) { + return TIFFComputeStrip(tiff, row, sample); } [[nodiscard]] uint32_t NumberOfStrips() const { return TIFFNumberOfStrips(tiff); } - tmsize_t ReadEncodedStrip(unsigned int strip, void * buf, tmsize_t size) { + tmsize_t ReadEncodedStrip(uint32_t strip, void* buf, tmsize_t size) { return TIFFReadEncodedStrip(tiff, strip, buf, size); } - tmsize_t ReadRawStrip(unsigned int strip, void * buf, tmsize_t size) { + tmsize_t ReadRawStrip(uint32_t strip, void* buf, tmsize_t size) { return TIFFReadRawStrip(tiff, strip, buf, size); } - tmsize_t ReadEncodedTile(unsigned int tile, void * buf, tmsize_t size) { + tmsize_t ReadEncodedTile(uint32_t tile, void* buf, tmsize_t size) { return TIFFReadEncodedTile(tiff, tile, buf, size); } - tmsize_t ReadRawTile(unsigned int tile, void * buf, tmsize_t size) { + tmsize_t ReadRawTile(uint32_t tile, void* buf, tmsize_t size) { return TIFFReadRawTile(tiff, tile, buf, size); } - tmsize_t WriteEncodedStrip(unsigned int strip, void * data, tmsize_t cc) { + tmsize_t WriteEncodedStrip(uint32_t strip, void* data, tmsize_t cc) { return TIFFWriteEncodedStrip(tiff, strip, data, cc); } - tmsize_t WriteRawStrip(unsigned int strip, void * data, tmsize_t cc) { + tmsize_t WriteRawStrip(uint32_t strip, void* data, tmsize_t cc) { return TIFFWriteRawStrip(tiff, strip, data, cc); } - tmsize_t WriteEncodedTile(unsigned int tile, void * data, tmsize_t cc) { + tmsize_t WriteEncodedTile(uint32_t tile, void* data, tmsize_t cc) { return TIFFWriteEncodedTile(tiff, tile, data, cc); } - tmsize_t WriteRawTile(unsigned int tile, void * data, tmsize_t cc) { + tmsize_t WriteRawTile(uint32_t tile, void* data, tmsize_t cc) { return TIFFWriteRawTile(tiff, tile, data, cc); } void SetWriteOffset(const uint64_t offset) { TIFFSetWriteOffset(tiff, offset); } //endregion + + //region Convenience TIFF field functions + //TODO get defaults + void SetResolution(const Math::Vector2ui& resolution) + { + SetField(TIFFTAG_IMAGEWIDTH, resolution.x); + SetField(TIFFTAG_IMAGELENGTH, resolution.y); + } + void SetTileResolution(const Math::Vector2ui& resolution) + { + SetField(TIFFTAG_TILEWIDTH, resolution.x); + SetField(TIFFTAG_TILELENGTH, resolution.y); + } + [[nodiscard]] Math::Vector2ui GetResolution() const + { + Math::Vector2ui resolution; + GetField(TIFFTAG_IMAGEWIDTH, &resolution.x); + GetField(TIFFTAG_IMAGELENGTH, &resolution.y); + return resolution; + } + [[nodiscard]] Math::Vector2ui GetTileResolution() const + { + Math::Vector2ui resolution; + GetField(TIFFTAG_TILEWIDTH, &resolution.x); + GetField(TIFFTAG_TILELENGTH, &resolution.y); + return resolution; + } + void SetCompression(const TiffCompression compression) + { + SetField(TIFFTAG_COMPRESSION, compression.GetTiffType()); + } + [[nodiscard]] TiffCompression GetCompression() const + { + uint16_t comp; + GetField(TIFFTAG_COMPRESSION, &comp); + return TiffCompression::FromTiffType(comp); + } + void SetResolutionUnit(const Math::Vector2f& scale, uint16_t type = RESUNIT_INCH) + { + SetField(TIFFTAG_RESOLUTIONUNIT, type); + SetField(TIFFTAG_XRESOLUTION, scale.x); + SetField(TIFFTAG_YRESOLUTION, scale.y); + } + //endregion }; }