Class: CIFilter

Inherits:
Object show all
Defined in:
lib/sugarcube-image/cifilter.rb

Overview

The following filters are available in iOS:

  • CIAdditionCompositing * CIExposureAdjust * CIPerspectiveTile
  • CIAffineClamp * CIFalseColor * CIPerspectiveTransform
  • CIAffineTile * CIFlashTransition * CIPerspectiveTransformWithExtent
  • CIAffineTransform * CIFourfoldReflectedTile * CIPinchDistortion
  • CIBarsSwipeTransition * CIFourfoldRotatedTile * CIPixellate
  • CIBlendWithMask * CIFourfoldTranslatedTile * CIRadialGradient
  • CIBloom * CIGammaAdjust * CIFilter
  • CIBumpDistortion * CIGaussianBlur * CISaturationBlendMode
  • CIBumpDistortionLinear * CIGaussianGradient * CIScreenBlendMode
  • CICheckerboardGenerator * CIGlideReflectedTile * CISepiaTone
  • CICircleSplashDistortion * CIGloom * CISharpenLuminance
  • CICircularScreen * CIHardLightBlendMode * CISixfoldReflectedTile
  • CIColorBlendMode * CIHatchedScreen * CISixfoldRotatedTile
  • CIColorBurnBlendMode * CIHighlightShadowAdjust * CISoftLightBlendMode
  • CIColorControls * CIHoleDistortion * CISourceAtopCompositing
  • CIColorCube * CIHueAdjust * CISourceInCompositing
  • CIColorDodgeBlendMode * CIHueBlendMode * CISourceOutCompositing
  • CIFilter * CILanczosScaleTransform * CISourceOverCompositing
  • CIColorMap * CILightenBlendMode * CIStarShineGenerator
  • CIColorMatrix * CILightTunnel * CIStraightenFilter
  • CIColorMonochrome * CILinearGradient * CIStripesGenerator
  • CIColorPosterize * CILineScreen * CISwipeTransition
  • CIConstantColorGenerator * CILuminosityBlendMode * CITemperatureAndTint
  • CICopyMachineTransition * CIFilter * CIToneCurve
  • CICrop * CIFilter * CITriangleKaleidoscope
  • CIDarkenBlendMode * CIMaximumCompositing * CITwelvefoldReflectedTile
  • CIDifferenceBlendMode * CIFilter * CITwirlDistortion
  • CIDisintegrateWithMaskTransition * CIMinimumCompositing * CIUnsharpMask
  • CIDissolveTransition * CIModTransition * CIVibrance
  • CIDotScreen * CIMultiplyBlendMode * CIVignette
  • CIEightfoldReflectedTile * CIMultiplyCompositing * CIVortexDistortion
  • CIExclusionBlendMode * CIOverlayBlendMode * CIWhitePointAdjust

The following filters have not been added to iOS: (as of 6/19/2013)

  • CIAreaAverage * CIHexagonalPixellate
  • CIAreaHistogram * CIKaleidoscope
  • CIAreaMaximum * CILenticularHaloGenerator
  • CIAreaMaximumAlpha * CILineOverlay
  • CIAreaMinimum * CIMedianFilter
  • CIAreaMinimumAlpha * CIMotionBlur
  • CIBoxBlur * CINoiseReduction
  • CICircularWrap * CIOpTile
  • CICMYKHalftone * CIPageCurlTransition
  • CIColumnAverage * CIParallelogramTile
  • CIComicEffect * CIPointillize
  • CICrystallize * CIRippleTransition
  • CIDepthOfField * CIRowAverage
  • CIDiscBlur * CIShadedMaterial
  • CIDisplacementDistortion * CISpotColor
  • CIDroste * CISpotLight
  • CIEdges * CIStretchCrop
  • CIEdgeWork * CISunbeamsGenerator
  • CIGlassDistortion * CITorusLensDistortion
  • CIGlassLozenge * CITriangleTile
  • CIHeightFieldFromMask * CIZoomBlur

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

._create_filter(filter_name, args, set_args = [], names = {}) ⇒ Object

This helper instantiates the filter (raising an exception if it was unsuccessful) and applies all the arguments from options (naming the args according to set_args), translating names from names



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/sugarcube-image/cifilter.rb', line 83

