motion-capture 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2ea866d57338e676627eaa74c23c490d6e8fd06
-  data.tar.gz: 0f31ebdf4127769dbfac818379cb5372e45f870e
+  metadata.gz: add5c836f6f0803ee318c5e70fddc996b7147bb4
+  data.tar.gz: 1d6af1f376fc2efcf7f84ca8a74e26ec6eb224b8
 SHA512:
-  metadata.gz: e5e8c4a930c9b6cc47e7479b0ddd84cc186ae717a8dc27f850c4e544fff6c48d43d4ba15d0c5d5a3d8a3a212bd65da00166c17fc010e6adc92d3b5e66167502c
-  data.tar.gz: d719496998b5a1f5d80ba12da71d9a8dff5265d7ece8c37feb262d719cb19ef592e60d66bfa412e3684a606cb84036dcc95cece83dd51b06e4df3082426710a5
+  metadata.gz: a44554d9deac436ec6940cbe0bc9fbf96011d736cb5a6c79a59a950384b9b61287b35098c26961fa64af2543d9494d6b5c176814f2118cafddce0fe1452191ee
+  data.tar.gz: 98ecacd33e94384f1bf33c404283d9a69a4a13ac37dd91086392f8a1affdb4e266100e498ce23cce3dbd4a07e1f1984ff1b232517dc1d1e9e63aa81aef569b7f

data/lib/project/motion-capture.rb

@@ -1,230 +1,240 @@
-class Motion
-  class Capture
-    DEFAULT_OPTIONS  = { device: :default }
+module Motion; class Capture
+  CAMERA_POSITIONS = { rear: AVCaptureDevicePositionBack, front: AVCaptureDevicePositionFront }
+  FLASH_MODES      = { on: AVCaptureFlashModeOn, off: AVCaptureFlashModeOff, auto: AVCaptureFlashModeAuto }
 
-    attr_accessor :options, :device
+  attr_reader :options, :device
 
-    def initialize(options = {})
-      self.options = options.merge(DEFAULT_OPTIONS)
-    end
-
-    def start!
-      use_camera(options[:device])
-
-      add_ouput(still_image_output)
-    end
+  def initialize(options = {})
+    @options = options
+  end
 
-    def stop!
-      session.stopRunning
+  def on_error(block)
+    @error_callback = block
+  end
 
-      remove_outputs
-      remove_inputs
+  def start!
+    use_camera(options.fetch(:device, :default))
 
-      @_still_image_output = nil
-      @_session = nil
-      @_capture_preview_view = nil
-    end
+    add_ouput(still_image_output)
+  end
 
-    def capture(&block)
-      still_image_connection = still_image_output.connectionWithMediaType(AVMediaTypeVideo)
+  def stop!
+    session.stopRunning
 
-      if still_image_connection.isVideoOrientationSupported
-        still_image_connection.setVideoOrientation(UIDevice.currentDevice.orientation)
-      end
+    remove_outputs
+    remove_inputs
 
-      still_image_output.captureStillImageAsynchronouslyFromConnection(still_image_connection, completionHandler: lambda { |image_data_sample_buffer, error|
-        if image_data_sample_buffer
-          image_data = AVCaptureStillImageOutput.jpegStillImageNSDataRepresentation(image_data_sample_buffer)
+    @still_image_output   = nil
+    @session              = nil
+    @capture_preview_view = nil
+  end
 
-          block.call(image_data)
-        else
-          p "Error capturing image: #{error.localizedDescription}"
-        end
-      })
-    end
+  def running?
+    session && session.running?
+  end
 
-    def capture_and_save(&block)
-      still_image_connection = still_image_output.connectionWithMediaType(AVMediaTypeVideo)
+  def capture(&block)
+    still_image_output.captureStillImageAsynchronouslyFromConnection(still_image_connection, completionHandler: -> (buffer, error) {
+      if error
+        error_callback.call(error)
+      else
+        image_data = AVCaptureStillImageOutput.jpegStillImageNSDataRepresentation(buffer)
 
-      if still_image_connection.isVideoOrientationSupported
-        still_image_connection.setVideoOrientation(UIDevice.currentDevice.orientation)
+        block.call(image_data)
       end
+    })
+  end
 
-      still_image_output.captureStillImageAsynchronouslyFromConnection(still_image_connection, completionHandler: lambda { |image_data_sample_buffer, error|
-        if image_data_sample_buffer
-          image_data = AVCaptureStillImageOutput.jpegStillImageNSDataRepresentation(image_data_sample_buffer)
-
-          assets_library.writeImageDataToSavedPhotosAlbum(image_data, metadata: nil, completionBlock: lambda { |asset_url, error|
-            block.call(asset_url)
-          })
-        else
-          p "Error capturing image: #{error.localizedDescription}"
-        end
-      })
-    end
+  def capture_image(&block)
+    capture do |jpeg_data|
+      image = UIImage.imageWithData(jpeg_data)
 
