morandi 0.12.0 → 0.99.03

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/image_operation.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'colorscore'
+
+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
+
+  # Straighten operation
+  # Does a small (ie. not 90,180,270 deg) rotation and zooms to avoid cropping
+  # @!visibility private
+  class Straighten < ImageOperation
+    attr_accessor :angle
+
+    def call(_image, pixbuf)
+      return pixbuf if angle.zero?
+
+      rotation_value_rad = angle * (Math::PI / 180)
+
+      ratio = pixbuf.width.to_f / pixbuf.height
+      rh = pixbuf.height / ((ratio * Math.sin(rotation_value_rad.abs)) + Math.cos(rotation_value_rad.abs))
+      scale = pixbuf.height / rh.to_f.abs
+
+      a_ratio = pixbuf.height.to_f / pixbuf.width
+      a_rh = pixbuf.width / ((a_ratio * Math.sin(rotation_value_rad.abs)) + Math.cos(rotation_value_rad.abs))
+      a_scale = pixbuf.width / a_rh.to_f.abs
+
+      scale = a_scale if a_scale > scale
+
+      create_pixbuf_from_image_surface(:rgb24, pixbuf.width, pixbuf.height) do |cr|
+        cr.translate(pixbuf.width / 2.0, pixbuf.height / 2.0)
+        cr.rotate(rotation_value_rad)
+        cr.scale(scale, scale)
+        cr.translate(pixbuf.width / -2.0, pixbuf.height / - 2.0)
+        cr.set_source_pixbuf(pixbuf)
+
+        cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
+        cr.paint(1.0)
+      end
+    end
+  end
+
+  # Image Border operation
+  # Supports retro (rounded) and square borders
+  # Background colour (ie. border colour) can be white, black, dominant (ie. from image)
+  # @!visibility private
+  class ImageBorder < ImageOperation
+    attr_accessor :style, :colour, :crop, :size, :print_size, :shrink, :border_size
+
+    def call(_image, pixbuf)
+      return pixbuf unless %w[square retro].include? @style
+
+      create_pixbuf_from_image_surface(:rgb24, pixbuf.width, pixbuf.height) do |cr|
+        if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
+          img_width = size[0]
+          img_height = size[1]
+        else
+          img_width = pixbuf.width
+          img_height = pixbuf.height
+        end
+
+        @border_scale = [img_width, img_height].max.to_f / print_size.max.to_i
+
+        draw_background(cr, img_height, img_width, pixbuf)
+
+        x = border_width
+        y = border_width
+
+        # This biggest impact will be on the smallest side, so to avoid white
+        # edges between photo and border scale by the longest changed side.
+        longest_side = [pixbuf.width, pixbuf.height].max.to_f
+
+        # Should be less than 1
+        pb_scale = (longest_side - (border_width * 2)) / longest_side
+
+        if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
+          x -= @crop[0]
+          y -= @crop[1]
+        end
+
+        draw_pixbuf(pixbuf, cr, img_height, img_width, pb_scale, x, y)
+      end
+    end
+
+    private
+
+    # Width is proportional to output size
+    def border_width
+      @border_size * @border_scale
+    end
+
+    def draw_pixbuf(pixbuf, cr, img_height, img_width, pb_scale, x, y)
+      case style
+      when 'retro'
+        Morandi::CairoExt.rounded_rectangle(cr, x, y,
+                                            img_width + x - (border_width * 2),
+                                            img_height + y - (border_width * 2), border_width)
+      when 'square'
+        cr.rectangle(x, y, img_width - (border_width * 2), img_height - (border_width * 2))
+      end
+      cr.clip
+
+      if @shrink
+        cr.translate(border_width, border_width)
+        cr.scale(pb_scale, pb_scale)
+      end
+      cr.set_source_pixbuf(pixbuf)
+      cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
+
+      cr.paint(1.0)
+    end
+
+    def draw_background(cr, img_height, img_width, pixbuf)
+      cr.save do
+        cr.translate(-@crop[0], -@crop[1]) if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
+
+        cr.save do
+          cr.set_operator :source
+          cr.set_source_rgb 1, 1, 1
+          cr.paint
+
+          cr.rectangle(0, 0, img_width, img_height)
+          case colour
+          when 'dominant'
+            pixbuf.scale_max(400).save(fn = "/tmp/hist-#{$PROCESS_ID}.#{Time.now.to_i}", 'jpeg')
+            histogram = Colorscore::Histogram.new(fn)
+            FileUtils.rm_f(fn)
+            col = histogram.scores.first[1]
+            cr.set_source_rgb col.red / 256.0, col.green / 256.0, col.blue / 256.0
+          when 'retro'
+            cr.set_source_rgb 1, 1, 0.8
+          when 'black'
+            cr.set_source_rgb 0, 0, 0
+          else
+            cr.set_source_rgb 1, 1, 1
+          end
+          cr.fill
+        end
+      end
+    end
+  end
+
+  # Colourify Operation
+  # Apply tint to image with variable strength
+  # Supports filter, alpha
+  class Colourify < ImageOperation
+    attr_reader :filter
+
+    def alpha
+      @alpha || 255
+    end
+
+    def sepia(pixbuf)
+      MorandiNative::PixbufUtils.tint(pixbuf, 25, 5, -25, alpha)
+    end
+
+    def bluetone(pixbuf)
+      MorandiNative::PixbufUtils.tint(pixbuf, -10, 5, 25, alpha)
+    end
+
+    def null(pixbuf)
+      pixbuf
+    end
+    alias full null # WebKiosk
+    alias colour null # WebKiosk
+
+    def greyscale(pixbuf)
+      MorandiNative::PixbufUtils.tint(pixbuf, 0, 0, 0, alpha)
+    end
+    alias bw greyscale # WebKiosk
+
+    def call(_image, pixbuf)
+      if @filter && respond_to?(@filter)
+        __send__(@filter, pixbuf)
+      else
+        pixbuf # Default is nothing
+      end
+    end
+  end
+end