motion-image-editor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bf6b38e31764220c4bb4d6f140089e3bdb50297
+  data.tar.gz: cb67aebfe59a677c3965522e83ce44151ff9af61
+SHA512:
+  metadata.gz: 7b4f42115362f4ff5b14d2948949fe31db972b7d5d5fbbb608229778a3ad533468dfd724d48ec5fc8999842ff1fe0a20d4ba2b126b6b501ebef8e33d7a2f3f6f
+  data.tar.gz: ce32cb9001e626e9425cb70d421643ab5621e56c1e80cbe477e3a6f69a852517800cf1ddf89136fd95d94557934d3d885685f9357efa3435b277a07ae5b6b892

data/README.md

@@ -0,0 +1,29 @@
+# motion-image-editor
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion-image-editor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion-image-editor
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/motion-image-editor.rb

@@ -0,0 +1,11 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "project/**/*.rb")))
+
+  app.pods ||= Motion::Project::CocoaPods.new(app)
+  app.pods.pod 'UIImage-Resize', '~> 1.0.1'
+end

data/lib/project/controllers/image_editor_controller.rb

@@ -0,0 +1,361 @@
+class Motion; class ImageEditorController < UIViewController
+  ANIMATION_DURATION = 0.2
+  MINIMUM_SCALE      = 1
+  MAXIMUM_SCALE      = 3
+
+  attr_reader :touch_center,
+              :scale_center,
+              :scale,
+              :output_width,
+              :source_image,
+              :crop_rect
+
+  def viewDidLoad
+    super
+
+    add_subviews
+
+    add_gesture_recognizers
+
+    setup_constraints
+  end
+
+  def add_subviews
+    view.addSubview(crop_view)
+    view.insertSubview(image_view, belowSubview: crop_view)
+  end
+
+  def add_gesture_recognizers
+    crop_view.addGestureRecognizer(pan_recognizer)
+    crop_view.addGestureRecognizer(pinch_recognizer)
+    crop_view.addGestureRecognizer(rotation_recognizer)
+    crop_view.addGestureRecognizer(tap_recognizer)
+  end
+
+  def setup_constraints
+    view.addConstraints(NSLayoutConstraint.constraintsWithVisualFormat(
+      'H:|[crop]|',
+      options: 0,
+      metrics: nil,
+      views:   { 'crop' => crop_view }))
+
+    view.addConstraints(NSLayoutConstraint.constraintsWithVisualFormat(
+      'V:|[crop]|',
+      options: 0,
+      metrics: nil,
+      views:   { 'crop' => crop_view }))
+  end
+
+  def process(&block)
+    view.userInteractionEnabled = false
+
+    Dispatch::Queue.concurrent.async do
+      @result_ref = transform_image(
+        image_view.transform,
+        source_image:       source_image.CGImage,
+        source_size:        source_image.size,
+        source_orientation: source_image.imageOrientation,
+        output_width:       output_width || source_image.size.width,
+        crop_rect:          crop_rect,
+        image_view_size:    image_view.bounds.size)
+
+      Dispatch::Queue.main.async do
+        transformed_image = UIImage.imageWithCGImage(
+          @result_ref,
+          scale: 1.0,
+          orientation: UIImageOrientationUp)
+
+        @result_ref = nil
+
+        view.userInteractionEnabled = true
+
+        block.call(transformed_image)
+      end
+    end
+  end
+
+  def crop_rect=(rect)
+    @crop_rect = rect
+
+    crop_view.crop_rect = rect
+  end
+
+  def scale_reset_orientations
+    [ UIImageOrientationUpMirrored,
+      UIImageOrientationDownMirrored,
+      UIImageOrientationLeftMirrored,
+      UIImageOrientationRightMirrored ]
+  end
+
+  def transform_image(transform, source_image: source_image, source_size: source_size, source_orientation: source_orientation, output_width: output_width, crop_rect: crop_rect, image_view_size: image_view_size)
+    aspect = crop_rect.size.height / crop_rect.size.width
+    output_size = CGSizeMake(output_width, output_width * aspect)
+
+    transpose = false
+    orientation_transform = CGAffineTransformIdentity
+
+    case source_orientation
+    when UIImageOrientationDown || UIImageOrientationDownMirrored
+      orientation_transform = CGAffineTransformMakeRotation(Math::PI)
+    when UIImageOrientationLeft || UIImageOrientationLeftMirrored
+      orientation_transform = CGAffineTransformMakeRotation(MATH::PI / 2.0)
+      transpose             = true
+    when UIImageOrientationRight || UIImageOrientationRightMirrored
+      orientation_transform = CGAffineTransformMakeRotation(-(Math::PI / 2.0))
+      transpose             = true
+    end
+
+    if scale_reset_orientations.include? source_orientation
+      orientation_transform = CGAffineTransformScale(transform, -1, 1)
+    end
+
+    if transpose
+      image_view_size = CGSizeMake(image_view_size.height, image_view_size.width)
+    end
+
+    context = CGBitmapContextCreate(
+      nil,                                      # data
+      output_size.width,                        # width
+      output_size.height,                       # height
+      CGImageGetBitsPerComponent(source_image), # bits per component
+      0,                                        # bytes per row
+      CGImageGetColorSpace(source_image),       # color space
+      CGImageGetBitmapInfo(source_image))       # bitmap info
+
+    CGContextSetFillColorWithColor(context,  UIColor.clearColor.CGColor)
+    CGContextFillRect(context, CGRectMake(0, 0, output_size.width, output_size.height))
+
+    ui_coords = CGAffineTransformMakeScale(output_size.width / crop_rect.size.width,
+                                           output_size.height / crop_rect.size.height)
+
+    ui_coords = CGAffineTransformTranslate(ui_coords, crop_rect.size.width / 2.0,
+                                           crop_rect.size.height / 2.0)
+
+    ui_coords = CGAffineTransformScale(ui_coords, 1.0, -1.0)
+    CGContextConcatCTM(context, ui_coords)
+
+    CGContextConcatCTM(context, transform)
+    CGContextScaleCTM(context, 1.0, -1.0)
+    CGContextConcatCTM(context, orientation_transform)
+
+    drawing_rect = CGRectMake(-image_view_size.width / 2.0, -image_view_size.height / 2.0, image_view_size.width, image_view_size.height)
+
+    CGContextDrawImage(context, drawing_rect, source_image)
+
+    CGBitmapContextCreateImage(context)
+  end
+
+  def viewDidAppear(animated)
+    super
+
+    image_view.image = preview_image
+
+    reset
+  end
+
+  def reset(options = {})
+    animated = options.fetch(:animated, false)
+
+    w = 0.0
+    h = 0.0
+
+    source_aspect = source_image.size.height / source_image.size.width
+    crop_aspect   = crop_rect.size.height    / crop_rect.size.width
+
+    if source_aspect > crop_aspect
+        w = crop_rect.size.width
+        h = source_aspect * w
+    else
+      h = crop_rect.size.height
+      w = h / source_aspect
+    end
+
+    @scale = 1
+
+    reset_block = -> {
+      image_view.transform = CGAffineTransformIdentity
+      image_view.frame     = CGRectMake(CGRectGetMidX(crop_rect) - w / 2, CGRectGetMidY(crop_rect) - h / 2, w, h)
+      image_view.transform = CGAffineTransformMakeScale(scale, scale)
+    }
+
+    if animated
+      view.userInteractionEnabled = false
+
+      UIView.animateWithDuration(ANIMATION_DURATION, animations: reset_block, completion: -> (finished) {
+          view.userInteractionEnabled = true
+      })
+    else
+      reset_block.call
+    end
+  end
+
+  # Touch handling
+
+  def touchesBegan(touches, withEvent: event)
+    handle_touches(event.allTouches)
+  end
+
+  def touchesMoved(touches, withEvent: event)
+    handle_touches(event.allTouches)
+  end
+
+  def touchesEnded(touches, withEvent: event)
+    handle_touches(event.allTouches)
+  end
+
+  def touchesCancelled(touches, withEvent: event)
+    handle_touches(event.allTouches)
+  end
+
+  def handle_touches(touches)
+    @touch_center = CGPointZero
+
+    if touches.count >= 2
+      touches.each do |touch|
+        touch_location = touch.locationInView(image_view)
+
+        @touch_center = CGPointMake(touch_center.x + touch_location.x, touch_center.y + touch_location.y)
+      end
+
+      @touch_center = CGPointMake(touch_center.x / touches.count, touch_center.y / touches.count)
+    end
+  end
+
+  def handle_state?(state)
+    if state == UIGestureRecognizerStateEnded
+      new_scale = bounded_scale(scale)
+
+      delta_x = scale_center.x - image_view.bounds.size.width / 2.0
+      delta_y = scale_center.y - image_view.bounds.size.height / 2.0
+
+      transform = CGAffineTransformTranslate(image_view.transform, delta_x, delta_y)
+
+      transform = CGAffineTransformScale(transform, new_scale / scale , new_scale / scale)
+
+      transform = CGAffineTransformTranslate(transform, -delta_x, -delta_y)
+
+      view.userInteractionEnabled = false
+
+      UIView.animateWithDuration(
+        ANIMATION_DURATION,
+        delay: 0,
+        options: UIViewAnimationOptionCurveEaseOut,
+        animations: -> { image_view.transform = transform },
+        completion: -> (finished) {
+          view.userInteractionEnabled = true
+          @scale = new_scale
+      })
+
+      false
+    else
+      true
+    end
+  end
+
+  def handle_pan(recognizer)
+    translation = recognizer.translationInView(image_view)
+    transform   = CGAffineTransformTranslate(image_view.transform, translation.x, translation.y)
+
+    image_view.transform = transform
+
+    recognizer.setTranslation(CGPointZero, inView: crop_view)
+  end
+
+  def handle_pinch(recognizer)
+    if handle_state? recognizer.state
+      if recognizer.state == UIGestureRecognizerStateBegan
+        @scale_center = @touch_center
+      end
+
+      delta_x = scale_center.x - image_view.bounds.size.width / 2.0
+      delta_y = scale_center.y - image_view.bounds.size.height / 2.0
+
+      transform = CGAffineTransformTranslate(image_view.transform, delta_x, delta_y)
+      transform = CGAffineTransformScale(transform, recognizer.scale, recognizer.scale)
+      transform = CGAffineTransformTranslate(transform, -delta_x, -delta_y)
+
+      @scale *= recognizer.scale
+
+      image_view.transform = transform
+
+      recognizer.scale = 1
+    end
+  end
+
+  def handle_rotation(recognizer)
+    delta_x = touch_center.x - image_view.bounds.size.width / 2
+    delta_y = touch_center.y - image_view.bounds.size.height / 2
+
+    transform = CGAffineTransformTranslate(image_view.transform, delta_x, delta_y)
+    transform = CGAffineTransformRotate(transform, recognizer.rotation)
+    transform = CGAffineTransformTranslate(transform, -delta_x, -delta_y)
+
+    image_view.transform = transform
+
+    recognizer.rotation = 0
+  end
+
+  def handle_tap(recognizer)
+    reset(animated: true)
+  end
+
+  def pan_recognizer
+    @pan_recognizer ||= UIPanGestureRecognizer.alloc.initWithTarget(self, action: 'handle_pan:').tap do |recognizer|
+      recognizer.cancelsTouchesInView = false
+      recognizer.delegate             = self
+    end
+  end
+
+  def tap_recognizer
+    @tap_recognizer ||= UITapGestureRecognizer.alloc.initWithTarget(self, action: 'handle_tap:').tap do |recognizer|
+      recognizer.numberOfTapsRequired = 2
+    end
+  end
+
+  def rotation_recognizer
+    @rotation_recognizer ||= UIRotationGestureRecognizer.alloc.initWithTarget(self, action: 'handle_rotation:').tap do |recognizer|
+      recognizer.cancelsTouchesInView = false
+      recognizer.delegate             = self
+    end
+  end
+
+  def pinch_recognizer
+    @pinch_recognizer ||= UIPinchGestureRecognizer.alloc.initWithTarget(self, action: 'handle_pinch:').tap do |recognizer|
+      recognizer.cancelsTouchesInView = false
+      recognizer.delegate             = self
+    end
+  end
+
+  def source_image=(image)
+    if image != source_image
+      @source_image  = image
+      @preview_image = nil
+    end
+  end
+
+  def bounded_scale(scale)
+    return scale if (MINIMUM_SCALE..MAXIMUM_SCALE).include? scale
+
+    scale < MINIMUM_SCALE ? MINIMUM_SCALE : MAXIMUM_SCALE
+  end
+
+  def preview_image
+    @preview_image ||= source_image.resizedImageToFitInSize(view.bounds.size, scaleIfSmaller: false)
+  end
+
+  def image_view
+    @image_view ||= UIImageView.alloc.init.tap do |view|
+      view.translatesAutoresizingMaskIntoConstraints = false
+    end
+  end
+
+  def crop_view
+    @crop_view ||= Motion::ImageEditorView.alloc.init.tap do |view|
+      view.translatesAutoresizingMaskIntoConstraints = false
+    end
+  end
+
+  def prefersStatusBarHidden
+    true
+  end
+end; end