-    def assets_library
-      @_assets_library ||= ALAssetsLibrary.alloc.init
+      block.call(image)
     end
+  end
 
-    def capture_preview_view(options)
-      @_capture_preview_view ||= begin
-        start!
+  def capture_and_save(&block)
+    capture do |jpeg_data|
+      save_data(jpeg_data) do |asset_url|
+        block.call(jpeg_data, asset_url)
+      end
+    end
+  end
 
-        UIView.alloc.initWithFrame(options.fetch(:frame, CGRectZero)).tap do |view|
-          view.backgroundColor = UIColor.whiteColor
+  def capture_image_and_save(&block)
+    capture do |jpeg_data|
+      save_data(jpeg_data) do |asset_url|
+        image = UIImage.imageWithData(jpeg_data)
 
-          view.layer.addSublayer(preview_layer_for_view(view))
-        end
+        block.call(image, asset_url)
       end
     end
+  end
 
-    def use_camera(camera)
-      device = camera_devices[camera]
+  def save_data(jpeg_data, &block)
+    assets_library.writeImageDataToSavedPhotosAlbum(jpeg_data, metadata: nil, completionBlock: -> (asset_url, error) {
+      error ? error_callback.call(error) : block.call(asset_url)
+    })
+  end
 
-      error = Pointer.new(:object)
+  def attach(view, options = {})
+    preview_layer = preview_layer_for_view(view, options)
 
-      self.device = device
-      input = AVCaptureDeviceInput.deviceInputWithDevice(device, error: error)
+    view.layer.addSublayer(preview_layer)
+  end
 
-      if input
-        set_input(input)
-      else
-        p error[0].description
-      end
-    end
+  def use_camera(target_camera = :default)
+    @device = camera_devices[target_camera]
 
-    def toggle_camera
-      if using_rear_camera?
-        use_camera(:front)
-      else
-        use_camera(:rear)
-      end
+    error_pointer = Pointer.new(:object)
+
+    if input = AVCaptureDeviceInput.deviceInputWithDevice(device, error: error_pointer)
+      set_input(input)
+    else
+      error_callback.call(error_pointer[0])
     end
+  end
+
+  def toggle_camera
+    target_camera = using_rear_camera? ? :front : :rear
 
-    def toggle_flash
-      if device && device.hasFlash
-        error = Pointer.new(:object)
-        if device.lockForConfiguration(error)
-          if flash_on?
-            turn_flash_off
-          else
-            turn_flash_on
-          end
-
-          device.unlockForConfiguration
-        else
-          p error[0].description
-        end
+    use_camera(target_camera)
+  end
+
+  def toggle_flash
+    if device && device.hasFlash
+      configure_with_lock do
+        target_mode = flash_on? ? :off : :on
+
+        set_flash(target_mode)
       end
     end
+  end
+
+  def set_flash(mode = :auto)
+    device.flashMode = FLASH_MODES[mode] if FLASH_MODES.keys.include? mode
+  end
 
-    private
+  private
 
-    def set_input(input)
-      remove_inputs
+  def error_callback
+    @error_callback ||= -> (error) { p "An error occurred: #{error.localizedDescription}." }
+  end
 
-      add_input(input)
+  def still_image_connection
+    @still_image_connection ||= still_image_output.connectionWithMediaType(AVMediaTypeVideo).tap do |connection|
+      connection.setVideoOrientation(UIDevice.currentDevice.orientation) if connection.videoOrientationSupported?
     end
+  end
 
-    def set_output(output)
-      remove_outputs
+  def assets_library
+    @assets_library ||= ALAssetsLibrary.alloc.init
+  end
 
-      add_output(output)
-    end
+  def configure_with_lock(&block)
+    error_pointer = Pointer.new(:object)
 
-    def remove_inputs
-      session.inputs.each do |input|
-        remove_input(input)
-      end
-    end
+    if device.lockForConfiguration(error_pointer)
+      block.call
 
-    def remove_outputs
-      session.outputs.each do |output|
-        remove_output(output)
-      end
+      device.unlockForConfiguration
+    else
+      error_callback.call(error_pointer[0])
     end
+  end
 
-    def remove_input(input)
-      session.removeInput(input)
-    end
+  def set_input(input)
+    remove_inputs
 
-    def remove_output(output)
-      session.removeOutput(output)
-    end
+    add_input(input)
+  end
 
-    def add_input(input)
-      session.addInput(input)
-    end
+  def set_output(output)
+    remove_outputs
 
-    def add_ouput(output)
-      session.addOutput(output)
-    end
+    add_output(output)
+  end
 
