morandi 0.12.1 → 0.99.4

data/ext/morandi_native/rotate.h

@@ -0,0 +1,79 @@
+typedef enum {
+    ANGLE_0 = 0,
+    ANGLE_90 = 90,
+    ANGLE_180 = 180,
+    ANGLE_270 = 270
+} rotate_angle_t;
+
+static GdkPixbuf *
+pixbuf_rotate(GdkPixbuf *src, rotate_angle_t angle) {
+    GdkPixbuf *dest;
+    int has_alpha;
+    int s_width, s_height, s_rowstride;
+    int d_width, d_height, d_rowstride;
+    guchar *s_pix;
+    guchar *d_pix;
+    guchar *sp;
+    guchar *dp;
+    int i, j, pix_width;
+
+    if (!src) return NULL;
+
+    if (angle == ANGLE_0)
+        return gdk_pixbuf_copy(src);
+
+    s_width = gdk_pixbuf_get_width(src);
+    s_height = gdk_pixbuf_get_height(src);
+    has_alpha = gdk_pixbuf_get_has_alpha(src);
+    s_rowstride = gdk_pixbuf_get_rowstride(src);
+    s_pix = gdk_pixbuf_get_pixels(src);
+
+    switch (angle) {
+        case ANGLE_90:
+        case ANGLE_270:
+            d_width = s_height;
+            d_height = s_width;
+            break;
+        default:
+        case ANGLE_0:/* Avoid compiler warnings... */
+        case ANGLE_180:
+            d_width = s_width;
+            d_height = s_height;
+            break;
+    }
+
+    dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, has_alpha, 8, d_width, d_height);
+    d_rowstride = gdk_pixbuf_get_rowstride(dest);
+    d_pix = gdk_pixbuf_get_pixels(dest);
+
+    pix_width = (has_alpha ? 4 : 3);
+
+    for (i = 0; i < s_height; i++) {
+        sp = s_pix + (i * s_rowstride);
+        for (j = 0; j < s_width; j++) {
+            switch (angle) {
+                case ANGLE_180:
+                    dp = d_pix + ((d_height - i - 1) * d_rowstride) + ((d_width - j - 1) * pix_width);
+                    break;
+                case ANGLE_90:
+                    dp = d_pix + (j * d_rowstride) + ((d_width - i - 1) * pix_width);
+                    break;
+                case ANGLE_270:
+                    dp = d_pix + ((d_height - j - 1) * d_rowstride) + (i * pix_width);
+                    break;
+                default:
+                case ANGLE_0:/* Avoid compiler warnings... */
+                    dp = d_pix + (i * d_rowstride) + (j * pix_width);
+                    break;
+            }
+
+            *(dp++) = *(sp++);    /* red */
+            *(dp++) = *(sp++);    /* green */
+            *(dp++) = *(sp++);    /* blue */
+            if (has_alpha) *(dp) = *(sp++);    /* alpha */
+        }
+    }
+
+    return dest;
+}
+

data/ext/morandi_native/tint.h

