image_intensities 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f39c65351e014f893378d86f9c4228992806523aa89c416b67e7f337b7ddc2fb
+  data.tar.gz: d935cc5c3ed468f4413f6e932fe451d0f71ce82ee52b163a8e403f7d02d94a5b
+SHA512:
+  metadata.gz: 9a185c393800449e75e372b0a39d984859952074a5bfdce1666a09f2e01cdbdb7b88135529295265d9204057b55d2dcfc12dca64f03cdddf198ef27846f845d3
+  data.tar.gz: 4cab25ae49fc490400b688436fa3879c3f393bd80331d127e390ab2ad68f4f182bbb702fff4fa47a4abef124012fb87a20063ea1b82cac0f14a0bdd48f3877b1

data/.gitignore

@@ -0,0 +1,7 @@
+# Extconf
+*.o
+*.so
+mkmf.log
+
+# Rubygems
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/ext/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+namespace :image_intensities do
+  desc 'Compile libimage_intensities'
+  task :compile do
+    lib_path = if Dir.pwd.end_with?('/ext')
+      'image_intensities'
+    else
+      'ext/image_intensities'
+    end
+
+    cd lib_path do
+      make_program = ENV['MAKE'] || 'make'
+      sh "#{make_program} lib/libimage_intensities.so"
+    end
+  end
+end
+
+task default: 'image_intensities:compile'

data/ext/image_intensities/Makefile

@@ -0,0 +1,14 @@
+CC    ?= cc
+RM    ?= rm -rf
+MKDIR ?= mkdir
+
+.PHONY: all clean
+
+all: lib/libimage_intensities.so
+
+lib/libimage_intensities.so: definitions.h intensities.c png.c jpeg.c
+	$(MKDIR) -p lib
+	$(CC) intensities.c png.c jpeg.c -fPIC -shared -o lib/libimage_intensities.so -ljpeg -lpng
+
+clean:
+	rm -rf lib

data/ext/image_intensities/definitions.h

@@ -0,0 +1,49 @@
+#ifndef _JPEG_H
+#define _JPEG_H
+
+#include "definitions.h"
+
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+typedef struct rgb_pixel {
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+} rgb_pixel;
+
+typedef struct intensity_sum {
+    uint64_t r;
+    uint64_t g;
+    uint64_t b;
+} intensity_sum;
+
+typedef struct quadrant_sums {
+    intensity_sum nw;
+    intensity_sum ne;
+    intensity_sum sw;
+    intensity_sum se;
+} quadrant_sums;
+
+typedef struct raster_data {
+    uint32_t width;
+    uint32_t height;
+    rgb_pixel *pixels;
+    int error;
+} raster_data;
+
+typedef struct intensity_data {
+    double nw;
+    double ne;
+    double sw;
+    double se;
+    int error;
+} intensity_data;
+
+raster_data read_jpeg_file(const char *file_name);
+raster_data read_png_file(const char *file_name);
+quadrant_sums rgb_sums(rgb_pixel *restrict pixels, uint32_t width, uint32_t height);
+
+intensity_data jpeg_intensities(const char *file_name);
+intensity_data png_intensities(const char *file_name);
+
+#endif

data/ext/image_intensities/intensities.c