data/lib/project/views/image_editor_view.rb

@@ -0,0 +1,55 @@
+class Motion; class ImageEditorView < UIView
+  def initWithFrame(frame)
+    super.tap do |view|
+      view.opaque          = false
+      view.layer.opacity   = 0.7
+      view.backgroundColor = UIColor.clearColor
+
+      view.addSubview(image_view)
+
+      view.setup_constraints
+    end
+  end
+
+  def setup_constraints
+    addConstraints(NSLayoutConstraint.constraintsWithVisualFormat(
+      'H:|[image]|',
+      options: 0,
+      metrics: nil,
+      views:   { 'image' => image_view }))
+
+    addConstraints(NSLayoutConstraint.constraintsWithVisualFormat(
+      'V:|[image]|',
+      options: 0,
+      metrics: nil,
+      views:   { 'image' => image_view }))
+  end
+
+  def crop_rect
+    @crop_rect ||= CGRectZero
+  end
+
+  def crop_rect=(rect)
+    @crop_rect = CGRectOffset(rect, frame.origin.x, frame.origin.y)
+
+    UIGraphicsBeginImageContextWithOptions(bounds.size, false, 0.0)
+
+    context = UIGraphicsGetCurrentContext()
+
+    UIColor.blackColor.setFill
+    UIRectFill(bounds)
+
+    UIColor.clearColor.setFill
+    UIRectFill(CGRectInset(rect, 1, 1))
+
+    image_view.image = UIGraphicsGetImageFromCurrentImageContext()
+
+    UIGraphicsEndImageContext()
+  end
+
+  def image_view
+    @image_view ||= UIImageView.alloc.init.tap do |image_view|
+      image_view.translatesAutoresizingMaskIntoConstraints = false
+    end
+  end
+end; end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: motion-image-editor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Devon Blandin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  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: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RubyMotion image editing controller
+email:
+- dblandin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/motion-image-editor.rb
+- lib/project/controllers/image_editor_controller.rb
+- lib/project/views/image_editor_view.rb
+homepage: http://github.com/dblandin/motion-image-editor
+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: []
+rubyforge_project: 
+rubygems_version: 2.1.1
+signing_key: 
+specification_version: 4
+summary: Easily scale, rotate, and crop images
+test_files: []