Class: CIFilter

Inherits:
Object show all
Defined in:
lib/ios/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
110
111
# File 'lib/ios/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 try to
    # assign the key as the user specified. This means you can pass options
    # like `'inputRadius'` directly, without using an alias
    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



114
115
116
# File 'lib/ios/sugarcube-image/cifilter.rb', line 114

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

.affine_clamp(*options) ⇒ Object

CIAffineClamp



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

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



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

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



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

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



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

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



175
176
177
178
179
180
# File 'lib/ios/sugarcube-image/cifilter.rb', line 175

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



183
184
185
# File 'lib/ios/sugarcube-image/cifilter.rb', line 183

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

.bump_distortion(*options) ⇒ Object

CIBumpDistortion PENDING



189
190
191
# File 'lib/ios/sugarcube-image/cifilter.rb', line 189

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

.bump_distortion_linear(*options) ⇒ Object

CIBumpDistortionLinear PENDING



195
196
197
# File 'lib/ios/sugarcube-image/cifilter.rb', line 195

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

.checkerboard_generator(*options) ⇒ Object

CICheckerboardGenerator



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

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



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

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



227
228
229
# File 'lib/ios/sugarcube-image/cifilter.rb', line 227

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

.color_blend_mode(*options) ⇒ Object

CIColorBlendMode



232
233
234
235
236
237
# File 'lib/ios/sugarcube-image/cifilter.rb', line 232

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



240
241
242
243
244
245
# File 'lib/ios/sugarcube-image/cifilter.rb', line 240

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



248
249
250
251
# File 'lib/ios/sugarcube-image/cifilter.rb', line 248

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



255
256
257
# File 'lib/ios/sugarcube-image/cifilter.rb', line 255

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

.color_dodge_blend_mode(*options) ⇒ Object

CIColorDodgeBlendMode



260
261
262
263
264
265
# File 'lib/ios/sugarcube-image/cifilter.rb', line 260

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

.color_invertObject

CIColorInvert



268
269
270
# File 'lib/ios/sugarcube-image/cifilter.rb', line 268

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

.color_map(*options) ⇒ Object

CIColorMap



273
274
275
276
277
278
# File 'lib/ios/sugarcube-image/cifilter.rb', line 273

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



282
283
284
# File 'lib/ios/sugarcube-image/cifilter.rb', line 282

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

.color_monochrome(*options) ⇒ Object

CIColorMonochrome PENDING



288
289
290
# File 'lib/ios/sugarcube-image/cifilter.rb', line 288

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

.color_posterize(*options) ⇒ Object

CIColorPosterize



293
294
295
# File 'lib/ios/sugarcube-image/cifilter.rb', line 293

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

.constant_color_generator(*options) ⇒ Object

CIConstantColorGenerator



298
299
300
301
302
303
# File 'lib/ios/sugarcube-image/cifilter.rb', line 298

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



307
308
309
# File 'lib/ios/sugarcube-image/cifilter.rb', line 307

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

.crop(*options) ⇒ Object

CICrop



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

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



323
324
325
326
327
328
# File 'lib/ios/sugarcube-image/cifilter.rb', line 323

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



331
332
333
334
335
336
# File 'lib/ios/sugarcube-image/cifilter.rb', line 331

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



340
341
342
# File 'lib/ios/sugarcube-image/cifilter.rb', line 340

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

.dissolve_transition(*options) ⇒ Object

CIDissolveTransition PENDING



346
347
348
# File 'lib/ios/sugarcube-image/cifilter.rb', line 346

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

.dot_screen(*options) ⇒ Object

CIDotScreen PENDING



352
353
354
# File 'lib/ios/sugarcube-image/cifilter.rb', line 352

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

.eightfold_reflected_tile(*options) ⇒ Object

CIEightfoldReflectedTile PENDING



358
359
360
# File 'lib/ios/sugarcube-image/cifilter.rb', line 358

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

.exclusion_blend_mode(*options) ⇒ Object

CIExclusionBlendMode



363
364
365
366
367
368
# File 'lib/ios/sugarcube-image/cifilter.rb', line 363

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



371
372
373
# File 'lib/ios/sugarcube-image/cifilter.rb', line 371

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

.false_color(*options) ⇒ Object

CIFalseColor



376
377
378
379
380
381
# File 'lib/ios/sugarcube-image/cifilter.rb', line 376

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



385
386
387
# File 'lib/ios/sugarcube-image/cifilter.rb', line 385

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

.fourfold_reflected_tile(*options) ⇒ Object

CIFourfoldReflectedTile PENDING



391
392
393
# File 'lib/ios/sugarcube-image/cifilter.rb', line 391

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

.fourfold_rotated_tile(*options) ⇒ Object

CIFourfoldRotatedTile PENDING



397
398
399
# File 'lib/ios/sugarcube-image/cifilter.rb', line 397

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