@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <fcntl.h>
+#include <string.h>
+#include <jpeglib.h>
+
+#include "definitions.h"
+
+quadrant_sums rgb_sums(rgb_pixel *restrict pixels, uint32_t width, uint32_t height)
+{
+    quadrant_sums sums = {{}};
+
+    for (uint32_t i = 0; i < height; ++i) {
+        for (uint32_t j = 0; j < width; ++j) {
+            int nw = (i <= height / 2) && (j <= width / 2);
+            int ne = (i <= height / 2) && (j >= width / 2);
+            int sw = (i >= height / 2) && (j <= width / 2);
+            int se = (i >= height / 2) && (j >= width / 2);
+
+            rgb_pixel pix = pixels[i * width + j];
+
+            if (nw) {
+                sums.nw.r += pix.r;
+                sums.nw.g += pix.g;
+                sums.nw.b += pix.b;
+            }
+
+            if (ne) {
+                sums.ne.r += pix.r;
+                sums.ne.g += pix.g;
+                sums.ne.b += pix.b;
+            }
+
+            if (sw) {
+                sums.sw.r += pix.r;
+                sums.sw.g += pix.g;
+                sums.sw.b += pix.b;
+            }
+
+            if (se) {
+                sums.se.r += pix.r;
+                sums.se.g += pix.g;
+                sums.se.b += pix.b;
+            }
+        }
+    }
+
+    return sums;
+}
+
+static intensity_data rgb_to_luma(quadrant_sums sums, raster_data data)
+{
+    double dim = MAX(data.width * data.height / 4.0, 1);
+
+    double nw_luma = ((sums.nw.r / dim * 0.2126) +
+                      (sums.nw.g / dim * 0.7152) +
+                      (sums.nw.b / dim * 0.0772)) / 3.0;
+
+    double ne_luma = ((sums.ne.r / dim * 0.2126) +
+                      (sums.ne.g / dim * 0.7152) +
+                      (sums.ne.b / dim * 0.0772)) / 3.0;
+
+    double sw_luma = ((sums.sw.r / dim * 0.2126) +
+                      (sums.sw.g / dim * 0.7152) +
+                      (sums.sw.b / dim * 0.0772)) / 3.0;
+
+    double se_luma = ((sums.se.r / dim * 0.2126) +
+                      (sums.se.g / dim * 0.7152) +
+                      (sums.se.b / dim * 0.0772)) / 3.0;
+
+    return (struct intensity_data) {
+        .nw = nw_luma,
+        .ne = ne_luma,
+        .sw = sw_luma,
+        .se = se_luma,
+        .error = 0
+    };
+}
+
+intensity_data jpeg_intensities(const char *file_name)
+{
+    raster_data data = read_jpeg_file(file_name);
+    if (data.error)
+        return (struct intensity_data) { .error = 1 };
+
+    quadrant_sums sums = rgb_sums(data.pixels, data.width, data.height);
+    intensity_data ins = rgb_to_luma(sums, data);
+
+    free(data.pixels);
+
+    return ins;
+}
+
+intensity_data png_intensities(const char *file_name)
+{
+    raster_data data = read_png_file(file_name);
+    if (data.error)
+        return (struct intensity_data) { .error = 1 };
+
+    quadrant_sums sums = rgb_sums(data.pixels, data.width, data.height);
+    intensity_data ins = rgb_to_luma(sums, data);
+
+    free(data.pixels);
+
+    return ins;
+}

data/ext/image_intensities/jpeg.c

@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <fcntl.h>
+#include <string.h>
+#include <jpeglib.h>
+#include <setjmp.h>
+
+#include "definitions.h"
+
+struct my_error_mgr {
+    struct jpeg_error_mgr pub;
+    jmp_buf setjmp_buffer;
+};
+
+static void my_error_exit(j_common_ptr cinfo)
+{
+    struct my_error_mgr *myerr = (struct my_error_mgr *) cinfo->err;
+    longjmp(myerr->setjmp_buffer, 1);
+}
+
+raster_data read_jpeg_file(const char *file_name)
+{
+    struct jpeg_decompress_struct cinfo;
+    struct my_error_mgr jerr;
+    FILE *file;
+    JSAMPARRAY buffer;
+    int row_stride;
+
+    raster_data data = {};
+
+    file = fopen(file_name, "rb");
+    if (file == NULL) {
+        data.error = 1;
+        return data;        
+    }
+
+    cinfo.err = jpeg_std_error(&jerr.pub);
+    jerr.pub.error_exit = my_error_exit;
+
+    if (setjmp(jerr.setjmp_buffer)) {
+        jpeg_destroy_decompress(&cinfo);
+        fclose(file);
+
+        return data;
+    }
+
+    jpeg_create_decompress(&cinfo);
+    jpeg_stdio_src(&cinfo, file);
+    jpeg_read_header(&cinfo, TRUE);
+    jpeg_start_decompress(&cinfo);
+
+    data.width  = cinfo.output_width;
+    data.height = cinfo.output_height;
+    data.pixels = malloc(cinfo.output_components * cinfo.output_width * cinfo.output_height);
+
+    row_stride = cinfo.output_width * cinfo.output_components;
+    buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
+
+    for (size_t i = 0; cinfo.output_scanline < cinfo.output_height; ++i) {
+        jpeg_read_scanlines(&cinfo, buffer, 1);
+        memcpy(&data.pixels[i * cinfo.output_width], buffer[0], row_stride);
+    }
+
+    jpeg_finish_decompress(&cinfo);
+    jpeg_destroy_decompress(&cinfo);
+    fclose(file);
+
+    return data;
+}

data/ext/image_intensities/png.c