def _create_filter(filter_name, args, set_args=[], names={})
  filter = CIFilter.filterWithName(filter_name)
  raise "Unsupported filter #{filter_name.inspect}" unless filter

  # turn a list of arguments into a hash
  if args.length == 1 && Hash === args[0]
    options = args[0]
  else
    options = {}
    args.each_with_index do |arg, index|
      setter = set_args[index]
      raise "Cannot set option ##{index}" if setter.nil?
      options[setter] = arg
    end
  end

  options.each do |key, value|
    # translate the keys, but if there is no translation key then do nothing
    key = names[key] || key.to_s

    # translate the value if a block was given for that. `key` is always going
    # to be the CIImage key (not the alias, e.g. :radius => 'inputRadius')
    value = yield(key, value) if block_given?
    filter.setValue(value, forKey:key)
  end
  return filter
end

.addition_compositing(*options) ⇒ Object

CIAdditionCompositing



112
113
114
 
# File 'lib/sugarcube-image/cifilter.rb', line 112

def addition_compositing(*options)
  return _create_filter('CIAdditionCompositing', options, [:background], background: 'inputBackgroundImage')
end

.affine_clamp(*options) ⇒ Object

CIAffineClamp



117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/sugarcube-image/cifilter.rb', line 117

def affine_clamp(*options)
  return _create_filter('CIAffineClamp', options, [:transform], transform: 'inputTransform'
    ) do |key, value|
    if key == 'inputTransform' && CGAffineTransform === value
      ptr = Pointer.new(:id)
      ptr[0] = value
      NSValue.valueWithBytes(ptr, objCType:CGAffineTransform.type)
    else
      value
    end
  end
end

.affine_tile(*options) ⇒ Object

CIAffineTile



131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/sugarcube-image/cifilter.rb', line 131

def affine_tile(*options)
  return _create_filter('CIAffineTile', options, [:transform], transform: 'inputTransform'
    ) do |key, value|
    if key == 'inputTransform' && CGAffineTransform === value
      ptr = Pointer.new(:id)
      ptr[0] = value
      NSValue.valueWithBytes(ptr, objCType:CGAffineTransform.type)
    else
      value
    end
  end
end

.affine_transform(*options) ⇒ Object

CIAffineTransform



145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/sugarcube-image/cifilter.rb', line 145

def affine_transform(*options)
  return _create_filter('CIAffineTransform', options, [:transform], transform: 'inputTransform'
    ) do |key, value|
    if key == 'inputTransform' && CGAffineTransform === value
      ptr = Pointer.new(:id)
      ptr[0] = value
      NSValue.valueWithBytes(ptr, objCType:CGAffineTransform.type)
    else
      value
    end
  end
end

.bars_swipe_transition(*options) ⇒ Object

CIBarsSwipeTransition



159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/sugarcube-image/cifilter.rb', line 159

def bars_swipe_transition(*options)
  return _create_filter('CIBarsSwipeTransition', options, [:target, :time],
    target: 'inputTargetImage', angle: 'inputAngle', width: 'inputWidth',
    offset: 'inputBarOffset', time: 'inputTime'
    ) do |key, value|
    if key == 'inputTargetImage'
      value.ciimage
    else
      value
    end
  end
end

.blend_with_mask(*options) ⇒ Object

CIBlendWithMask



173
174
175
176
177
178
 
# File 'lib/sugarcube-image/cifilter.rb', line 173

def blend_with_mask(*options)
  return _create_filter('CIBlendWithMask', options, [:background, :mask], background: 'inputBackgroundImage', mask: 'inputMaskImage'
    ) do |key, value|
    value.ciimage
  end
end

.bloom(*options) ⇒ Object

CIBloom



181
182
183
 
# File 'lib/sugarcube-image/cifilter.rb', line 181

def bloom(*options)
  return _create_filter('CIBloom', options, [:radius, :intensity], radius: 'inputRadius', intensity: 'inputIntensity')
end

.bump_distortion(*options) ⇒ Object

CIBumpDistortion PENDING



187
188
189
 
# File 'lib/sugarcube-image/cifilter.rb', line 187

def bump_distortion(*options)
  return _create_filter('CIBumpDistortion', options)
end

.bump_distortion_linear(*options) ⇒ Object

CIBumpDistortionLinear PENDING



193
194
195
 