@@ -0,0 +1,72 @@
+#define RLUM    (0.3086)
+#define GLUM    (0.6094)
+#define BLUM    (0.0820)
+
+// Graphica Obscure
+#define GO_RGB_TO_GREY(r, g, b) ((int)((RLUM * (double)r) + (GLUM * (double)g) + (BLUM * (double)b)))
+
+static inline unsigned char pu_clamp(int x) {
+    return (x > 255) ? 255 : (x < 0 ? 0 : x);
+}
+
+static GdkPixbuf *pixbuf_tint(GdkPixbuf *src, GdkPixbuf *dest, int r, int g, int b, int alpha) {
+    int s_has_alpha, d_has_alpha;
+    int s_width, s_height, s_rowstride;
+    int d_width, d_height, d_rowstride;
+    guchar *s_pix, *sp;
+    guchar *d_pix, *dp;
+    int i, j, pix_width, grey;
+
+    g_return_val_if_fail(src != NULL, NULL);
+    g_return_val_if_fail(dest != NULL, NULL);
+
+    s_width = gdk_pixbuf_get_width(src);
+    s_height = gdk_pixbuf_get_height(src);
+    s_has_alpha = gdk_pixbuf_get_has_alpha(src);
+    s_rowstride = gdk_pixbuf_get_rowstride(src);
+    s_pix = gdk_pixbuf_get_pixels(src);
+
+    d_width = gdk_pixbuf_get_width(dest);
+    d_height = gdk_pixbuf_get_height(dest);
+    d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
+    d_rowstride = gdk_pixbuf_get_rowstride(dest);
+    d_pix = gdk_pixbuf_get_pixels(dest);
+
+    g_return_val_if_fail(d_width == s_width, NULL);
+    g_return_val_if_fail(d_height == s_height, NULL);
+    g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
+
+    pix_width = (s_has_alpha ? 4 : 3);
+
+    for (i = 0; i < s_height; i++) {
+        sp = s_pix;
+        dp = d_pix;
+
+        for (j = 0; j < s_width; j++) {
+            grey = GO_RGB_TO_GREY(sp[0], sp[1], sp[2]);
+
+            dp[0] = pu_clamp(pu_clamp(((int) grey + r) * alpha / 255) +
+                             pu_clamp((int) sp[0] * (255 - alpha) / 255));    /* red */
+
+            //fprintf(stderr, "alpha=%i, r=%i, grey=%i -> %i + %i = %i\n", alpha, r, grey, pu_clamp(((int)grey + r) * alpha / 255), pu_clamp((int)sp[0] * (255 - alpha) / 255), dp[0]);	/* red */
+
+            dp[1] = pu_clamp(
+                    pu_clamp((grey + g) * alpha / 255) + pu_clamp((int) sp[1] * (255 - alpha) / 255));    /* green */
+            dp[2] = pu_clamp(
+                    pu_clamp((grey + b) * alpha / 255) + pu_clamp((int) sp[2] * (255 - alpha) / 255));    /* blue */
+
+            if (s_has_alpha) {
+                dp[3] = sp[3];    /* alpha */
+            }
+
+            dp += pix_width;
+            sp += pix_width;
+        }
+
+        d_pix += d_rowstride;
+        s_pix += s_rowstride;
+    }
+
+    return dest;
+}
+

data/lib/morandi/cairo_ext.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'cairo'
+require 'gdk_pixbuf_cairo'
+require 'pango'
+
+module Morandi
+  # Rounded rectangle function for photo borders
+  module CairoExt
+    module_function
+
+    def rounded_rectangle(cr, x1, y1, x2, y2, x_radius = 4, y_radius = nil)
+      width = x2 - x1
+      height = y2 - y1
+      y_radius ||= x_radius
+
+      x_radius = [x_radius, width / 2].min
+      y_radius = [y_radius, height / 2].min
+
+      xr1 = x_radius
+      xr2 = x_radius / 2.0
+      yr1 = y_radius
+      yr2 = y_radius / 2.0
+
+      cr.new_path
+      cr.move_to(x1 + xr1, y1)
+      cr.line_to(x2 - xr1, y1)
+      cr.curve_to(x2 - xr2, y1, x2, y1 + yr2, x2, y1 + yr1)
+      cr.line_to(x2, y2 - yr1)
+      cr.curve_to(x2, y2 - yr2, x2 - xr2, y2, x2 - xr1, y2)
+      cr.line_to(x1 + xr1, y2)
+      cr.curve_to(x1 + xr2, y2, x1, y2 - yr2, x1, y2 - yr1)
+      cr.line_to(x1, y1 + yr1)
+      cr.curve_to(x1, y1 + yr2, x1 + xr2, y1, x1 + xr1, y1)
+      cr.close_path
+    end
+  end
+end
+
+# Monkey patch Cairo::Context
+module Cairo
+  # Add Cairo::Context#set_source_pixbuf without gtk2 depdendency
+  class Context
+    def set_source_pixbuf(pixbuf, x = 0, y = 0)
+      set_source(pixbuf.to_cairo_image_surface, x, y)
+    end
+  end
+
+  # Add ImageSurface.to_gdk_pixbuf
+  # for converting back to pixbuf without exporting as PNG
+  class ImageSurface
+    def to_gdk_pixbuf
+      GdkPixbufCairo.surface_to_pixbuf(self)
+    end
+  end
+end

