sync rewrite mixins and add code for bbox retrieval etc.

Author: EmilDohne

.github/workflows/build-wheels.yml

@@ -76,15 +76,6 @@ jobs:
           brew install libtool
           brew install automake
           
-    - name: Setup Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: '3.12'
-
-    - name: Install CMake using pip
-      run: |
-        python -m pip install cmake
-
     - name: Initialize vcpkg
       uses: lukka/run-vcpkg@v11
       with:
@@ -96,6 +87,7 @@ jobs:
         CXX: g++-13
         CIBW_ARCHS: auto64
         MACOSX_DEPLOYMENT_TARGET: 14.0
+        CIBW_BEFORE_BUILD: pip install cmake
         CIBW_MANYLINUX_X86_64_IMAGE: quay.io/pypa/manylinux_2_34_x86_64:latest
         CIBW_BUILD: "${{ matrix.os_dist.dist }}"
         # Test not only by running the test suite but also by executing every example we provide. This is to ensure

PhotoshopAPI/src/Core/Geometry/BoundingBox.h

@@ -26,10 +26,10 @@ namespace Geometry
     struct BoundingBox
     {
         /// The minimum (bottom-left) corner of the bounding box.
-        Point2D<T> minimum;
+        Point2D<T> minimum{};
 
         /// The maximum (top-right) corner of the bounding box.
-        Point2D<T> maximum;
+        Point2D<T> maximum{};
 
         /// Default constructor.
         /// Initializes the bounding box with default `Point2D` values.

PhotoshopAPI/src/Core/Geometry/GeometryInstantiations.cpp

@@ -0,0 +1,14 @@
+#include "Macros.h"
+
+#include "Mesh.h"
+
+PSAPI_NAMESPACE_BEGIN
+
+
+template struct Face<double, 4>;
+template struct OctreeNode<double, 128>;
+template class Octree<double, 128>;
+template struct QuadMesh<double>;
+
+
+PSAPI_NAMESPACE_END

PhotoshopAPI/src/Core/Geometry/Mesh.h

@@ -567,6 +567,14 @@ namespace Geometry
             }
         }
     };
+
+
+    // In most cases we will deal with doubles so we get advantages by explicitly instantiating them
+    extern template struct Face<double, 4>;
+    extern template struct OctreeNode<double, 128>;
+    extern template class Octree<double, 128>;
+    extern template struct QuadMesh<double>;
+
 }
 
 PSAPI_NAMESPACE_END

PhotoshopAPI/src/Core/Geometry/Point.h

@@ -29,8 +29,8 @@ namespace Geometry
     {
         using value_type = T;
 
-        T x{};
-        T y{};
+        T x = static_cast<T>(0);
+        T y = static_cast<T>(0);
 
         Point2D() = default;
         constexpr Point2D(T x_val, T y_val) : x(x_val), y(y_val) {}
@@ -134,8 +134,32 @@ namespace Geometry
             // Use a simple hash combination method
             return std::hash<T>()(x) ^ (std::hash<T>()(y) << 1); // XOR combined with left shift for distribution
         }
-    };
 
+        // Provide a get<I> function for structured bindings
+        template <std::size_t I>
+        constexpr auto& get(Point2D<T>& point) 
+        {
+            if constexpr (I == 0) return point.x;
+            else if constexpr (I == 1) return point.y;
+        }
+
+        // Provide a get<I> function for structured bindings
+        template <std::size_t I>
+        constexpr const auto& get(const Point2D<T>& point) 
+        {
+            if constexpr (I == 0) return point.x;
+            else if constexpr (I == 1) return point.y;
+        }
+
+        // Provide a get<I> function for structured bindings
+        template <std::size_t I>
+        constexpr auto&& get(Point2D<T>&& point) 
+        {
+            if constexpr (I == 0) return std::move(point.x);
+            else if constexpr (I == 1) return std::move(point.y);
+        }
+
+    };
 
     /// Extension of a Point2D to additionally describe the UV coordinate of a given point.
     template <typename T>
@@ -180,4 +204,16 @@ namespace std
             return point.hash();
         }
     };
+}
+
+// Enable structured bindings
+namespace std {
+    template <typename T>
+    struct tuple_size<NAMESPACE_PSAPI::Geometry::Point2D<T>> : std::integral_constant<std::size_t, 2> {};
+
+    template <typename T, std::size_t I>
+    struct tuple_element<I, NAMESPACE_PSAPI::Geometry::Point2D<T>> {
+        static_assert(I < 2, "Index out of bounds for Point2D");
+        using type = T;
+    };
 }

PhotoshopAPI/src/Core/Struct/ImageChannel.h