# File 'lib/sugarcube-image/cifilter.rb', line 193

def bump_distortion_linear(*options)
  return _create_filter('CIBumpDistortionLinear', options)
end

.checkerboard_generator(*options) ⇒ Object

CICheckerboardGenerator



198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/sugarcube-image/cifilter.rb', line 198

def checkerboard_generator(*options)
  return _create_filter('CICheckerboardGenerator', options, [:width, :color0, :color1],
    width: 'inputWidth', color0: 'inputColor0', color1: 'inputColor1', sharpness: 'inputSharpness'
    ) do |key, value|
    if key == 'inputColor0' || key == 'inputColor1'
      value.cicolor
    else
      value
    end
  end
end

.circle_splash_distortion(*options) ⇒ Object

CICircleSplashDistortion



211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/sugarcube-image/cifilter.rb', line 211

def circle_splash_distortion(*options)
  return _create_filter('CICircleSplashDistortion', options, [:radius, :center],
    radius: 'inputRadius', center: 'inputCenter'
    ) do |key, value|
    if key == 'inputCenter' && ! CIVector === value
      CIVector.vectorWithX(value[0], Y: value[1])
    else
      value
    end
  end
end

.circular_screen(*options) ⇒ Object

CICircularScreen PENDING



225
226
227
 
# File 'lib/sugarcube-image/cifilter.rb', line 225

def circular_screen(*options)
  return _create_filter('CICircularScreen', options)
end

.color_blend_mode(*options) ⇒ Object

CIColorBlendMode



230
231
232
233
234
235
 
# File 'lib/sugarcube-image/cifilter.rb', line 230