-    def default_camera
-      AVCaptureDevice.defaultDeviceWithMediaType(AVMediaTypeVideo)
+  def remove_inputs
+    session.inputs.each do |input|
+      remove_input(input)
     end
+  end
 
-    def rear_camera
-      capture_devices.select { |device| device.position == camera_position_mapping[:rear] }.first
+  def remove_outputs
+    session.outputs.each do |output|
+      remove_output(output)
     end
+  end
 
-    def front_camera
-      capture_devices.select { |device| device.position == camera_position_mapping[:front] }.first
-    end
+  def remove_input(input)
+    session.removeInput(input)
+  end
 
-    def using_rear_camera?
-      device.position == AVCaptureDevicePositionBack
-    end
+  def remove_output(output)
+    session.removeOutput(output)
+  end
 
-    def camera_position_mapping
-      { rear: AVCaptureDevicePositionBack, front: AVCaptureDevicePositionFront }
-    end
+  def add_input(input)
+    session.addInput(input)
+  end
 
-    def camera_devices
-      { default: default_camera, rear: rear_camera, front: front_camera }
-    end
+  def add_ouput(output)
+    session.addOutput(output)
+  end
 
-    def capture_devices
-      @_capture_devices ||= AVCaptureDevice.devicesWithMediaType(AVMediaTypeVideo)
-    end
+  def default_camera
+    AVCaptureDevice.defaultDeviceWithMediaType(AVMediaTypeVideo)
+  end
 
-    def preview_layer_for_view(view)
-      AVCaptureVideoPreviewLayer.layerWithSession(session).tap do |layer|
-        layer_bounds = view.layer.bounds
+  def rear_camera
+    capture_devices.select { |device| device.position == CAMERA_POSITIONS[:rear] }.first
+  end
 
-        layer.bounds       = layer_bounds
-        layer.position     = CGPointMake(CGRectGetMidX(layer_bounds), CGRectGetMidY(layer_bounds))
-        layer.videoGravity = AVLayerVideoGravityResizeAspectFill
-      end
-    end
+  def front_camera
+    capture_devices.select { |device| device.position == CAMERA_POSITIONS[:front] }.first
+  end
 
-    def flash_on?
-      device.flashMode == AVCaptureFlashModeOn
-    end
+  def using_rear_camera?
+    device.position == CAMERA_POSITIONS[:rear]
+  end
 
-    def turn_flash_on
-      device.flashMode = AVCaptureFlashModeOn
-    end
+  def camera_devices
+    { default: default_camera, rear: rear_camera, front: front_camera }
+  end
 
-    def turn_flash_off
-      device.flashMode = AVCaptureFlashModeOff
+  def capture_devices
+    @capture_devices ||= AVCaptureDevice.devicesWithMediaType(AVMediaTypeVideo)
+  end
+
+  def preview_layer_for_view(view, options = {})
+    AVCaptureVideoPreviewLayer.layerWithSession(session).tap do |layer|
+      layer_bounds = view.layer.bounds
+
+      layer.bounds       = layer_bounds
+      layer.position     = CGPointMake(CGRectGetMidX(layer_bounds), CGRectGetMidY(layer_bounds))
+      layer.zPosition    = options.fetch(:z_position, -100)
+      layer.videoGravity = options.fetch(:video_gravity, AVLayerVideoGravityResizeAspectFill)
     end
+  end
 
-    def session
-      @_session ||= AVCaptureSession.alloc.init.tap do |session|
-        session.sessionPreset = AVCaptureSessionPresetMedium
+  def flash_on?
+    [FLASH_MODES[:on], FLASH_MODES[:auto]].include? device.flashMode
+  end
 
-        session.startRunning
-      end
+  def session
+    @session ||= AVCaptureSession.alloc.init.tap do |session|
+      session.sessionPreset = AVCaptureSessionPresetMedium
+
+      session.startRunning
     end
+  end
 
-    def still_image_output
-      @_still_image_output ||= AVCaptureStillImageOutput.alloc.init.tap do |output|
-        settings = { 'AVVideoCodeKey' => AVVideoCodecJPEG }
+  def still_image_output
+    @still_image_output ||= AVCaptureStillImageOutput.alloc.init.tap do |output|
+      settings = { 'AVVideoCodeKey' => AVVideoCodecJPEG }
 
-        output.setOutputSettings(settings)
-      end
+      output.setOutputSettings(settings)
     end
   end
-end
+end; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion-capture
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Devon Blandin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-12 00:00:00.000000000 Z
+date: 2013-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,7 +24,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: AVFoundation wrapper to support custom camera controllers
+description: Easily create custom camera controllers
 email:
 - dblandin@gmail.com
 executables: []
@@ -54,8 +54,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.1.3
 signing_key: 
 specification_version: 4
-summary: AVFoundation wrapper to support custom camera controllers
+summary: RubyMotion AVFoundation wrapper
 test_files: []