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
 
# 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 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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/sugarcube-image/cifilter.rb', line 510

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

.maximum_component ⇒ Object

CIMaximumComponent



515
516
517
 
# File 'lib/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/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/ios/sugarcube-image/cifilter.rb', line 70

def ciimage
  valueForKey('outputImage')
end

#uiimage ⇒ Object

| | TYPE COERCTION |



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

def uiimage
  ciimage.uiimage
end