def color_blend_mode(*options)
  return _create_filter('CIColorBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.color_burn_blend_mode(*options) ⇒ Object

CIColorBurnBlendMode



238
239
240
241
242
243
 
# File 'lib/sugarcube-image/cifilter.rb', line 238

def color_burn_blend_mode(*options)
  return _create_filter('CIColorBurnBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.color_controls(*options) ⇒ Object

CIColorControls



246
247
248
249
 
# File 'lib/sugarcube-image/cifilter.rb', line 246

def color_controls(*options)
  return _create_filter('CIColorControls', options, [:saturation, :brightness, :contrast],
    saturation: 'inputSaturation', brightness: 'inputBrightness', contrast: 'inputContrast')
end

.color_cube(*options) ⇒ Object

CIColorCube PENDING



253
254
255
 
# File 'lib/sugarcube-image/cifilter.rb', line 253

def color_cube(*options)
  return _create_filter('CIColorCube', options)
end

.color_dodge_blend_mode(*options) ⇒ Object

CIColorDodgeBlendMode



258
259
260
261
262
263
 
# File 'lib/sugarcube-image/cifilter.rb', line 258

def color_dodge_blend_mode(*options)
  return _create_filter('CIColorDodgeBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.color_invert ⇒ Object

CIColorInvert



266
267
268
 
# File 'lib/sugarcube-image/cifilter.rb', line 266

def color_invert()
  return CIFilter.filterWithName('CIColorInvert')
end

.color_map(*options) ⇒ Object

CIColorMap



271
272
273
274
275
276
 
# File 'lib/sugarcube-image/cifilter.rb', line 271

def color_map(*options)
  return _create_filter('CIColorMap', options, [:gradient], gradient: 'inputGradientImage'
    ) do |key, value|
    value.ciimage
  end
end

.color_matrix(*options) ⇒ Object

CIColorMatrix PENDING



280
281
282
 
# File 'lib/sugarcube-image/cifilter.rb', line 280

def color_matrix(*options)
  return _create_filter('CIColorMatrix', options)
end

.color_monochrome(*options) ⇒ Object

CIColorMonochrome PENDING



286
287
288
 
# File 'lib/sugarcube-image/cifilter.rb', line 286

def color_monochrome(*options)
  return _create_filter('CIColorMonochrome', options)
end

.color_posterize(*options) ⇒ Object

CIColorPosterize



291
292
293
 
# File 'lib/sugarcube-image/cifilter.rb', line 291

def color_posterize(*options)
  return _create_filter('CIColorPosterize', options, [:levels], levels: 'inputLevels')
end

.constant_color_generator(*options) ⇒ Object

CIConstantColorGenerator



296
297
298
299
300
301
 
# File 'lib/sugarcube-image/cifilter.rb', line 296

def constant_color_generator(*options)
  return _create_filter('CIConstantColorGenerator', options, [:color], color: 'inputColor'
    ) do |key, value|
    value.cicolor
  end
end

.copy_machine_transition(*options) ⇒ Object

CICopyMachineTransition PENDING



305
306
307
 
# File 'lib/sugarcube-image/cifilter.rb', line 305

def copy_machine_transition(*options)
  return _create_filter('CICopyMachineTransition', options)
end

.crop(*options) ⇒ Object

CICrop



310
311
312
313
314
315
316
317
318
 
# File 'lib/sugarcube-image/cifilter.rb', line 310

def crop(*options)
  return _create_filter('CICrop', options, [:rectangle], rectangle: 'inputRectangle') do |key, value|
    rect = SugarCube::CoreGraphics::Rect(value)
    CIVector.alloc.initWithX( rect.origin.x,
                           Y: rect.origin.y,
                           Z: rect.size.width,
                           W: rect.size.height)
  end
end

.darken_blend_mode(*options) ⇒ Object

CIDarkenBlendMode



321
322
323
324
325
326
 
# File 'lib/sugarcube-image/cifilter.rb', line 321

def darken_blend_mode(*options)
  return _create_filter('CIDarkenBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.difference_blend_mode(*options) ⇒ Object

CIDifferenceBlendMode



329
330
331
332
333
334
 
# File 'lib/sugarcube-image/cifilter.rb', line 329

def difference_blend_mode(*options)
  return _create_filter('CIDifferenceBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.disintegrate_with_mask_transition(*options) ⇒ Object

CIDisintegrateWithMaskTransition PENDING



338
339
340
 
# File 'lib/sugarcube-image/cifilter.rb', line 338

def disintegrate_with_mask_transition(*options)
  return _create_filter('CIDisintegrateWithMaskTransition', options)
end

.dissolve_transition(*options) ⇒ Object

CIDissolveTransition PENDING



344
345
346
 
# File 'lib/sugarcube-image/cifilter.rb', line 344

def dissolve_transition(*options)
  return _create_filter('CIDissolveTransition', options)
end

.dot_screen(*options) ⇒ Object

CIDotScreen PENDING



350
351
352
 
# File 'lib/sugarcube-image/cifilter.rb', line 350

def dot_screen(*options)
  return _create_filter('CIDotScreen', options)
end

.eightfold_reflected_tile(*options) ⇒ Object

CIEightfoldReflectedTile PENDING



356
357
358
 
# File 'lib/sugarcube-image/cifilter.rb', line 356

def eightfold_reflected_tile(*options)
  return _create_filter('CIEightfoldReflectedTile', options)
end

.exclusion_blend_mode(*options) ⇒ Object

CIExclusionBlendMode



361
362
363
364
365
366
 
# File 'lib/sugarcube-image/cifilter.rb', line 361

def exclusion_blend_mode(*options)
  return _create_filter('CIExclusionBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.exposure_adjust(*options) ⇒ Object

CIExposureAdjust



369
370
371
 
# File 'lib/sugarcube-image/cifilter.rb', line 369

def exposure_adjust(*options)
  return _create_filter('CIExposureAdjust', options, [:ev], ev: 'inputEV')
end

.false_color(*options) ⇒ Object

CIFalseColor



374
375
376
377
378
379
 
# File 'lib/sugarcube-image/cifilter.rb', line 374

def false_color(*options)
  return _create_filter('CIFalseColor', options, [:color0, :color1], color0: 'inputColor0', color1: 'inputColor1'
    ) do |key, value|
    value.cicolor
  end
end

.flash_transition(*options) ⇒ Object

CIFlashTransition PENDING



383
384
385
 
# File 'lib/sugarcube-image/cifilter.rb', line 383

def flash_transition(*options)
  return _create_filter('CIFlashTransition', options)
end

.fourfold_reflected_tile(*options) ⇒ Object

CIFourfoldReflectedTile PENDING



389
390
391
 
# File 'lib/sugarcube-image/cifilter.rb', line 389

def fourfold_reflected_tile(*options)
  return _create_filter('CIFourfoldReflectedTile', options)
end

.fourfold_rotated_tile(*options) ⇒ Object

CIFourfoldRotatedTile PENDING



395
396
397
 
# File 'lib/sugarcube-image/cifilter.rb', line 395

def fourfold_rotated_tile(*options)
  return _create_filter('CIFourfoldRotatedTile', options)
end

.fourfold_translated_tile(*options) ⇒ Object

CIFourfoldTranslatedTile PENDING



401
402
403
 
# File 'lib/sugarcube-image/cifilter.rb', line 401

def fourfold_translated_tile(*options)
  return _create_filter('CIFourfoldTranslatedTile', options)
end

.gamma_adjust(*options) ⇒ Object

CIGammaAdjust



406
407
408
 
# File 'lib/sugarcube-image/cifilter.rb', line 406

def gamma_adjust(*options)
  return _create_filter('CIGammaAdjust', options, [:power], power: 'inputPower')
end

.gaussian_blur(*options) ⇒ Object

CIGaussianBlur



411
412
413
 
# File 'lib/sugarcube-image/cifilter.rb', line 411

def gaussian_blur(*options)
  return _create_filter('CIGaussianBlur', options, [:radius], radius: 'inputRadius')
end

.gaussian_gradient(*options) ⇒ Object

CIGaussianGradient PENDING



417
418
419
 
# File 'lib/sugarcube-image/cifilter.rb', line 417

def gaussian_gradient(*options)
  return _create_filter('CIGaussianGradient', options)
end

.glide_reflected_tile(*options) ⇒ Object

CIGlideReflectedTile PENDING



423
424
425
 
# File 'lib/sugarcube-image/cifilter.rb', line 423

def glide_reflected_tile(*options)
  return _create_filter('CIGlideReflectedTile', options)
end

.gloom(*options) ⇒ Object

CIGloom



428
429
430
 
# File 'lib/sugarcube-image/cifilter.rb', line 428

def gloom(*options)
  return _create_filter('CIGloom', options, [:intensity, :radius], intensity: 'inputIntensity', radius: 'inputRadius')
end

.hard_light_blend_mode(*options) ⇒ Object

CIHardLightBlendMode



433
434
435
436
437
438
 
# File 'lib/sugarcube-image/cifilter.rb', line 433

def hard_light_blend_mode(*options)
  return _create_filter('CIHardLightBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.hatched_screen(*options) ⇒ Object

CIHatchedScreen PENDING



442
443
444
 
# File 'lib/sugarcube-image/cifilter.rb', line 442

def hatched_screen(*options)
  return _create_filter('CIHatchedScreen', options)
end

.highlight_shadow_adjust(*options) ⇒ Object

CIHighlightShadowAdjust



447
448
449
 
# File 'lib/sugarcube-image/cifilter.rb', line 447

def highlight_shadow_adjust(*options)
  return _create_filter('CIHighlightShadowAdjust', options, [:highlight, :shadow], highlight: 'inputHighlightAmount', shadow: 'inputShadowAmount')
end

.hole_distortion(*options) ⇒ Object

CIHoleDistortion PENDING



453
454
455
 
# File 'lib/sugarcube-image/cifilter.rb', line 453

def hole_distortion(*options)
  return _create_filter('CIHoleDistortion', options)
end

.hue_adjust(*options) ⇒ Object

CIHueAdjust



458
459
460
 
# File 'lib/sugarcube-image/cifilter.rb', line 458

def hue_adjust(*options)
  return _create_filter('CIHueAdjust', options, [:angle], angle: 'inputAngle')
end

.hue_blend_mode(*options) ⇒ Object

CIHueBlendMode



463
464
465
466
467
468
 
# File 'lib/sugarcube-image/cifilter.rb', line 463

def hue_blend_mode(*options)
  return _create_filter('CIHueBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.lanczos_scale_transform(*options) ⇒ Object

CILanczosScaleTransform



471
472
473
 
# File 'lib/sugarcube-image/cifilter.rb', line 471

def lanczos_scale_transform(*options)
  return _create_filter('CILanczosScaleTransform', options, [:scale, :aspect_ratio], scale: 'inputScale', aspect_ratio: 'inputAspectRatio')
end

.light_tunnel(*options) ⇒ Object

CILightTunnel PENDING



485
486
487
 
# File 'lib/sugarcube-image/cifilter.rb', line 485

def light_tunnel(*options)
  return _create_filter('CILightTunnel', options)
end

.lighten_blend_mode(*options) ⇒ Object

CILightenBlendMode



476
477
478
479
480
481
 
# File 'lib/sugarcube-image/cifilter.rb', line 476

def lighten_blend_mode(*options)
  return _create_filter('CILightenBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.line_screen(*options) ⇒ Object

CILineScreen PENDING



497
498
499
 
# File 'lib/sugarcube-image/cifilter.rb', line 497

def line_screen(*options)
  return _create_filter('CILineScreen', options)
end

.linear_gradient(*options) ⇒ Object

CILinearGradient PENDING



491
492
493
 
# File 'lib/sugarcube-image/cifilter.rb', line 491

def linear_gradient(*options)
  return _create_filter('CILinearGradient', options)
end

.luminosity_blend_mode(*options) ⇒ Object

CILuminosityBlendMode



502
503
504
505
506
507
 
# File 'lib/sugarcube-image/cifilter.rb', line 502

def luminosity_blend_mode(*options)
  return _create_filter('CILuminosityBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.mask_to_alpha ⇒ Object

CIMaskToAlpha



510
511
512
 
# File 'lib/sugarcube-image/cifilter.rb', line 510

def mask_to_alpha()
  return CIFilter.filterWithName('CIMaskToAlpha')
end

.maximum_component ⇒ Object

CIMaximumComponent



515
516
517
 
# File 'lib/sugarcube-image/cifilter.rb', line 515

def maximum_component()
  return CIFilter.filterWithName('CIMaximumComponent')
end

.maximum_compositing(*options) ⇒ Object

CIMaximumCompositing



520
521
522
523
524
525
 
# File 'lib/sugarcube-image/cifilter.rb', line 520

def maximum_compositing(*options)
  return _create_filter('CIMaximumCompositing', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.minimum_component ⇒ Object

CIMinimumComponent



528
529
530
 
# File 'lib/sugarcube-image/cifilter.rb', line 528

def minimum_component()
  return CIFilter.filterWithName('CIMinimumComponent')
end

.minimum_compositing(*options) ⇒ Object

CIMinimumCompositing



533
534
535
536
537
538
 
# File 'lib/sugarcube-image/cifilter.rb', line 533

def minimum_compositing(*options)
  return _create_filter('CIMinimumCompositing', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.mod_transition(*options) ⇒ Object

CIModTransition PENDING



542
543
544
 
# File 'lib/sugarcube-image/cifilter.rb', line 542

def mod_transition(*options)
  return _create_filter('CIModTransition', options)
end

.multiply_blend_mode(*options) ⇒ Object

CIMultiplyBlendMode



547
548
549
550
551
552
 
# File 'lib/sugarcube-image/cifilter.rb', line 547

def multiply_blend_mode(*options)
  return _create_filter('CIMultiplyBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.multiply_compositing(*options) ⇒ Object

CIMultiplyCompositing



555
556
557
558
559
560
 
# File 'lib/sugarcube-image/cifilter.rb', line 555

def multiply_compositing(*options)
  return _create_filter('CIMultiplyCompositing', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.overlay_blend_mode(*options) ⇒ Object

CIOverlayBlendMode



563
564
565
566
567
568
 
# File 'lib/sugarcube-image/cifilter.rb', line 563

def overlay_blend_mode(*options)
  return _create_filter('CIOverlayBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.perspective_tile(*options) ⇒ Object

CIPerspectiveTile PENDING



572
573
574
 
# File 'lib/sugarcube-image/cifilter.rb', line 572

def perspective_tile(*options)
  return _create_filter('CIPerspectiveTile', options)
end

.perspective_transform(*options) ⇒ Object

CIPerspectiveTransform PENDING



578
579
580
 
# File 'lib/sugarcube-image/cifilter.rb', line 578

def perspective_transform(*options)
  return _create_filter('CIPerspectiveTransform', options)
end

.perspective_transform_with_extent(*options) ⇒ Object

CIPerspectiveTransformWithExtent PENDING



584
585
586
 
# File 'lib/sugarcube-image/cifilter.rb', line 584

def perspective_transform_with_extent(*options)
  return _create_filter('CIPerspectiveTransformWithExtent', options)
end

.pinch_distortion(*options) ⇒ Object

CIPinchDistortion PENDING



590
591
592
 
# File 'lib/sugarcube-image/cifilter.rb', line 590

def pinch_distortion(*options)
  return _create_filter('CIPinchDistortion', options)
end

.pixellate(*options) ⇒ Object

CIPixellate PENDING



596
597
598
 
# File 'lib/sugarcube-image/cifilter.rb', line 596

def pixellate(*options)
  return _create_filter('CIPixellate', options)
end

.radial_gradient(*options) ⇒ Object

CIRadialGradient PENDING



602
603
604
 
# File 'lib/sugarcube-image/cifilter.rb', line 602

def radial_gradient(*options)
  return _create_filter('CIRadialGradient', options)
end

.random_generator ⇒ Object

CIRandomGenerator



607
608
609
 
# File 'lib/sugarcube-image/cifilter.rb', line 607

def random_generator()
  return CIFilter.filterWithName('CIRandomGenerator')
end

.saturation_blend_mode(*options) ⇒ Object

CISaturationBlendMode



612
613
614
615
616
617
 
# File 'lib/sugarcube-image/cifilter.rb', line 612

def saturation_blend_mode(*options)
  return _create_filter('CISaturationBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.screen_blend_mode(*options) ⇒ Object

CIScreenBlendMode



620
621
622
623
624
625
 
# File 'lib/sugarcube-image/cifilter.rb', line 620

def screen_blend_mode(*options)
  return _create_filter('CIScreenBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.sepia_tone(*options) ⇒ Object

CISepiaTone



628
629
630
 
# File 'lib/sugarcube-image/cifilter.rb', line 628

def sepia_tone(*options)
  return _create_filter('CISepiaTone', options, [:intensity], intensity: 'inputIntensity')
end

.sharpen_luminance(*options) ⇒ Object

CISharpenLuminance



633
634
635
 
# File 'lib/sugarcube-image/cifilter.rb', line 633

def sharpen_luminance(*options)
  return _create_filter('CISharpenLuminance', options, [:sharpness], sharpness: 'inputSharpness')
end

.sixfold_reflected_tile(*options) ⇒ Object

CISixfoldReflectedTile PENDING



639
640
641
 
# File 'lib/sugarcube-image/cifilter.rb', line 639

def sixfold_reflected_tile(*options)
  return _create_filter('CISixfoldReflectedTile', options)
end

.sixfold_rotated_tile(*options) ⇒ Object

CISixfoldRotatedTile PENDING



645
646
647
 
# File 'lib/sugarcube-image/cifilter.rb', line 645

def sixfold_rotated_tile(*options)
  return _create_filter('CISixfoldRotatedTile', options)
end

.soft_light_blend_mode(*options) ⇒ Object

CISoftLightBlendMode



650
651
652
653
654
655
 
# File 'lib/sugarcube-image/cifilter.rb', line 650

def soft_light_blend_mode(*options)
  return _create_filter('CISoftLightBlendMode', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.source_atop_compositing(*options) ⇒ Object

CISourceAtopCompositing



658
659
660
661
662
663
 
# File 'lib/sugarcube-image/cifilter.rb', line 658

def source_atop_compositing(*options)
  return _create_filter('CISourceAtopCompositing', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.source_in_compositing(*options) ⇒ Object

CISourceInCompositing



666
667
668
669
670
671
 
# File 'lib/sugarcube-image/cifilter.rb', line 666

def source_in_compositing(*options)
  return _create_filter('CISourceInCompositing', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.source_out_compositing(*options) ⇒ Object

CISourceOutCompositing



674
675
676
677
678
679
 
# File 'lib/sugarcube-image/cifilter.rb', line 674

def source_out_compositing(*options)
  return _create_filter('CISourceOutCompositing', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.source_over_compositing(*options) ⇒ Object

CISourceOverCompositing



682
683
684
685
686
687
 
# File 'lib/sugarcube-image/cifilter.rb', line 682

def source_over_compositing(*options)
  return _create_filter('CISourceOverCompositing', options, [:background], background: 'inputBackgroundImage'
    ) do |key, value|
    value.ciimage
  end
end

.star_shine_generator(*options) ⇒ Object

CIStarShineGenerator PENDING



691
692
693
 
# File 'lib/sugarcube-image/cifilter.rb', line 691

def star_shine_generator(*options)
  return _create_filter('CIStarShineGenerator', options)
end

.straighten_filter(*options) ⇒ Object

CIStraightenFilter



696
697
698
 
# File 'lib/sugarcube-image/cifilter.rb', line 696

def straighten_filter(*options)
  return _create_filter('CIStraightenFilter', options, [:angle], angle: 'inputAngle')
end

.stripes_generator(*options) ⇒ Object

CIStripesGenerator PENDING



702
703
704
 
# File 'lib/sugarcube-image/cifilter.rb', line 702

def stripes_generator(*options)
  return _create_filter('CIStripesGenerator', options)
end

.swipe_transition(*options) ⇒ Object

CISwipeTransition PENDING



708
709
710
 
# File 'lib/sugarcube-image/cifilter.rb', line 708

def swipe_transition(*options)
  return _create_filter('CISwipeTransition', options)
end

.temperature_and_tint(*options) ⇒ Object

CITemperatureAndTint PENDING



714
715
716
 
# File 'lib/sugarcube-image/cifilter.rb', line 714

def temperature_and_tint(*options)
  return _create_filter('CITemperatureAndTint', options)
end

.tone_curve(*options) ⇒ Object

CIToneCurve PENDING



720
721
722
 
# File 'lib/sugarcube-image/cifilter.rb', line 720

def tone_curve(*options)
  return _create_filter('CIToneCurve', options)
end

.triangle_kaleidoscope(*options) ⇒ Object

CITriangleKaleidoscope PENDING



726
727
728
 
# File 'lib/sugarcube-image/cifilter.rb', line 726

def triangle_kaleidoscope(*options)
  return _create_filter('CITriangleKaleidoscope', options)
end

.twelvefold_reflected_tile(*options) ⇒ Object

CITwelvefoldReflectedTile PENDING



732
733
734
 
# File 'lib/sugarcube-image/cifilter.rb', line 732

def twelvefold_reflected_tile(*options)
  return _create_filter('CITwelvefoldReflectedTile', options)
end

.twirl_distortion(*options) ⇒ Object

CITwirlDistortion PENDING



738
739
740
 
# File 'lib/sugarcube-image/cifilter.rb', line 738

def twirl_distortion(*options)
  return _create_filter('CITwirlDistortion', options)
end

.unsharp_mask(*options) ⇒ Object

CIUnsharpMask



743
744
745
 
# File 'lib/sugarcube-image/cifilter.rb', line 743

def unsharp_mask(*options)
  return _create_filter('CIUnsharpMask', options, [:intensity, :radius], intensity: 'inputIntensity', radius: 'inputRadius')
end

.vibrance(*options) ⇒ Object

CIVibrance



748
749
750
 
# File 'lib/sugarcube-image/cifilter.rb', line 748

def vibrance(*options)
  return _create_filter('CIVibrance', options, [:amount], amount: 'inputAmount')
end

.vignette(*options) ⇒ Object

CIVignette



753
754
755
 
# File 'lib/sugarcube-image/cifilter.rb', line 753

def vignette(*options)
  return _create_filter('CIVignette', options, [:radius, :intensity], radius: 'inputRadius', intensity: 'inputIntensity')
end

.vortex_distortion(*options) ⇒ Object

CIVortexDistortion PENDING



759
760
761
 
# File 'lib/sugarcube-image/cifilter.rb', line 759

def vortex_distortion(*options)
  return _create_filter('CIVortexDistortion', options)
end

.white_point_adjust(*options) ⇒ Object

CIWhitePointAdjust



764
765
766
767
768
 
# File 'lib/sugarcube-image/cifilter.rb', line 764

def white_point_adjust(*options)
  return _create_filter('CIWhitePointAdjust', options, [:color], color: 'inputColor') do |key, value|
    value.cicolor
  end
end

Instance Method Details

#ciimage ⇒ Object 



70
71
72
 
# File 'lib/sugarcube-image/cifilter.rb', line 70

def ciimage
  valueForKey('outputImage')
end

#uiimage ⇒ Object 



66
67
68
 
# File 'lib/sugarcube-image/cifilter.rb', line 66

def uiimage
  ciimage.uiimage
end