- update docs

- update stub files
- add test for mask mixin

Author: EmilDohne

.github/workflows/build-wheels.yml

@@ -101,6 +101,7 @@ jobs:
             python -u {project}/PhotoshopExamples/ModifyLayerStructure/modify_layer_structure.py &&
             python -u {project}/PhotoshopExamples/ReplaceImageData/replace_image_data.py &&
             python -u {project}/PhotoshopExamples/RescaleCanvas/rescale_canvas.py &&
+            python -u {project}/PhotoshopExamples/SmartObjects/smart_objects.py &&
             nosetests {project}/python/psapi-test --verbose
 
     - name: Verify clean directory

CMakeLists.txt

@@ -116,7 +116,6 @@ if(PSAPI_BUILD_EXAMPLES)
     add_subdirectory (PhotoshopExamples/ProgressCallbacks)
     add_subdirectory (PhotoshopExamples/ReplaceImageData)
     add_subdirectory (PhotoshopExamples/SmartObjects)
-    add_subdirectory (PhotoshopExamples/Tmp)
 endif()
 if(PSAPI_BUILD_DOCS)
     if(NOT PSAPI_BUILD_PYTHON)

PhotoshopAPI/src/Core/Geometry/BezierSurface.h

@@ -157,7 +157,18 @@ namespace Geometry
             return { u, v };
         }
 