@@ -41,10 +41,10 @@ struct ImageChannel
 {
 	/// The size of each sub-chunk in the super-chunk. For more information about what a chunk and super-chunk is
 	/// please refer to the c-blosc2 documentation. Defaults to 8MB
-	static const uint64_t m_ChunkSize = 1024 * 1024 * 8;
+	static constexpr uint64_t m_ChunkSize = 1024 * 1024 * 8;
 	/// This does not indicate the compression method of the channel in memory 
 	/// but rather the compression method it writes the PhotoshopFile with
-	Enum::Compression m_Compression = Enum::Compression::Raw;
+	Enum::Compression m_Compression = Enum::Compression::ZipPrediction;
 	/// Information about what channel this actually is
 	Enum::ChannelIDInfo m_ChannelID = { Enum::ChannelID::Red, 1 };
 	/// The size of the original (uncompressed) data in bytes
@@ -57,8 +57,10 @@ struct ImageChannel
 	int32_t getHeight() const { return m_Height; };
 	/// Get the x-coordinate of the uncompressed ImageChannel
 	float getCenterX() const { return m_XCoord; };
+	void setCenterX(float value) { m_XCoord = value; }
 	/// Get the y-coordinate of the uncompressed ImageChannel
 	float getCenterY() const { return m_YCoord; };
+	void setCenterY(float value) { m_YCoord = value; }
 	/// Get the total number of chunks held in the ImageChannel
 	uint64_t getNumChunks() const { return m_NumChunks; };
 
@@ -117,7 +119,7 @@ struct ImageChannel
 	// ---------------------------------------------------------------------------------------------------------------------
 	// ---------------------------------------------------------------------------------------------------------------------
 	template <typename T>
-	void getData(std::span<T> buffer, size_t numThreads = 0)
+	void getData(std::span<T> buffer, size_t numThreads = 0) const
 	{
 		PSAPI_PROFILE_FUNCTION();
 
@@ -203,7 +205,7 @@ struct ImageChannel
 	// ---------------------------------------------------------------------------------------------------------------------
 	// ---------------------------------------------------------------------------------------------------------------------
 	template <typename T>
-	std::vector<T> getData(size_t numThreads = 0)
+	std::vector<T> getData(size_t numThreads = 0) const
 	{
 		std::vector<T> buffer(m_OrigByteSize / sizeof(T));
 		getData(std::span<T>(buffer), numThreads);
@@ -318,7 +320,9 @@ struct ImageChannel
 	~ImageChannel() 
 	{
 		if (!m_wasFreed)
+		{
 			blosc2_schunk_free(m_Data);
+		}
 		m_wasFreed = true;
 	}
 	ImageChannel() = default;

PhotoshopAPI/src/LayeredFile/LayerTypes/AdjustmentLayer.h

@@ -15,4 +15,8 @@ struct AdjustmentLayer : Layer<T>
 
 };
 
+extern template struct AdjustmentLayer<bpp8_t>;
+extern template struct AdjustmentLayer<bpp16_t>;
+extern template struct AdjustmentLayer<bpp32_t>;
+
 PSAPI_NAMESPACE_END

PhotoshopAPI/src/LayeredFile/LayerTypes/ArtboardLayer.h

@@ -15,4 +15,8 @@ struct ArtboardLayer : Layer<T>
 	ArtboardLayer() = default;
 };
 
+extern template struct ArtboardLayer<bpp8_t>;
+extern template struct ArtboardLayer<bpp16_t>;
+extern template struct ArtboardLayer<bpp32_t>;
+
 PSAPI_NAMESPACE_END

PhotoshopAPI/src/LayeredFile/LayerTypes/GroupLayer.h

@@ -32,7 +32,7 @@ struct LayeredFile;
 /// \tparam T The data type for pixel values in layers (e.g., uint8_t, uint16_t, float32_t).
 /// 
 template <typename T>
-struct GroupLayer : public Layer<T>
+struct GroupLayer final: public Layer<T>
 {
 	/// \defgroup layer The groups' child layers
 	/// @{
@@ -151,13 +151,13 @@ struct GroupLayer : public Layer<T>
 	/// \param colorMode The color mode for the conversion.
 	/// \param header The file header for the conversion.
 	/// \return A tuple containing layerRecords and imageData.
-	std::tuple<LayerRecord, ChannelImageData> to_photoshop(const Enum::ColorMode colorMode, const FileHeader& header) override
+	std::tuple<LayerRecord, ChannelImageData> to_photoshop() override
 	{
 		PascalString lrName = Layer<T>::generate_name();
-		ChannelExtents extents = generate_extents(ChannelCoordinates(Layer<T>::m_Width, Layer<T>::m_Height, Layer<T>::m_CenterX, Layer<T>::m_CenterY), header);
+		ChannelExtents extents = generate_extents(ChannelCoordinates(Layer<T>::m_Width, Layer<T>::m_Height, Layer<T>::m_CenterX, Layer<T>::m_CenterY));
 		uint8_t clipping = 0u;	// No clipping mask for now
 		LayerRecords::BitFlags bitFlags = LayerRecords::BitFlags(Layer<T>::m_IsLocked, !Layer<T>::m_IsVisible, false);
-		std::optional<LayerRecords::LayerMaskData> lrMaskData = Layer<T>::generate_mask(header);
+		std::optional<LayerRecords::LayerMaskData> lrMaskData = Layer<T>::generate_mask();
 		LayerRecords::LayerBlendingRanges blendingRanges = Layer<T>::generate_blending_ranges();
 
 
@@ -299,5 +299,9 @@ struct GroupLayer : public Layer<T>
 };
 
 
+extern template struct GroupLayer<bpp8_t>;
+extern template struct GroupLayer<bpp16_t>;
+extern template struct GroupLayer<bpp32_t>;
+
 
 PSAPI_NAMESPACE_END