data/lib/morandi/crop_utils.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'gdk_pixbuf2'
+
+module Morandi
+  # Utility functions relating to cropping
+  module CropUtils
+    module_function
+
+    def autocrop_coords(pixbuf_width, pixbuf_height, target_width, target_height)
+      return nil unless target_width
+
+      aspect = target_width.to_f / target_height
+      pixbuf_aspect = pixbuf_width.to_f / pixbuf_height
+
+      # TODO: this looks wrong - typically relative aspect ratios matter more
+      # than whether this is portrait or landscape
+      if pixbuf_height > pixbuf_width
+        # Portrait image
+        # Check whether the aspect ratio is greater or smaller
+        # ie. where constraints will hit
+        aspect = target_height.to_f / target_width
+      end
+
+      # Landscape
+      if aspect > pixbuf_aspect
+        # Width constraint - aspect-rect wider
+        crop_width  = pixbuf_width
+        crop_height = (crop_width / aspect).to_i
+      else
+        # Height constraint - aspect-rect wider
+        crop_height = pixbuf_height
+        crop_width  = (crop_height * aspect).to_i
+      end
+
+      [
+        ((pixbuf_width - crop_width) >> 1),
+        ((pixbuf_height - crop_height) >> 1),
+        crop_width,
+        crop_height
+      ].map(&:to_i)
+    end
+
+    def apply_crop(pixbuf, x_coord, y_coord, width, height, fill_col = 0xffffffff)
+      if x_coord.negative? ||
+         y_coord.negative? ||
+         ((x_coord + width) > pixbuf.width) ||
+         ((y_coord + height) > pixbuf.height)
+
+        base_pixbuf = GdkPixbuf::Pixbuf.new(
+          colorspace: GdkPixbuf::Colorspace::RGB,
+          has_alpha: false,
+          bits_per_sample: 8,
+          width: width,
+          height: height
+        )
+        base_pixbuf.fill!(fill_col)
+
+        offset_x = [x_coord, 0].max
+        offset_y = [y_coord, 0].max
+        copy_w = [width, pixbuf.width - offset_x].min
+        copy_h = [height, pixbuf.height - offset_y].min
+
+        paste_x = [x_coord, 0].min * -1
+        paste_y = [y_coord, 0].min * -1
+
+        copy_w = base_pixbuf.width - paste_x if copy_w + paste_x > base_pixbuf.width
+        copy_h = base_pixbuf.height - paste_y if copy_h + paste_y > base_pixbuf.height
+
+        base_pixbuf.composite!(
+          pixbuf,
+          dest_x: paste_x,
+          dest_y: paste_y,
+          dest_width: copy_w,
+          dest_height: copy_h,
+          offset_x: paste_x - offset_x,
+          offset_y: paste_y - offset_y,
+          scale_x: 1,
+          scale_y: 1,
+          interpolation_type: :hyper,
+          overall_alpha: 255
+        )
+        pixbuf = base_pixbuf
+      else
+        x_coord = x_coord.clamp(0, pixbuf.width)
+        y_coord = y_coord.clamp(0, pixbuf.height)
+        width = width.clamp(1, pixbuf.width - x_coord)
+        height = height.clamp(1, pixbuf.height - y_coord)
+
+        pixbuf = pixbuf.subpixbuf(x_coord, y_coord, width, height)
+      end
+      pixbuf
+    end
+  end
+end

data/lib/morandi/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Morandi
+  class Error < StandardError
+  end
+
+  class CorruptImageError < Error
+  end
+
+  class UnknownTypeError < Error
+  end
+end

data/lib/morandi/image_operation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Morandi
+  # Base Image Op class
+  # @!visibility private
+  class ImageOperation
+    class << self
+      def new_from_hash(hash)
+        op = allocate
+        hash.each_pair do |key, val|
+          op.respond_to?(key.intern) && op.instance_variable_set("@#{key}", val)
+        end
+        op
+      end
+    end
+
+    private
+
+    def create_pixbuf_from_image_surface(type, width, height)
+      surface = Cairo::ImageSurface.new(type, width, height)
+      cr = Cairo::Context.new(surface)
+
+      yield(cr)
+
+      final_pb = surface.to_gdk_pixbuf
+      cr.destroy
+      surface.destroy
+      final_pb
+    end
+  end
+end