-        // Evaluate any patch at (u, v) based on subdivisions across x and y
+        /// Evaluate any patch at (u, v) based on the subdivisions across x and y.
+        /// This will return the screen-space coordinate from the given mesh. 
+        /// 
+        /// If the bezier surface is made up of non-uniform slices (i.e. the bezier isn't
+        /// split at .33, .66 etc for a 4x4 bezier) one should use `bias_uv()` to account 
+        /// for this. In fact because it evaluates to a no-op if that isn't the case the UV
+        /// should always first be biased before calling this function.
+        /// 
+        /// \param u The u value to sample the bezier at. This should be from 0-1
+        /// \param v The v value to sample the bezier at. This should be from 0-1
+        /// 
+        /// \returns The screen-space coordinate for the mesh at the given uv coordinate.
         Point2D<double> evaluate(double u, double v) const
         {
             double patch_size_u = 1.0 / m_NumPatchesX;

PhotoshopAPI/src/Core/Geometry/Mesh.h

@@ -7,13 +7,13 @@
 #include <vector>
 #include <memory>
 #include <cmath>
+#include <span>
 
 #include "BoundingBox.h"
 #include "MeshOperations.h"
 
 #include <Eigen/Dense>
-
-#include <span>
+#include <fmt/format.h>
 
 
 PSAPI_NAMESPACE_BEGIN
@@ -387,7 +387,7 @@ namespace Geometry
             for (size_t face_index : face_indices)
             {
                 Face<T, 4> face = m_Faces[face_index];
-                
+
                 // Check if the position is within this face, we first check based on bbox as that is as faster operation
                 // for rejecting false positives
                 const auto& face_bbox = face.bbox();
@@ -417,9 +417,9 @@ namespace Geometry
             return Point2D<double>(-1.0, -1.0); // No valid UV coordinate found
         }
 
-        BoundingBox<T> bbox() const noexcept 
-        { 
-            return m_BoundingBox; 
+        BoundingBox<T> bbox() const noexcept
+        {
+            return m_BoundingBox;
         }
 
     private:
@@ -432,14 +432,27 @@ namespace Geometry
         /// Initialize the mesh for a given number of vertices
         void initialize_mesh(
             const std::vector<Vertex<T>>& vertices,
-            size_t x_divisions, 
+            size_t x_divisions,
             size_t y_divisions
         )
         {
             PSAPI_PROFILE_FUNCTION();
             m_Vertices = vertices;
             m_BoundingBox = BoundingBox<T>::compute(m_Vertices);
 
+            // Our octree would fail due to floating point precision issues as the mesh approaches closer to .01 in size
+            // hence the failure condition. 
+            if (m_BoundingBox.size().x < 1e-2 || m_BoundingBox.size().y < 1e-2)
+            {
+                throw std::runtime_error(
+                    fmt::format(
+                        "Tried to construct the mesh with vertices that are less than 1e-2 (0.01) across one of the axis. " \
+                        "Trying to construct this mesh would cause the Octree calculation to fail. If called from the context " \
+                        "of a layer this is likely a mistake in the transformation. The bounding box of the vertices is [{}, {}]",
+                        m_BoundingBox.size().x, m_BoundingBox.size().y
+                    ));
+            }
+
             m_Faces.reserve((x_divisions - 1) * (y_divisions - 1));
 
             // Generate the faces and populate the vertex indices.

PhotoshopAPI/src/Core/Geometry/MeshOperations.h

@@ -319,7 +319,7 @@ namespace Geometry
         /// Compute a 3x3 homography transformation matrix based on the given source and destination quad
         ///
         /// \param source_points      The points from which we want to compute the homography
-        /// \param destination points The points to which we want to transform.
+        /// \param destination_points The points to which we want to transform.
         template<typename T>
         Eigen::Matrix3d create_homography_matrix(const std::array<Point2D<T>, 4>& source_points, const std::array<Point2D<T>, 4>& destination_points)
         {

PhotoshopAPI/src/Core/Render/Composite.h

@@ -155,7 +155,7 @@ namespace Composite
 			///		The canvas onto which to draw the layer with the given kernel.
 			/// \param layer
 			///		The layer to compose on top of the canvas
-			/// \param kernel
+			/// \param kernel_func
 			///		The kernel to apply to the color channels of the image (alpha is handled separately)
 			/// 
 			/// \throws std::invalid_argument If the canvas has a mask channel.

PhotoshopAPI/src/Core/Struct/DescriptorStructure.h

@@ -328,7 +328,7 @@ namespace Descriptors
 		/// \param document The File object to write to.
 		/// \param key		The key to write to disk, will be ignored if writeKey is set to false
 		/// \param value	The value you intend to write to disk, will write the child items as well if present
-		/// \param readKey	Whether to write the key to disk or discard it (such as with lists), this does not propagate to any child 
+		/// \param writeKey	Whether to write the key to disk or discard it (such as with lists), this does not propagate to any child 
 		///					nodes and only applies to the given node
 		inline void WriteDescriptor(File& document, const std::string& key, const std::unique_ptr<DescriptorBase>& value, bool writeKey = true)
 		{

PhotoshopAPI/src/Core/Struct/ResourceBlock.h

@@ -66,7 +66,7 @@ struct ResolutionInfoBlock : public ResourceBlock
 /// Edit -> Assign Profile which just visually adjusts the colours but does not convert the colours
 struct ICCProfileBlock : public ResourceBlock
 {
-	/// Stores the raw bytes of an ICC profile such as the ones found on C:\Windows\System32\spool\drivers\color for Windows.
+	/// Stores the raw bytes of an ICC profile such as the ones found on C:/Windows/System32/spool/drivers/color for Windows.
 	/// This does not include the padding bytes which are explicitly written on write
 	std::vector<uint8_t> m_RawICCProfile;
 

PhotoshopAPI/src/Core/Warp/SmartObjectWarp.h

@@ -128,42 +128,62 @@ namespace SmartObject
 						// We then bilinearly sample the source image to avoid artifacts from nearest 
 						// neighbour sampling.
 
-						bool sampled = false;
-						float accumulated_color = 0;
-
-						for (size_t sy = 0; sy < supersample_resolution; ++sy)
+						// Simplify the code at compile time already if not supersampling
+						if constexpr (supersample_resolution == 1)
 						{
-							double subpixel_y = y + static_cast<double>(sy) / supersample_resolution;
+							auto position = Geometry::Point2D<double>(static_cast<double>(x), static_cast<double>(y));
+							auto uv = warp_mesh.uv_coordinate(position);
 
-							for (size_t sx = 0; sx < supersample_resolution; ++sx)
+							// If the uv coordinate is outside of the image we dont bother with it.
+							// We can check against the exact -1.0f here as that is what we return
+							if (uv != failure_condition)
 							{
-								double subpixel_x = x + static_cast<double>(sx) / supersample_resolution;
+								size_t idx = y * buffer.width + x;
+								buffer.buffer[idx] = image.template sample_bilinear_uv<double>(uv);
+							}
+						}
+						else
+						{
+							bool sampled = false;
+							float accumulated_color = 0;
 
-								auto position = Geometry::Point2D<double>(subpixel_x, subpixel_y);
-								auto uv = warp_mesh.uv_coordinate(position);
+							// Perform the supersampling steps
+							for (size_t sy = 0; sy < supersample_resolution; ++sy)
+							{
+								double subpixel_y = y + static_cast<double>(sy) / supersample_resolution;
 
-								// If the uv coordinate is outside of the image we dont bother with it.
-								// We can check against the exact -1.0f here as that is what we return
-								if (uv != failure_condition)
+								for (size_t sx = 0; sx < supersample_resolution; ++sx)
 								{
-									sampled = true;
-									accumulated_color += image.template sample_bilinear_uv<double>(uv);
+									double subpixel_x = x + static_cast<double>(sx) / supersample_resolution;
+
+									auto position = Geometry::Point2D<double>(subpixel_x, subpixel_y);
+									auto uv = warp_mesh.uv_coordinate(position);
+
+									// If the uv coordinate is outside of the image we dont bother with it.
+									// We can check against the exact -1.0f here as that is what we return
+									if (uv != failure_condition)
+									{
+										sampled = true;
+										accumulated_color += image.template sample_bilinear_uv<double>(uv);
+									}
 								}
 							}
-						}
 
-						if (sampled)
-						{
-							T final_value = static_cast<T>(std::clamp<double>(accumulated_color / total_supersamples, 0.0, static_cast<double>(max_t)));
+							if (sampled)
+							{
+								T final_value = static_cast<T>(std::clamp<double>(accumulated_color / total_supersamples, 0.0, static_cast<double>(max_t)));
 
-							size_t idx = y * buffer.width + x;
-							buffer.buffer[idx] = final_value;
+								size_t idx = y * buffer.width + x;
+								buffer.buffer[idx] = final_value;
+							}
 						}
 					}
 				});
 		}
 
 
+
+
 		/// Apply the warp by warping the `image` into the `buffer` using the locally stored warp description. 
 		/// The `buffer` passed should match the general resolution of the warp points. So if e.g. the warp points 
 		/// are from { 0 - 4000, 0 - 2000 } the `buffer` parameter should cover these.

PhotoshopAPI/src/LayeredFile/LayerTypes/GroupLayer.h

@@ -40,7 +40,7 @@ struct GroupLayer final: public Layer<T>
 	/// @} 
 
 	/// \brief Constructs a GroupLayer with the given layer parameters and collapse state.
-	/// \param layerParameters The parameters for the group layer.
+	/// \param parameters The parameters for the group layer.
 	/// \param isCollapsed Specifies whether the group layer is initially collapsed.
 	GroupLayer(Layer<T>::Params& parameters, bool isCollapsed = false)
 	{
@@ -139,8 +139,6 @@ struct GroupLayer final: public Layer<T>
 	/// This is part of the internal API and as a user you will likely never have to use 
 	/// this function
 	/// 
-	/// \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() override
 	{

PhotoshopAPI/src/LayeredFile/LayerTypes/ImageDataMixins.h

@@ -156,8 +156,6 @@ struct ImageDataMixin
 	/// 
 	/// Each Layer type that implement ImageDataMixin must provide an implementation for evaluate_image_data().
 	/// 
-	/// \param document The document the layer is a part of, may be unused during evaluation.
-	/// 
 	/// \returns The evaluated image data for each channel 
 	virtual data_type evaluate_image_data() = 0;
 
@@ -167,7 +165,7 @@ struct ImageDataMixin
 	/// so a layer must take care to access these channels together. Similarly, a smart object must apply the warp first
 	/// before getting the image data. 
 	/// 
-	/// \param document The document the layer is a part of, may be unused during evaluation.
+	/// \param _id The channel to evaluate
 	/// 
 	/// \returns The evaluated image data for each channel 
 	virtual std::vector<T> evaluate_channel(std::variant<int, Enum::ChannelID, Enum::ChannelIDInfo> _id) = 0;