.fourfold_translated_tile(*options) ⇒ Object

CIFourfoldTranslatedTile PENDING



403
404
405
# File 'lib/ios/sugarcube-image/cifilter.rb', line 403

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

.gamma_adjust(*options) ⇒ Object

CIGammaAdjust



408
409
410
# File 'lib/ios/sugarcube-image/cifilter.rb', line 408

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

.gaussian_blur(*options) ⇒ Object

CIGaussianBlur



413
414
415
# File 'lib/ios/sugarcube-image/cifilter.rb', line 413

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

.gaussian_gradient(*options) ⇒ Object

CIGaussianGradient PENDING



419
420
421
# File 'lib/ios/sugarcube-image/cifilter.rb', line 419

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

.glide_reflected_tile(*options) ⇒ Object

CIGlideReflectedTile PENDING



425
426
427
# File 'lib/ios/sugarcube-image/cifilter.rb', line 425

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

.gloom(*options) ⇒ Object

CIGloom



430
431
432
# File 'lib/ios/sugarcube-image/cifilter.rb', line 430

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

.hard_light_blend_mode(*options) ⇒ Object

CIHardLightBlendMode



435
436
437
438
439
440
# File 'lib/ios/sugarcube-image/cifilter.rb', line 435

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



444
445
446
# File 'lib/ios/sugarcube-image/cifilter.rb', line 444

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

.highlight_shadow_adjust(*options) ⇒ Object

CIHighlightShadowAdjust



449
450
451
# File 'lib/ios/sugarcube-image/cifilter.rb', line 449

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

.hole_distortion(*options) ⇒ Object

CIHoleDistortion PENDING



455
456
457
# File 'lib/ios/sugarcube-image/cifilter.rb', line 455

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

.hue_adjust(*options) ⇒ Object

CIHueAdjust



460
461
462
# File 'lib/ios/sugarcube-image/cifilter.rb', line 460

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

.hue_blend_mode(*options) ⇒ Object

CIHueBlendMode



465
466
467
468
469
470
# File 'lib/ios/sugarcube-image/cifilter.rb', line 465

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



473
474
475
# File 'lib/ios/sugarcube-image/cifilter.rb', line 473

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



487
488
489
# File 'lib/ios/sugarcube-image/cifilter.rb', line 487

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

.lighten_blend_mode(*options) ⇒ Object

CILightenBlendMode



478
479
480
481
482
483
# File 'lib/ios/sugarcube-image/cifilter.rb', line 478

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



499
500
501
# File 'lib/ios/sugarcube-image/cifilter.rb', line 499

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

.linear_gradient(*options) ⇒ Object

CILinearGradient PENDING



493
494
495
# File 'lib/ios/sugarcube-image/cifilter.rb', line 493

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

.luminosity_blend_mode(*options) ⇒ Object

CILuminosityBlendMode



504
505
506
507
508
509
# File 'lib/ios/sugarcube-image/cifilter.rb', line 504

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

.mask_to_alphaObject

CIMaskToAlpha



512
513
514
# File 'lib/ios/sugarcube-image/cifilter.rb', line 512

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

.maximum_componentObject

CIMaximumComponent



517
518
519
# File 'lib/ios/sugarcube-image/cifilter.rb', line 517

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

.maximum_compositing(*options) ⇒ Object

CIMaximumCompositing



522
523
524
525
526
527
# File 'lib/ios/sugarcube-image/cifilter.rb', line 522

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

.minimum_componentObject

CIMinimumComponent



530
531
532
# File 'lib/ios/sugarcube-image/cifilter.rb', line 530

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

.minimum_compositing(*options) ⇒ Object

CIMinimumCompositing



535
536
537
538
539
540
# File 'lib/ios/sugarcube-image/cifilter.rb', line 535

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



544
545
546
# File 'lib/ios/sugarcube-image/cifilter.rb', line 544

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

.multiply_blend_mode(*options) ⇒ Object

CIMultiplyBlendMode



549
550
551
552
553
554
# File 'lib/ios/sugarcube-image/cifilter.rb', line 549

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



557
558
559
560
561
562
# File 'lib/ios/sugarcube-image/cifilter.rb', line 557

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



565
566
567
568
569
570
# File 'lib/ios/sugarcube-image/cifilter.rb', line 565

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



574
575
576
# File 'lib/ios/sugarcube-image/cifilter.rb', line 574

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

.perspective_transform(*options) ⇒ Object

CIPerspectiveTransform PENDING



580
581
582
# File 'lib/ios/sugarcube-image/cifilter.rb', line 580

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

.perspective_transform_with_extent(*options) ⇒ Object

CIPerspectiveTransformWithExtent PENDING



586
587
588
# File 'lib/ios/sugarcube-image/cifilter.rb', line 586

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

.pinch_distortion(*options) ⇒ Object