@@ -0,0 +1,75 @@
+#include <png.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#include "definitions.h"
+
+raster_data read_png_file(const char *file_name)
+{
+    FILE *fp = NULL;
+    png_bytep *row_pointers = NULL;
+    int error = 0;
+    raster_data data = {};
+
+    fp = fopen(file_name, "rb");
+    if (fp == NULL) {
+        error = 1;
+        goto cleanup;
+    }
+
+    // These lines will not fail under any usual circumstances, so it's okay
+    // to leak the png ptr if the info ptr can't be allocated
+    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    png_infop info_ptr = png_create_info_struct(png_ptr);
+
+    if (!png_ptr || !info_ptr) {
+        error = 1;
+        goto cleanup;
+    }
+
+    // Set up error handler
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        error = 1;
+        goto cleanup;
+    }
+
+    png_init_io(png_ptr, fp);
+    png_set_sig_bytes(png_ptr, 0);
+
+    png_read_info(png_ptr, info_ptr);
+
+    data.width = png_get_image_width(png_ptr, info_ptr);
+    data.height = png_get_image_height(png_ptr, info_ptr);
+
+    data.pixels = malloc(png_get_rowbytes(png_ptr, info_ptr) * data.height);
+
+    png_set_strip_16(png_ptr);
+    png_set_strip_alpha(png_ptr);
+    png_set_gray_to_rgb(png_ptr);
+    png_set_expand(png_ptr);
+    png_set_interlace_handling(png_ptr);
+    png_read_update_info(png_ptr, info_ptr);
+
+    row_pointers = png_malloc(png_ptr, data.height * sizeof(png_bytep));
+    for (size_t i = 0; i < data.height; ++i)
+        row_pointers[i] = (png_bytep) &data.pixels[data.width * i];
+
+    png_read_image(png_ptr, row_pointers);
+    png_free(png_ptr, row_pointers);
+    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+    fclose(fp);
+
+    return data;
+
+cleanup:
+
+    if (fp) fclose(fp);
+    if (row_pointers) png_free(png_ptr, row_pointers);
+    if (png_ptr && info_ptr) png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+    data.error = error;
+    return data;
+}

data/image_intensities.gemspec

@@ -0,0 +1,17 @@
+require_relative 'lib/image_intensities/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'image_intensities'
+  s.version       = ImageIntensities::VERSION
+  s.summary       = ''
+  s.author        = 'Liam P. White'
+  s.files         = `git ls-files`.split("\n")
+  s.license       = 'MIT'
+  s.extensions    = %w[ext/Rakefile]
+  s.require_paths = %w[lib]
+
+  s.add_dependency 'ffi'
+  s.add_dependency 'rake'
+  s.add_dependency 'rb-libmagic'
+
+end

data/lib/image_intensities.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'magic'
+
+module ImageIntensities
+  def self.file(path)
+    case magic.file(path)
+    when 'image/png'
+      ins = Native.png_intensities(path)
+      raise 'Processing error' if ins[:error] != 0
+
+      { nw: ins[:nw], ne: ins[:ne], sw: ins[:sw], se: ins[:se] }
+    when 'image/jpeg'
+      ins = Native.jpeg_intensities(path)
+      raise 'Processing error' if ins[:error] != 0
+
+      { nw: ins[:nw], ne: ins[:ne], sw: ins[:sw], se: ins[:se] }
+    else
+      raise "Unsupported file type `#{mime}'"
+    end
+  end
+
+  def self.magic
+    @magic ||= Magic.new(Magic::MIME_TYPE)
+  end
+end
+
+require 'image_intensities/native'
+require 'image_intensities/version'

data/lib/image_intensities/native.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module ImageIntensities
+  module Native
+    extend FFI::Library
+
+    spec = Gem.loaded_specs['image_intensities']
+    gem_root = spec.gem_dir
+    ffi_lib "#{gem_root}/ext/image_intensities/lib/libimage_intensities.so"
+
+    class IntensityData < FFI::Struct
+      layout :nw, :double,
+             :ne, :double,
+             :sw, :double,
+             :se, :double,
+             :error, :int
+    end
+
+    attach_function :jpeg_intensities, [:string], IntensityData.by_value
+    attach_function :png_intensities, [:string], IntensityData.by_value
+  end
+end

data/lib/image_intensities/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ImageIntensities
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: image_intensities
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Liam P. White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-libmagic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions:
+- ext/Rakefile
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- ext/Rakefile
+- ext/image_intensities/Makefile
+- ext/image_intensities/definitions.h
+- ext/image_intensities/intensities.c
+- ext/image_intensities/jpeg.c
+- ext/image_intensities/png.c
+- image_intensities.gemspec
+- lib/image_intensities.rb
+- lib/image_intensities/native.rb
+- lib/image_intensities/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []