draw: allow drawing in any colorspace, regardless of the image type

Author: Adrià Arrufat

examples/src/face_alignment.zig

@@ -7,6 +7,7 @@ const Image = zignal.Image;
 const SimilarityTransform = zignal.SimilarityTransform(f32);
 const Rectangle = zignal.Rectangle(f32);
 const Rgba = zignal.Rgba;
+const Hsv = zignal.Hsv;
 const drawRectangle = zignal.drawRectangle;
 
 pub const std_options: std.Options = .{
@@ -36,7 +37,7 @@ pub fn extractAlignedFace(
     blurring: i32,
     out: *Image(T),
 ) !void {
-    // This are the normalized coordinates of the aligned landmarks
+    // These are the normalized coordinates of the aligned landmarks
     // taken from dlib.
     var from_points: [5]Point2d = .{
         .{ .x = 0.8595674595992, .y = 0.2134981538014 },
@@ -46,6 +47,7 @@ pub fn extractAlignedFace(
         .{ .x = 0.4901123135679, .y = 0.6277975316475 },
     };
 
+    // These are the detected points from MediaPipe.
     const to_points: [5]Point2d = .{
         landmarks[alignment[0]].scale(image.cols, image.rows),
         landmarks[alignment[1]].scale(image.cols, image.rows),
@@ -61,30 +63,43 @@ pub fn extractAlignedFace(
         p.x = (padding + p.x) / (2 * padding + 1) * side;
         p.y = (padding + p.y) / (2 * padding + 1) * side;
     }
+
+    // Find the transforms that maps the points between the canonical landmarks
+    // and the detected landmarks.
     const transform = SimilarityTransform.find(&from_points, &to_points);
     var p = transform.project(.{ .x = 1, .y = 0 });
     p.x -= transform.bias.at(0, 0);
     p.y -= transform.bias.at(1, 0);
     const angle = std.math.atan2(p.y, p.x);
     const scale = p.norm();
     const center = transform.project(.{ .x = side / 2, .y = side / 2 });
+
+    // Align the face: rotate the image so that the face is aligned.
     var rotated: Image(Rgba) = undefined;
     try image.rotateFrom(allocator, center, angle, &rotated);
     defer rotated.deinit(allocator);
 
+    // Get the rectangle around the face.
     const rect = Rectangle.initCenter(center.x, center.y, side * scale, side * scale);
-    drawRectangle(Rgba, image, rect, 1, .{ .r = 0, .g = 0, .b = 0, .a = 255 });
+    // Draw a rectangle around the detected face.  Note that the color can be any Zignal
+    // supported color, and the appropriate conversion will be performed.  In this case,
+    // the image is in Rgba format, and the color is in Hsv.  Zignal will handle that.
+    drawRectangle(Rgba, image, rect, 1, Hsv{ .h = 0, .s = 100, .v = 100 });
+
+    // Crop out the detected face.
     var chip: Image(Rgba) = undefined;
     try rotated.crop(allocator, rect, &chip);
     defer chip.deinit(allocator);
 
+    // Resize it to the desired size.
     var resized = try Image(Rgba).initAlloc(allocator, out.rows, out.cols);
     defer resized.deinit(allocator);
     chip.resize(&resized);
     for (out.data, resized.data) |*c, b| {
         c.* = b;
     }
 
+    // Perform blurring or sharpening to the aligned face.
     if (blurring > 0) {
         try out.boxBlur(allocator, out, @intCast(blurring));
     } else if (blurring < 0) {

src/color.zig

@@ -15,7 +15,7 @@ pub const Color = union(enum) {
     Lab: Lab,
 
     /// Returns true if and only if T can be treated as a color.
-    fn isColor(comptime T: type) bool {
+    pub fn isColor(comptime T: type) bool {
         return switch (T) {
             u8, Rgb, Rgba, Hsv, Lab => true,
             else => false,

src/draw.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const assert = std.debug.assert;
 const as = @import("meta.zig").as;
 const Color = @import("color.zig").Color;
 const Rgba = @import("color.zig").Rgba;
@@ -9,7 +10,8 @@ const Rectangle = @import("geometry.zig").Rectangle(f32);
 /// Draws a colored straight of a custom width between p1 and p2 on image.  It uses Xialin
 /// Wu's line algorithm to perform antialiasing along the diagonal.  Moreover, if color is of
 /// Rgba type, it alpha-blends it on top of the image.
-pub fn drawLine(comptime T: type, image: Image(T), p1: Point2d, p2: Point2d, width: usize, color: T) void {
+pub fn drawLine(comptime T: type, image: Image(T), p1: Point2d, p2: Point2d, width: usize, color: anytype) void {
+    comptime assert(Color.isColor(@TypeOf(color)));
     if (width == 0) return;
     // To avoid casting all the time, perform all operations using the underlying type of p1 and p2.
     const Float = @TypeOf(p1.x);
@@ -197,7 +199,8 @@ pub fn drawLineFast(comptime T: type, image: Image(T), p1: Point2d, p2: Point2d,
     }
 }
 
-pub fn drawRectangle(comptime T: type, image: Image(T), rect: Rectangle, width: usize, color: T) void {
+pub fn drawRectangle(comptime T: type, image: Image(T), rect: Rectangle, width: usize, color: anytype) void {
+    comptime assert(Color.isColor(@TypeOf(color)));
     const points: []const Point2d = &.{
         .{ .x = rect.l, .y = rect.t },
         .{ .x = rect.r, .y = rect.t },
@@ -221,7 +224,8 @@ pub fn drawCross(comptime T: type, image: Image(T), center: Point2d, size: usize
 }
 
 /// Draws the given polygon defined as an array of points.
-pub fn drawPolygon(comptime T: type, image: Image(T), polygon: []const Point2d, width: usize, color: T) void {
+pub fn drawPolygon(comptime T: type, image: Image(T), polygon: []const Point2d, width: usize, color: anytype) void {
+    comptime assert(Color.isColor(@TypeOf(color)));
     if (width == 0) return;
     for (0..polygon.len) |i| {
         drawLine(T, image, polygon[i], polygon[@mod(i + 1, polygon.len)], width, color);