CIPinchDistortion PENDING



592
593
594
# File 'lib/ios/sugarcube-image/cifilter.rb', line 592

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

.pixellate(*options) ⇒ Object

CIPixellate PENDING



598
599
600
# File 'lib/ios/sugarcube-image/cifilter.rb', line 598

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

.radial_gradient(*options) ⇒ Object

CIRadialGradient PENDING



604
605
606
# File 'lib/ios/sugarcube-image/cifilter.rb', line 604

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

.random_generatorObject

CIRandomGenerator



609
610
611
# File 'lib/ios/sugarcube-image/cifilter.rb', line 609

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

.saturation_blend_mode(*options) ⇒ Object

CISaturationBlendMode



614
615
616
617
618
619
# File 'lib/ios/sugarcube-image/cifilter.rb', line 614

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



622
623
624
625
626
627
# File 'lib/ios/sugarcube-image/cifilter.rb', line 622

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



630
631
632
# File 'lib/ios/sugarcube-image/cifilter.rb', line 630

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

.sharpen_luminance(*options) ⇒ Object

CISharpenLuminance



635
636
637
# File 'lib/ios/sugarcube-image/cifilter.rb', line 635

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

.sixfold_reflected_tile(*options) ⇒ Object

CISixfoldReflectedTile PENDING



641
642
643
# File 'lib/ios/sugarcube-image/cifilter.rb', line 641

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

.sixfold_rotated_tile(*options) ⇒ Object

CISixfoldRotatedTile PENDING



647
648
649
# File 'lib/ios/sugarcube-image/cifilter.rb', line 647

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

.soft_light_blend_mode(*options) ⇒ Object

CISoftLightBlendMode



652
653
654
655
656
657
# File 'lib/ios/sugarcube-image/cifilter.rb', line 652

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



660
661
662
663
664
665
# File 'lib/ios/sugarcube-image/cifilter.rb', line 660

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



668
669
670
671
672
673
# File 'lib/ios/sugarcube-image/cifilter.rb', line 668

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



676
677
678
679
680
681
# File 'lib/ios/sugarcube-image/cifilter.rb', line 676

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



684
685
686
687
688
689
# File 'lib/ios/sugarcube-image/cifilter.rb', line 684

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



693
694
695
# File 'lib/ios/sugarcube-image/cifilter.rb', line 693

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

.straighten_filter(*options) ⇒ Object

CIStraightenFilter



698
699
700
# File 'lib/ios/sugarcube-image/cifilter.rb', line 698

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

.stripes_generator(*options) ⇒ Object

CIStripesGenerator PENDING



704
705
706
# File 'lib/ios/sugarcube-image/cifilter.rb', line 704

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

.swipe_transition(*options) ⇒ Object

CISwipeTransition PENDING



710
711
712
# File 'lib/ios/sugarcube-image/cifilter.rb', line 710

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

.temperature_and_tint(*options) ⇒ Object

CITemperatureAndTint PENDING



716
717
718
# File 'lib/ios/sugarcube-image/cifilter.rb', line 716

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

.tone_curve(*options) ⇒ Object

CIToneCurve PENDING



722
723
724
# File 'lib/ios/sugarcube-image/cifilter.rb', line 722

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

.triangle_kaleidoscope(*options) ⇒ Object

CITriangleKaleidoscope PENDING



728
729
730
# File 'lib/ios/sugarcube-image/cifilter.rb', line 728

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

.twelvefold_reflected_tile(*options) ⇒ Object

CITwelvefoldReflectedTile PENDING



734
735
736
# File 'lib/ios/sugarcube-image/cifilter.rb', line 734

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

.twirl_distortion(*options) ⇒ Object

CITwirlDistortion PENDING



740
741
742
# File 'lib/ios/sugarcube-image/cifilter.rb', line 740

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

.unsharp_mask(*options) ⇒ Object

CIUnsharpMask



745
746
747
# File 'lib/ios/sugarcube-image/cifilter.rb', line 745

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

.vibrance(*options) ⇒ Object

CIVibrance



750
751
752
# File 'lib/ios/sugarcube-image/cifilter.rb', line 750

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

.vignette(*options) ⇒ Object

CIVignette



755
756
757
# File 'lib/ios/sugarcube-image/cifilter.rb', line 755

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

.vortex_distortion(*options) ⇒ Object

CIVortexDistortion PENDING



761
762
763
# File 'lib/ios/sugarcube-image/cifilter.rb', line 761

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

.white_point_adjust(*options) ⇒ Object

CIWhitePointAdjust



766
767
768
769
770
# File 'lib/ios/sugarcube-image/cifilter.rb', line 766

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

Instance Method Details

#ciimageObject



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

def ciimage
  valueForKey('outputImage')
end

#uiimageObject



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

def uiimage
  ciimage.uiimage
end