##|
##| REALLY HANDY STUFF!
##| many of these methods are translated from:
##|
##|
##|
class UIImage
class << self
# Easily create a UIImage by using this factory method, and do your drawing
# in a block. The core graphics context will be passed to the block you
# provide. To create a canvas based on an image, use the instance method.
#
# @example
# white_square = UIImage.canvas([100, 100]) do |context|
# :white.uicolor.set
# CGContextAddRect(context, [[0, 0], [100, 100]])
# CGContextDrawPath(context, KCGPathFill)
# end
# :size is required, :scale defaults to the screen scale, and :opaque is
# false by default.
#
# The first argument can be a size, or an options dict
def canvas(options_or_size={}, more_options={}, &block)
if options_or_size.is_a?(NSDictionary)
options = options_or_size
size = options[:size]
else
options = more_options
size = options_or_size
end
raise ":size is required in #{self.name}##canvas" unless size
scale = options.fetch(:scale, 0.0) # not a typo, 0.0 indicates "use default"
opaque = options.fetch(:opaque, false)
UIGraphicsBeginImageContextWithOptions(size, opaque, scale)
block.call(UIGraphicsGetCurrentContext()) if block
new_image = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
return new_image
end
end
# Merges the two images. The target is drawn first, `image` is drawn on top.
# The two images are centered, and the maximum size is used so that both
# images fit on the canvas.
def <<(image)
self.merge(image, at: :center, stretch: true)
end
# Draw an image on top of the receiver. The `:at` option provides either an
# absolute location (Array or CGPoint) or relative location (Symbol, one of
# :top_left, :top, :top_right, :left, :center (default), :right, :bottom_left,
# :bottom, :bottom_right). The `:stretch` option increases the canvas so
# there is room for both images, otherwise the target image's size is used.
def merge(image, options={})
image_position = options.fetch(:at, :center)
stretch = options.fetch(:stretch, false)
size = self.size
if stretch
if image.size.width > size.width
size.width = image.size.width
end
if image.size.height > size.height
size.height = image.size.height
end
end
my_left = image_left = 0
my_top = image_top = 0
my_right = (size.width - self.size.width)
my_bottom = (size.height - self.size.height)
image_right = (size.width - image.size.width)
image_bottom = (size.height - image.size.height)
my_cx = my_right / 2.0
my_cy = my_bottom / 2.0
image_cx = image_right / 2.0
image_cy = image_bottom / 2.0
case image_position
when :top_left, :topleft, :tl
my_position = [my_right, my_bottom]
image_position = [image_left, image_top]
when :top, :t
my_position = [my_cx, my_bottom]
image_position = [image_cx, image_top]
when :top_right, :topright, :tr
my_position = [my_left, my_bottom]
image_position = [image_right, image_top]
when :left, :l
my_position = [my_right, my_cy]
image_position = [image_left, image_cy]
when :center, :c
my_position = [my_cx, my_cy]
image_position = [image_cx, image_cy]
when :right, :r
my_position = [my_left, my_cy]
image_position = [image_right, image_cy]
when :bottom_left, :bottomleft, :bl
my_position = [my_right, my_top]
image_position = [image_left, image_bottom]
when :bottom, :b
my_position = [my_cx, my_top]
image_position = [image_cx, image_bottom]
when :bottom_right, :bottomright, :br
my_position = [my_left, my_top]
image_position = [image_right, image_bottom]
end
return self.draw(size: size, at: my_position) do
image.drawAtPoint(image_position)
end
end
# Returns a cropped UIImage. The easiest way is to check for a CGImage
# backing, but if this image uses a CIImage backing, we draw a new (cropped)
# image.
def crop(rect)
rect = SugarCube::CoreGraphics::Rect(rect)
if self.CGImage
if self.scale > 1.0
rect = CGRectMake(rect.origin.x * self.scale,
rect.origin.y * self.scale,
rect.size.width * self.scale,
rect.size.height * self.scale)
end
cgimage = CGImageCreateWithImageInRect(self.CGImage, rect)
return UIImage.imageWithCGImage(cgimage, scale:self.scale, orientation:self.imageOrientation)
else
return self.canvas(size: rect.size) do |context|
self.drawAtPoint(CGPoint.new(-rect.origin.x, -rect.origin.y))
end
end
end
##|
##| image scaling
##|
# This method is used to crop an image. Scale (retina or non-retina) is preserved.
#
# @param rect [CGRect] the portion of the image to return
# @return [UIImage]
def in_rect(rect)
imageRef = CGImageCreateWithImageInRect(self.CGImage, rect)
sub_image = UIImage.imageWithCGImage(imageRef, scale:self.scale, orientation:self.imageOrientation)
return sub_image
end
# Scales an image to fit within the given size, stretching one or both
# dimensions so that it completely fills the area. The current aspect ratio
# is maintained. If you want to place an image inside a container image, this
# is the method to use.
#
# You can specify a `position` property, which can be a symbol or a point. It
# specifies where you want the image located if it has to be cropped.
# Specifying the top-left corner will display the top-left corner of the
# image, likewise specifing the bottom-right corner will display *that*
# corner. If you want the image centered, you can use the 'position-less'
# version of this method (`scale_to_fit()`) or specify the point at the center
# of the image (`scale_to_fit(size, position:[w/2, h/2])`), or use a symbol
# (`scale_to_fit(size, position: :center)`).
#
# @param new_size [CGSize] Minimum dimensions of desired image. The returned image is
# guaranteed to fit within these dimensions.
# @param position [Symbol, CGPoint] Where to position the resized image. Valid symbols
# are: `[:top_left, :top, :top_right, :left, :center, :right, :bottom_left,
# :bottom, :bottom_right]` (if you forget the underscore, like
# `topleft`, that'll work, too)
# @param scale [Numeric] image scale
# @return [UIImage]
def scale_to_fill(new_size, options={})
new_size = SugarCube::CoreGraphics::Size(new_size)
position = options[:position] || :center
scale = options[:scale] || self.scale
my_size = self.size
if new_size.width == my_size.width && new_size.height == my_size.height && self.scale == scale
return self
end
# first, scale down; then we'll scale back up if we went too far
if my_size.width > new_size.width
my_size.height *= new_size.width / my_size.width
my_size.width = new_size.width
end
if my_size.height > new_size.height
my_size.width *= new_size.height / my_size.height
my_size.height = new_size.height
end
if my_size.width < new_size.width
my_size.height *= new_size.width / my_size.width
my_size.width = new_size.width
end
if my_size.height < new_size.height
my_size.width *= new_size.height / my_size.height
my_size.height = new_size.height
end
if self.size.width == my_size.width && self.size.height == my_size.height
return self
end
if position.is_a?(Symbol)
min_x = 0
min_y = 0
max_x = my_size.width
max_y = my_size.height
mid_x = max_x / 2
mid_y = max_y / 2
case position
when :top_left, :topleft, :tl
position = CGPoint.new(min_x, min_y)
when :top, :t
position = CGPoint.new(mid_x, min_y)
when :top_right, :topright, :tr
position = CGPoint.new(max_x, min_y)
when :left, :l
position = CGPoint.new(min_x, mid_x)
when :center, :c
position = CGPoint.new(mid_x, mid_x)
when :right, :r
position = CGPoint.new(max_x, mid_x)
when :bottom_left, :bottomleft, :bl
position = CGPoint.new(min_x, max_y)
when :bottom, :b
position = CGPoint.new(mid_x, max_y)
when :bottom_right, :bottomright, :br
position = CGPoint.new(max_x, max_y)
else
raise "Unknown position #{position.inspect}"
end
else
position = SugarCube::CoreGraphics::Point(position)
end
thumbnail_x = position.x * (new_size.width - my_size.width) / my_size.width
thumbnail_y = position.y * (new_size.height - my_size.height) / my_size.height
new_image = self.canvas(size: new_size) do
thumbnail_rect = CGRect.new([0, 0], [0, 0])
thumbnail_rect.origin = [thumbnail_x, thumbnail_y]
thumbnail_rect.size = my_size
self.drawInRect(thumbnail_rect)
end
raise "could not scale image" unless new_image
return new_image
end
# This method is similar to `scale_to`, except it doesn't pad the image, it
# just scales the image so that it will fit inside the new bounds.
def scale_within(new_size)
target_size = SugarCube::CoreGraphics::Size(new_size)
image_size = self.size
if CGSizeEqualToSize(target_size, self.size)
return self
end
width = image_size.width
height = image_size.height
target_width = target_size.width
target_height = target_size.height
width_factor = target_width / width
height_factor = target_height / height
if width_factor < height_factor
scale_factor = width_factor
else
scale_factor = height_factor
end
if scale_factor == 1
return self
end
scaled_size = CGSize.new(width * scale_factor, height * scale_factor)
return scale_to(scaled_size)
end
# Delegates to scale_to(background:), specifying background color of `nil`
def scale_to(new_size)
scale_to(new_size, background:nil)
end
# Scales an image to fit within the given size. Its current aspect ratio is
# maintained, but the image is padded so that it fills the entire area. If the
# image is too small, it will be scaled up to fit. If you specify a
# background that color will be used, otherwise the background will be
# transparent.
#
# @param new_size [CGSize] Maximum dimensions of desired image. The returned image is
# guaranteed to fit within these dimensions.
# @param background [UIColor] Color to fill padded areas. Default is transparent.
# @return [UIImage]
def scale_to(new_size, background:background)
new_size = SugarCube::CoreGraphics::Size(new_size)
image_size = self.size
if CGSizeEqualToSize(image_size, new_size)
return self
end
new_image = nil
width = image_size.width
height = image_size.height
target_width = new_size.width
target_height = new_size.height
scale_factor = 0.0
scaled_width = target_width
scaled_height = target_height
thumbnail_point = CGPoint.new(0.0, 0.0)
width_factor = target_width / width
height_factor = target_height / height
if width_factor < height_factor
scale_factor = width_factor
else
scale_factor = height_factor
end
scaled_width = width * scale_factor
scaled_height = height * scale_factor
# center the image
if width_factor < height_factor
thumbnail_point.y = (target_height - scaled_height) * 0.5
elsif width_factor > height_factor
thumbnail_point.x = (target_width - scaled_width) * 0.5
end
# this is actually the interesting part:
new_image = self.canvas(size: new_size) do |context|
if background
background = background.uicolor unless background.is_a?(UIColor)
background.setFill
CGContextAddRect(context, [[0, 0], new_size])
CGContextDrawPath(context, KCGPathFill)
end
thumbnail_rect = CGRect.new([0, 0], [0, 0])
thumbnail_rect.origin = thumbnail_point
thumbnail_rect.size.width = scaled_width
thumbnail_rect.size.height = scaled_height
self.drawInRect(thumbnail_rect)
end
raise "could not scale image" unless new_image
return new_image
end
##|
##| image modifications
##|
def rounded(corner_radius=5)
return self.canvas do
path = UIBezierPath.bezierPathWithRoundedRect([[0, 0], size], cornerRadius:corner_radius)
path.addClip
self.drawInRect([[0, 0], size])
end
end
# Returns a CIImage with the filter applied to the receiver. The return value
# is a CIImage object, which also defines `|` to work the same way, so filters
# can be chained.
#
# @example
# image = 'test'.uiimage
# new_image = image.apply_filter(CIFilter.gaussian_blur)
def apply_filter(filter)
filter.setValue(self.ciimage, forKey: 'inputImage')
return filter.valueForKey('outputImage')
end
# Returns a CGImageRef. Alias for `CGImage`.
def cgimage
return self.CGImage
end
# Returns a CIImage.
def ciimage
return CIImage.imageWithCGImage(self.CGImage)
end
# Accepts two options: brightness (default: 0.0) and saturation (default: 0.0)
# Returns a darkened version of the image.
def darken(options={})
filter_options = {
'inputSaturation' => options[:saturation] || 0,
'inputBrightness' => options[:brightness] || 0,
}
darken_filter = CIFilter.color_controls(filter_options)
output = self.apply_filter(darken_filter)
return UIImage.imageWithCIImage(output, scale:self.scale, orientation:self.imageOrientation)
end
# Invert the image
# @options - none
#
# @example
# image.inverted
#
# similar to (image | CIFilter.color_invert).uiimage
def inverted
output = self.apply_filter(CIFilter.color_invert)
return UIImage.imageWithCIImage(output, scale:self.scale, orientation:self.imageOrientation)
end
# Apply a gaussian filter
# @options radius, default: 10
#
# @example
# image.gaussian_blur(radius: 5)
# image.gaussian_blur(5) # :radius is the default option
def gaussian_blur(*args)
output = self.apply_filter(CIFilter.gaussian_blur(*args))
return UIImage.imageWithCIImage(output, scale:self.scale, orientation:self.imageOrientation)
end
# Apply a color overlay to the image (very practical with PNG button images)
#
# @example
# image.overlay(UIColor.redColor)
def overlay(color)
image_rect = CGRectMake(0, 0, self.size.width, self.size.height)
new_image = nil
UIImage.canvas(size: self.size, scale: self.scale) do |ctx|
self.drawInRect(image_rect)
CGContextSetFillColorWithColor(ctx, color.uicolor.CGColor)
CGContextSetAlpha(ctx, 1)
CGContextSetBlendMode(ctx, KCGBlendModeSourceAtop)
CGContextFillRect(ctx, image_rect)
image_ref = CGBitmapContextCreateImage(ctx)
new_image = UIImage.imageWithCGImage(image_ref, scale:self.scale, orientation:self.imageOrientation)
end
return new_image
end
##|
##| rotate images
##|
def rotate(angle_or_direction)
case angle_or_direction
when :left
radian = -90.degrees
when :right
radian = 90.degrees
when :flip
radian = 180.degrees
when Numeric
radian = angle_or_direction
else
raise "Unknown angle/direction #{angle_or_direction.inspect}"
end
w = (self.size.width * Math.cos(radian)).abs + (self.size.height * Math.sin(radian)).abs
h = (self.size.height * Math.cos(radian)).abs + (self.size.width * Math.sin(radian)).abs
new_size = CGSize.new(w, h)
new_size = self.size
return self.canvas(size: new_size) do |context|
# Move the origin to the middle of the image so we will rotate and scale around the center.
CGContextTranslateCTM(context, new_size.width / 2, new_size.height / 2)
# Rotate the image context
CGContextRotateCTM(context, radian)
# otherwise it'll be upside down:
CGContextScaleCTM(context, 1.0, -1.0)
# Now, draw the rotated/scaled image into the context
CGContextDrawImage(context, CGRectMake(-new_size.width / 2, -new_size.height / 2, new_size.width, new_size.height), self.CGImage)
end
end
##|
##| resizableImageWithCapInsets
##|
def tileable(insets=UIEdgeInsetsZero)
# not necessary, since we don't modify/examine the insets
# insets = SugarCube::CoreGraphics::EdgeInsets(insets)
resizableImageWithCapInsets(insets, resizingMode:UIImageResizingModeTile)
end
def stretchable(insets=UIEdgeInsetsZero)
# not necessary, since we don't modify/examine the insets
# insets = SugarCube::CoreGraphics::EdgeInsets(insets)
resizableImageWithCapInsets(insets, resizingMode:UIImageResizingModeStretch)
end
##|
##| imageWithAlignmentRectInsets
##|
def alignment_rect(insets=UIEdgeInsetsZero)
imageWithAlignmentRectInsets(insets)
end
##|
##| CGImageCreateWithMask
##|
# The mask image cannot have ANY transparency. Instead, transparent areas must
# be white or some value between black and white. The more white a pixel is
# the more transparent it becomes.
# black .. white
# opaque .. transparent
def masked(mask_image)
mask_image = mask_image.CGImage
width = CGImageGetWidth(mask_image)
height = CGImageGetHeight(mask_image)
component_bits = CGImageGetBitsPerComponent(mask_image)
pixel_bits = CGImageGetBitsPerPixel(mask_image)
row_bytes = CGImageGetBytesPerRow(mask_image)
data_provider = CGImageGetDataProvider(mask_image)
mask = CGImageMaskCreate(width, height, component_bits,
pixel_bits, row_bytes, data_provider,nil, false)
masked = CGImageCreateWithMask(self.CGImage, mask)
UIImage.imageWithCGImage(masked, scale:self.scale, orientation:self.imageOrientation)
end
# Oddly enough, this method doesn't seem to have retina support
def color_at(point)
point = SugarCube::CoreGraphics::Point(point)
point.x *= self.scale
point.y *= self.scale
# First get the image into your data buffer
cgimage = self.CGImage
width = CGImageGetWidth(cgimage)
height = CGImageGetHeight(cgimage)
bytes_per_pixel = 4
bits_per_component = 8
bytes_per_row = bytes_per_pixel * width
@raw_data || begin
color_space = CGColorSpaceCreateDeviceRGB()
@raw_data = Pointer.new(:uchar, height * width * 4)
context = CGBitmapContextCreate(@raw_data, width, height, bits_per_component, bytes_per_row, color_space, KCGImageAlphaPremultipliedLast | KCGBitmapByteOrder32Big)
CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgimage)
end
# Now @raw_data contains the image data in the RGBA8888 pixel format.
xx = point.x.round
yy = point.y.round
byte_index = (bytes_per_row * yy) + xx * bytes_per_pixel
red = @raw_data[byte_index]
green = @raw_data[byte_index + 1]
blue = @raw_data[byte_index + 2]
alpha = @raw_data[byte_index + 3]
return [red, green, blue].uicolor(alpha / 255.0)
end
def avg_color
colorSpace = CGColorSpaceCreateDeviceRGB()
rgba = Pointer.new(:uchar, 4)
context = CGBitmapContextCreate(rgba, 1, 1, 8, 4, colorSpace, KCGImageAlphaPremultipliedLast | KCGBitmapByteOrder32Big)
CGContextDrawImage(context, CGRectMake(0, 0, 1, 1), self.CGImage)
if rgba[3] > 0
alpha = rgba[3] / 255.0
multiplier = alpha / 255.0
return UIColor.colorWithRed(rgba[0] * multiplier,
green:rgba[1] * multiplier,
blue:rgba[2] * multiplier,
alpha:alpha)
else
return UIColor.colorWithRed(rgba[0] / 255.0,
green:rgba[1] / 255.0,
blue:rgba[2] / 255.0,
alpha:rgba[3] / 255.0)
end
end
def at_scale(scale)
if scale == self.scale
return self
end
new_size = self.size
new_size.width = new_size.width * self.scale / scale
new_size.height = new_size.height * self.scale / scale
return self.canvas(size: new_size, scale: scale) do
thumbnail_rect = CGRect.new([0, 0], new_size)
self.drawInRect(thumbnail_rect)
end
end
# Using the image as the background, you can use this method to draw anything
# on top, like text or other images.
def draw(options={}, &block)
at = options[:at] || [0, 0]
return self.canvas(options) do |context|
self.drawAtPoint(at)
block.call(context) if block
end
end
# the first argument can be a size, or an options dict
def canvas(options_or_size={}, more_options={}, &block)
if options_or_size.is_a?(NSDictionary)
options = options_or_size
else
options = more_options
options[:size] = options_or_size
end
unless options[:size]
options[:size] = self.size
end
unless options[:scale]
options[:scale] = self.scale
end
self.class.canvas(options) do |context|
block.call(context) if block
end
end
end