dragonfly-lossless_rotate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4570113d02eed8571af6ccd48135730ecb435d85edc5db4f3c12dc5134fbb4c0
+  data.tar.gz: 1c711083d0e1a89a0f13ade6e1d30488f4f565aaefda54fcde30c73b356e4b94
+SHA512:
+  metadata.gz: 83923e26bc11d4cab7cbf1dfc30f1a81528917ff5454d5636eeb0d8a9920454639a6fa74c94820b84e804da5aa3ffd3ffa6c63c033284fd90ce839be8291743a
+  data.tar.gz: 8dd6253e9ac9f9766439c87f26c285c0f8be8bfc1d7bba6ba92ca92b773cb5ab72d4b611f914425839d24ce62d4486643c477b9ad82a9262dab2edd275b3fc10

data/README.md

@@ -0,0 +1,247 @@
+# Dragonfly Lossless Rotate
+
+**About 60% more performance with libjpeg-turbo tools**
+
+## NOTE
+
+Tool _jpegtran_ from MozJPEG may work incorrectly and not rotate same image many times.
+You should test it before run in production.
+
+## Setup
+
+```ruby
+gem "dragonfly-lossless_rotate"
+```
+
+```ruby
+Dragonfly.app.configure
+  require "dragonfly/lossless_rotate"
+  plugin :lossless_rotate
+end
+```
+
+## Requirements
+
+By default gem use _libjpeg_ binaries:
+```shell
+cjpeg
+djpeg
+jpegtran
+pnmflip
+```
+
+But you can set MozJPEG binaries in ENV `CJPEG_BIN=mozjpeg-cjpeg` or in config:
+```ruby
+Dragonfly.app.configure
+  require "dragonfly/lossless_rotate"
+  plugin :lossless_rotate, cjpeg_bin: "mozjpeg-cjpeg",
+                           djpeg_bin: "mozjpeg-djpeg",
+                           jpegtran_bin: "mozjpeg-jpegtran"
+
+end
+```
+
+## Usage
+
+JPEG only:
+```ruby
+@image.process(:lossless_rotate) # default 90
+@image.process(:lossless_rotate, 180)
+@image.process(:lossless_rotate, 270)
+@image.process(:lossless_rotate, -90)
+
+# Without JPEG optimization
+@image.process(:lossless_rotate, 90, optimize: false)
+```
+
+With fallback for other formats (rotate via ImageMagick):
+```ruby
+@image.process(:safe_lossless_rotate)
+```
+
+## Benchmark
+
+- _libjpeg_ version 9b (17-Jan-2016)
+- _libjpeg-turbo_ version 1.4.2 (build 20160222)
+- _MozJPEG_ version 3.3.2 (build 20180713)
+
+JPEG 85KB 552x416px
+
+### ImageMagick rotate
+```bash
+convert old_path -rotate 90 new_path
+```
+```ruby
+puts Benchmark.measure { 500.times { @image.rotate(90).apply } }
+  0.360000   1.570000  25.270000 ( 25.168681)
+```
+
+### Lossless rotate
+
+#### libjpeg
+
+##### (optimize=true)
+```bash
+jpegtran -rotate 90 -perfect -optimize old_path > new_path
+```
+
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate).apply } }
+  0.240000   1.190000  10.600000 ( 11.368903)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate).apply } }
+  0.440000   1.640000  24.360000 ( 26.211808)
+```
+
+##### (optimize=false)
+```bash
+jpegtran -rotate 90 -perfect old_path > new_path
+```
+
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate, 90, optimize: false).apply } }
+  0.290000   1.170000   9.600000 ( 10.321087)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate, 90, optimize: false).apply } }
+  0.450000   1.470000  23.610000 ( 25.478872)
+```
+
+#### libjpeg-turbo
+
+##### (optimize=true)
+```bash
+jpegtran -rotate 90 -perfect -optimize old_path > new_path
+```
+
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate).apply } }
+  0.280000   1.160000   9.170000 (  9.876645)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate).apply } }
+  0.560000   1.780000  22.710000 ( 23.879913)
+```
+
+##### (optimize=false)
+```bash
+jpegtran -rotate 90 -perfect old_path > new_path
+```
+
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate, 90, optimize: false).apply } }
+  0.290000   1.170000   9.600000 ( 10.321087)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate, 90, optimize: false).apply } }
+  0.450000   1.470000  23.610000 ( 25.478872)
+```
+
+#### MozJPEG
+
+##### (optimize=true)
+```bash
+mozjpeg-jpegtran -rotate 90 -perfect -optimize old_path > new_path
+```
+
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate).apply } }
+  0.270000   1.110000  35.230000 ( 36.693039)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate).apply } }
+  0.550000   1.540000  48.880000 ( 50.171667)
+```
+
+##### (optimize=false)
+```bash
+mozjpeg-jpegtran -rotate 90 -perfect old_path > new_path
+```
+
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate, 90, optimize: false).apply } }
+  0.310000   1.100000  34.960000 ( 35.947432)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate, 90, optimize: false).apply } }
+  0.470000   1.660000  49.050000 ( 50.823576)
+```
+
+### Fallback when jpegtran transformation is not perfect
+
+> if the image dimensions are not a multiple of the iMCU size (usually 8 or 16 pixels)
+
+Same image but resized to 556x417px
+
+#### libjpeg
+
+##### (optimize=true)
+```bash
+djpeg old_path | pnmflip -r270 | cjpeg -optimize > new_path
+```
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate).apply } }
+  0.340000   0.930000  19.320000 ( 16.055059)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate).apply } }
+  0.390000   1.240000  32.520000 ( 30.055926)
+```
+
+##### (optimize=false)
+```bash
+djpeg old_path | convert - -rotate 90 JPG:new_path
+```
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate, 90, optimize: false).apply } }
+  0.310000   1.450000  30.520000 ( 28.357557)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate, 90, optimize: false).apply } }
+  0.530000   1.520000  43.790000 ( 41.732961)
+```
+
+#### libjpeg-turbo
+
+##### (optimize=true)
+```bash
+djpeg old_path | pnmflip -r270 | cjpeg -optimize > new_path
+```
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate).apply } }
+  0.410000   1.280000  16.310000 ( 13.220535)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate).apply } }
+  0.310000   1.330000  30.300000 ( 28.332533)
+```
+
+##### (optimize=false)
+```bash
+djpeg old_path | convert - -rotate 90 JPG:new_path
+```
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate, 90, optimize: false).apply } }
+  0.470000   1.110000  29.630000 ( 26.944807)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate, 90, optimize: false).apply } }
+  0.500000   1.810000  43.420000 ( 42.309805)
+```
+
+#### MozJPEG
+
+##### (optimize=true)
+```bash
+mozjpeg-djpeg old_path | pnmflip -r270 | mozjpeg-cjpeg -optimize > new_path
+```
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate).apply } }
+  0.400000   1.150000  41.190000 ( 37.970843)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate).apply } }
+  0.420000   1.670000  55.700000 ( 52.835614)
+```
+
+##### (optimize=false)
+```bash
+mozjpeg-djpeg old_path | convert - -rotate 90 JPG:new_path
+```
+```ruby
+puts Benchmark.measure { 500.times { @image.process(:lossless_rotate, 90, optimize: false).apply } }
+  0.270000   1.170000  31.300000 ( 28.983087)
+
+puts Benchmark.measure { 500.times { @image.process(:safe_lossless_rotate, 90, optimize: false).apply } }
+  0.340000   1.310000  44.890000 ( 43.052428)
+```

data/dragonfly-lossless_rotate.gemspec

@@ -0,0 +1,23 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dragonfly/lossless_rotate/version"
+
+Gem::Specification.new do |spec|
+  spec.name         = "dragonfly-lossless_rotate"
+  spec.version      = Dragonfly::LosslessRotate::VERSION
+  spec.summary      = "Dragonfly lossless image rotate"
+  spec.description  = "Lossless rotating and compressing JPEG images via libjpeg tools"
+  spec.author       = "Maxim Perepelitsa"
+  spec.email        = "n0xff@outlook.com"
+  spec.homepage     = "https://github.com/n0xff/dragonfly-lossless_rotate"
+  spec.license      = "MIT"
+
+  spec.requirements << "cjpeg"
+  spec.requirements << "djpeg"
+  spec.requirements << "jpegtran"
+  spec.requirements << "pnmflip"
+
+  spec.files        = `git ls-files`.split($/)
+
+  spec.add_runtime_dependency "dragonfly", "~> 1.0"
+end

data/lib/dragonfly/lossless_rotate.rb

@@ -0,0 +1,93 @@
+require "dragonfly"
+
+Dragonfly::App.register_plugin(:lossless_rotate) { Dragonfly::LosslessRotate::Plugin.new }
+
+module Dragonfly
+  class LosslessRotate
+
+    class Plugin
+      def call(app, opts={})
+        app.env[:cjpeg_bin] = opts[:cjpeg_bin] || "cjpeg"
+        app.env[:djpeg_bin] = opts[:djpeg_bin] || "djpeg"
+        app.env[:jpegtran_bin] = opts[:jpegtran_bin] || "jpegtran"
+        app.env[:pnmflip_bin] = opts[:pnmflip_bin] || "pnmflip"
+
+        app.add_processor :lossless_rotate, Dragonfly::LosslessRotate::Rotate.new
+        app.add_processor :safe_lossless_rotate, Dragonfly::LosslessRotate::SafeRotate.new
+      end
+    end
+
+    # Only JPEG format
+    class Rotate
+      def call(content, degree=90, optimize: true)
+        unless [90, 180, 270, -90, -180, -270].include?(degree)
+          warn "Rotate by 90, 180 and 270 degrees allowed"
+          degree = 90
+        end
+
+        rotate(content, degree, optimize)
+      end
+
+      private
+
+        def rotate(content, degree, optimize)
+          cjpeg_bin    = content.env[:cjpeg_bin] || "cjpeg"
+          djpeg_bin    = content.env[:djpeg_bin] || "djpeg"
+          jpegtran_bin = content.env[:jpegtran_bin] || "jpegtran"
+          pnmflip_bin  = content.env[:pnmflip_bin] || "pnmflip"
+
+          content.shell_update escape: false do |old_path, new_path|
+            optimize_option = " -optimize" if optimize
+            output_command = if optimize
+              " #{pnmflip_bin} -r#{pnmflip_degrees(degree)} | #{cjpeg_bin}#{optimize_option} > #{new_path}"
+            else
+              " convert - -rotate #{degree} JPG:#{new_path}"
+            end
+
+            lossless_rotate_command = "#{jpegtran_bin} -rotate #{jpegtran_degrees(degree)} -perfect#{optimize_option} #{old_path} > #{new_path}"
+            lossy_rotate_command = "#{djpeg_bin} #{old_path} |#{output_command}"
+
+            "#{lossless_rotate_command} || #{lossy_rotate_command}"
+          end
+        end
+
+        def pnmflip_degrees(degree)
+          {
+            90 => 270,
+            180 => 180,
+            270 => 90,
+            -90 => 90,
+            -180 => 180,
+            -270 => 270
+          }[degree]
+        end
+
+        def jpegtran_degrees(degree)
+          {
+            90 => 90,
+            180 => 180,
+            270 => 180,
+            -90 => 270,
+            -180 => 180,
+            -270 => 90
+          }[degree]
+        end
+
+        def jpeg?(content)
+          content.shell_eval { |path| "identify -format \%m #{path}" } == "JPEG"
+        end
+    end
+
+    # All formats support by ImageMagick
+    class SafeRotate < Rotate
+      def rotate(content, degree, optimize)
+        return super if jpeg?(content)
+
+        content.shell_update escape: false do |old_path, new_path|
+          "convert -rotate #{degree} #{old_path} > #{new_path}"
+        end
+      end
+      private :rotate
+    end
+  end
+end

data/lib/dragonfly/lossless_rotate/version.rb

@@ -0,0 +1,5 @@
+module Dragonfly
+  class LosslessRotate
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: dragonfly-lossless_rotate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Maxim Perepelitsa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dragonfly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Lossless rotating and compressing JPEG images via libjpeg tools
+email: n0xff@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- dragonfly-lossless_rotate.gemspec
+- lib/dragonfly/lossless_rotate.rb
+- lib/dragonfly/lossless_rotate/version.rb
+homepage: https://github.com/n0xff/dragonfly-lossless_rotate
+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:
+- cjpeg
+- djpeg
+- jpegtran
+- pnmflip
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Dragonfly lossless image rotate
+test_files: []