src/c/sk_imagefilter.cpp

   1 /*
   2  * Copyright 2014 Google Inc.
   3  * Copyright 2015 Xamarin Inc.
   4  * Copyright 2017 Microsoft Corporation. All rights reserved.
   5  *
   6  * Use of this source code is governed by a BSD-style license that can be
   7  * found in the LICENSE file.
   8  */
   9
  10 #include "SkImageFilter.h"
  11 #include "SkColorFilter.h"
  12 #include "SkAlphaThresholdFilter.h"
  13 #include "SkBlurImageFilter.h"
  14 #include "SkColorFilterImageFilter.h"
  15 #include "SkComposeImageFilter.h"
  16 #include "SkDisplacementMapEffect.h"
  17 #include "SkDropShadowImageFilter.h"
  18 #include "SkLightingImageFilter.h"
  19 #include "SkMagnifierImageFilter.h"
  20 #include "SkMatrixConvolutionImageFilter.h"
  21 #include "SkMergeImageFilter.h"
  22 #include "SkMorphologyImageFilter.h"
  23 #include "SkOffsetImageFilter.h"
  24 #include "SkPictureImageFilter.h"
  25 #include "SkTileImageFilter.h"
  26 #include "SkXfermodeImageFilter.h"
  27 #include "SkArithmeticImageFilter.h"
  28 #include "SkImageSource.h"
  29 #include "SkPaintImageFilter.h"
  30 #include "SkRegion.h"
  31
  32 #include "sk_imagefilter.h"
  33
  34 #include "sk_types_priv.h"
  35
  36 sk_imagefilter_croprect_t* sk_imagefilter_croprect_new() {
  37     return (sk_imagefilter_croprect_t*) new SkImageFilter::CropRect();
  38 }
  39
  40 sk_imagefilter_croprect_t* sk_imagefilter_croprect_new_with_rect(const sk_rect_t* rect, uint32_t flags) {
  41     return (sk_imagefilter_croprect_t*) new SkImageFilter::CropRect(*AsRect(rect), flags);
  42 }
  43
  44 void sk_imagefilter_croprect_destructor(sk_imagefilter_croprect_t* cropRect) {
  45     delete AsImageFilterCropRect(cropRect);
  46 }
  47
  48 void sk_imagefilter_croprect_get_rect(sk_imagefilter_croprect_t* cropRect, sk_rect_t* rect) {
  49     if (rect) {
  50         *rect = ToRect(AsImageFilterCropRect(cropRect)->rect());
  51     }
  52 }
  53
  54 uint32_t sk_imagefilter_croprect_get_flags(sk_imagefilter_croprect_t* cropRect) {
  55     return AsImageFilterCropRect(cropRect)->flags();
  56 }
  57
  58 void sk_imagefilter_unref(sk_imagefilter_t* cfilter) {
  59     SkSafeUnref(AsImageFilter(cfilter));
  60 }
  61
  62 sk_imagefilter_t* sk_imagefilter_new_matrix(
  63     const sk_matrix_t* cmatrix,
  64     sk_filter_quality_t cquality,
  65     sk_imagefilter_t* input /*NULL*/) {
  66
  67     SkMatrix matrix;
  68     from_c(cmatrix, &matrix);
  69
  70     sk_sp<SkImageFilter> filter = SkImageFilter::MakeMatrixFilter(matrix, (SkFilterQuality)cquality, sk_ref_sp(AsImageFilter(input)));
  71     return ToImageFilter(filter.release());
  72 }
  73
  74 sk_imagefilter_t* sk_imagefilter_new_alpha_threshold(
  75     const sk_irect_t* region,
  76     float innerThreshold,
  77     float outerThreshold,
  78     sk_imagefilter_t* input /*NULL*/) {
  79
  80     SkRegion r = SkRegion(AsIRect(*region));
  81
  82     sk_sp<SkImageFilter> filter = SkAlphaThresholdFilter::Make(r, innerThreshold, outerThreshold, sk_ref_sp(AsImageFilter(input)));
  83     return ToImageFilter(filter.release());
  84 }
  85
  86 sk_imagefilter_t* sk_imagefilter_new_blur(
  87     float sigmaX,
  88     float sigmaY,
  89     sk_imagefilter_t* input /*NULL*/,
  90     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
  91
  92     sk_sp<SkImageFilter> filter = SkImageFilter::MakeBlur(sigmaX, sigmaY, sk_ref_sp(AsImageFilter(input)), AsImageFilterCropRect(cropRect));
  93     return ToImageFilter(filter.release());
  94 }
  95
  96 sk_imagefilter_t* sk_imagefilter_new_color_filter(
  97     sk_colorfilter_t* cf,
  98     sk_imagefilter_t* input /*NULL*/,
  99     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 100
 101     sk_sp<SkImageFilter> filter = SkColorFilterImageFilter::Make(sk_ref_sp(AsColorFilter(cf)), sk_ref_sp(AsImageFilter(input)), AsImageFilterCropRect(cropRect));
 102     return ToImageFilter(filter.release());
 103 }
 104
 105 sk_imagefilter_t* sk_imagefilter_new_compose(
 106     sk_imagefilter_t* outer,
 107     sk_imagefilter_t* inner) {
 108
 109     sk_sp<SkImageFilter> filter = SkComposeImageFilter::Make(sk_ref_sp(AsImageFilter(outer)), sk_ref_sp(AsImageFilter(inner)));
 110     return ToImageFilter(filter.release());
 111 }
 112
 113 sk_imagefilter_t* sk_imagefilter_new_displacement_map_effect(
 114     sk_displacement_map_effect_channel_selector_type_t xChannelSelector,
 115     sk_displacement_map_effect_channel_selector_type_t yChannelSelector,
 116     float scale,
 117     sk_imagefilter_t* displacement,
 118     sk_imagefilter_t* color /*NULL*/,
 119     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 120
 121     sk_sp<SkImageFilter> filter = SkDisplacementMapEffect::Make(
 122         (SkDisplacementMapEffect::ChannelSelectorType)xChannelSelector,
 123         (SkDisplacementMapEffect::ChannelSelectorType)yChannelSelector,
 124         scale,
 125         sk_ref_sp(AsImageFilter(displacement)),
 126         sk_ref_sp(AsImageFilter(color)),
 127         AsImageFilterCropRect(cropRect));
 128     return ToImageFilter(filter.release());
 129 }
 130
 131 sk_imagefilter_t* sk_imagefilter_new_drop_shadow(
 132     float dx,
 133     float dy,
 134     float sigmaX,
 135     float sigmaY,
 136     sk_color_t color,
 137     sk_drop_shadow_image_filter_shadow_mode_t cShadowMode,
 138     sk_imagefilter_t* input /*NULL*/,
 139     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 140
 141     sk_sp<SkImageFilter> filter = SkDropShadowImageFilter::Make(
 142         dx,
 143         dy,
 144         sigmaX,
 145         sigmaY,
 146         color,
 147         (SkDropShadowImageFilter::ShadowMode)cShadowMode,
 148         sk_ref_sp(AsImageFilter(input)),
 149         AsImageFilterCropRect(cropRect));
 150     return ToImageFilter(filter.release());
 151 }
 152
 153 sk_imagefilter_t* sk_imagefilter_new_distant_lit_diffuse(
 154     const sk_point3_t* direction,
 155     sk_color_t lightColor,
 156     float surfaceScale,
 157     float kd,
 158     sk_imagefilter_t* input /*NULL*/,
 159     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 160
 161     sk_sp<SkImageFilter> filter = SkLightingImageFilter::MakeDistantLitDiffuse(
 162         *AsPoint3(direction),
 163         lightColor,
 164         surfaceScale,
 165         kd,
 166         sk_ref_sp(AsImageFilter(input)),
 167         AsImageFilterCropRect(cropRect));
 168     return ToImageFilter(filter.release());
 169 }
 170
 171 sk_imagefilter_t* sk_imagefilter_new_point_lit_diffuse(
 172     const sk_point3_t* location,
 173     sk_color_t lightColor,
 174     float surfaceScale,
 175     float kd,
 176     sk_imagefilter_t* input /*NULL*/,
 177     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 178
 179     sk_sp<SkImageFilter> filter = SkLightingImageFilter::MakePointLitDiffuse(
 180         *AsPoint3(location),
 181         lightColor,
 182         surfaceScale,
 183         kd,
 184         sk_ref_sp(AsImageFilter(input)),
 185         AsImageFilterCropRect(cropRect));
 186     return ToImageFilter(filter.release());
 187 }
 188
 189 sk_imagefilter_t* sk_imagefilter_new_spot_lit_diffuse(
 190     const sk_point3_t* location,
 191     const sk_point3_t* target,
 192     float specularExponent,
 193     float cutoffAngle,
 194     sk_color_t lightColor,
 195     float surfaceScale,
 196     float kd,
 197     sk_imagefilter_t* input /*NULL*/,
 198     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 199
 200     sk_sp<SkImageFilter> filter = SkLightingImageFilter::MakeSpotLitDiffuse(
 201         *AsPoint3(location),
 202         *AsPoint3(target),
 203         specularExponent,
 204         cutoffAngle,
 205         lightColor,
 206         surfaceScale,
 207         kd,
 208         sk_ref_sp(AsImageFilter(input)),
 209         AsImageFilterCropRect(cropRect));
 210     return ToImageFilter(filter.release());
 211 }
 212
 213 sk_imagefilter_t* sk_imagefilter_new_distant_lit_specular(
 214     const sk_point3_t* direction,
 215     sk_color_t lightColor,
 216     float surfaceScale,
 217     float ks,
 218     float shininess,
 219     sk_imagefilter_t* input /*NULL*/,
 220     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 221
 222     sk_sp<SkImageFilter> filter = SkLightingImageFilter::MakeDistantLitSpecular(
 223         *AsPoint3(direction),
 224         lightColor,
 225         surfaceScale,
 226         ks,
 227         shininess,
 228         sk_ref_sp(AsImageFilter(input)),
 229         AsImageFilterCropRect(cropRect));
 230     return ToImageFilter(filter.release());
 231 }
 232
 233 sk_imagefilter_t* sk_imagefilter_new_point_lit_specular(
 234     const sk_point3_t* location,
 235     sk_color_t lightColor,
 236     float surfaceScale,
 237     float ks,
 238     float shininess,
 239     sk_imagefilter_t* input /*NULL*/,
 240     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 241
 242     sk_sp<SkImageFilter> filter = SkLightingImageFilter::MakePointLitSpecular(
 243         *AsPoint3(location),
 244         lightColor,
 245         surfaceScale,
 246         ks,
 247         shininess,
 248         sk_ref_sp(AsImageFilter(input)),
 249         AsImageFilterCropRect(cropRect));
 250     return ToImageFilter(filter.release());
 251 }
 252
 253 sk_imagefilter_t* sk_imagefilter_new_spot_lit_specular(
 254     const sk_point3_t* location,
 255     const sk_point3_t* target,
 256     float specularExponent,
 257     float cutoffAngle,
 258     sk_color_t lightColor,
 259     float surfaceScale,
 260     float ks,
 261     float shininess,
 262     sk_imagefilter_t* input /*NULL*/,
 263     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 264
 265     sk_sp<SkImageFilter> filter = SkLightingImageFilter::MakeSpotLitSpecular(
 266         *AsPoint3(location),
 267         *AsPoint3(target),
 268         specularExponent,
 269         cutoffAngle,
 270         lightColor,
 271         surfaceScale,
 272         ks,
 273         shininess,
 274         sk_ref_sp(AsImageFilter(input)),
 275         AsImageFilterCropRect(cropRect));
 276     return ToImageFilter(filter.release());
 277 }
 278
 279 sk_imagefilter_t* sk_imagefilter_new_magnifier(
 280     const sk_rect_t* src,
 281     float inset,
 282     sk_imagefilter_t* input, /*NULL*/
 283     const sk_imagefilter_croprect_t* cropRect) {
 284
 285     sk_sp<SkImageFilter> filter = SkMagnifierImageFilter::Make(
 286         *AsRect(src),
 287         inset,
 288         sk_ref_sp(AsImageFilter(input)),
 289         AsImageFilterCropRect(cropRect));
 290     return ToImageFilter(filter.release());
 291 }
 292
 293 sk_imagefilter_t* sk_imagefilter_new_matrix_convolution(
 294     const sk_isize_t* kernelSize,
 295     const float kernel[],
 296     float gain,
 297     float bias,
 298     const sk_ipoint_t* kernelOffset,
 299     sk_matrix_convolution_tilemode_t ctileMode,
 300     bool convolveAlpha,
 301     sk_imagefilter_t* input /*NULL*/,
 302     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 303
 304     sk_sp<SkImageFilter> filter = SkMatrixConvolutionImageFilter::Make(
 305         *AsISize(kernelSize),
 306         kernel,
 307         gain,
 308         bias,
 309         *AsIPoint(kernelOffset),
 310         (SkMatrixConvolutionImageFilter::TileMode)ctileMode,
 311         convolveAlpha,
 312         sk_ref_sp(AsImageFilter(input)),
 313         AsImageFilterCropRect(cropRect));
 314     return ToImageFilter(filter.release());
 315 }
 316
 317 sk_imagefilter_t* sk_imagefilter_new_merge(
 318     sk_imagefilter_t* cfilters[],
 319     int count,
 320     const sk_blendmode_t cmodes[] /*NULL*/,
 321     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 322
 323     sk_sp<SkImageFilter>* filters = new sk_sp<SkImageFilter>[count];
 324     for (int i = 0; i < count; i++) {
 325         filters[i] = sk_ref_sp(AsImageFilter(cfilters[i]));
 326     }
 327
 328     sk_sp<SkImageFilter> filter = SkMergeImageFilter::MakeN(
 329         filters,
 330         count,
 331         (SkBlendMode*)cmodes,
 332         AsImageFilterCropRect(cropRect));
 333
 334     return ToImageFilter(filter.release());
 335 }
 336
 337 sk_imagefilter_t* sk_imagefilter_new_dilate(
 338     int radiusX,
 339     int radiusY,
 340     sk_imagefilter_t* input /*NULL*/,
 341     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 342
 343     sk_sp<SkImageFilter> filter = SkDilateImageFilter::Make(
 344         radiusX,
 345         radiusY,
 346         sk_ref_sp(AsImageFilter(input)),
 347         AsImageFilterCropRect(cropRect));
 348     return ToImageFilter(filter.release());
 349 }
 350
 351 sk_imagefilter_t* sk_imagefilter_new_erode(
 352     int radiusX,
 353     int radiusY,
 354     sk_imagefilter_t* input /*NULL*/,
 355     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 356
 357     sk_sp<SkImageFilter> filter = SkErodeImageFilter::Make(
 358         radiusX,
 359         radiusY,
 360         sk_ref_sp(AsImageFilter(input)),
 361         AsImageFilterCropRect(cropRect));
 362     return ToImageFilter(filter.release());
 363 }
 364
 365 sk_imagefilter_t* sk_imagefilter_new_offset(
 366     float dx,
 367     float dy,
 368     sk_imagefilter_t* input /*NULL*/,
 369     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 370
 371     sk_sp<SkImageFilter> filter = SkOffsetImageFilter::Make(
 372         dx,
 373         dy,
 374         sk_ref_sp(AsImageFilter(input)),
 375         AsImageFilterCropRect(cropRect));
 376     return ToImageFilter(filter.release());
 377 }
 378
 379 sk_imagefilter_t* sk_imagefilter_new_picture(
 380     sk_picture_t* picture) {
 381
 382     sk_sp<SkImageFilter> filter = SkPictureImageFilter::Make(
 383         sk_ref_sp(AsPicture(picture)));
 384     return ToImageFilter(filter.release());
 385 }
 386
 387 sk_imagefilter_t* sk_imagefilter_new_picture_with_croprect(
 388     sk_picture_t* picture,
 389     const sk_rect_t* cropRect) {
 390
 391     sk_sp<SkImageFilter> filter = SkPictureImageFilter::Make(
 392         sk_ref_sp(AsPicture(picture)),
 393         *AsRect(cropRect));
 394     return ToImageFilter(filter.release());
 395 }
 396
 397 sk_imagefilter_t* sk_imagefilter_new_picture_for_localspace(
 398     sk_picture_t* picture,
 399     const sk_rect_t* cropRect,
 400     sk_filter_quality_t filterQuality) {
 401
 402     sk_sp<SkImageFilter> filter = SkPictureImageFilter::MakeForLocalSpace(
 403         sk_ref_sp(AsPicture(picture)),
 404         *AsRect(cropRect),
 405         (SkFilterQuality)filterQuality);
 406     return ToImageFilter(filter.release());
 407 }
 408
 409 sk_imagefilter_t* sk_imagefilter_new_tile(
 410     const sk_rect_t* src,
 411     const sk_rect_t* dst,
 412     sk_imagefilter_t* input) {
 413
 414     sk_sp<SkImageFilter> filter = SkTileImageFilter::Make(
 415         *AsRect(src),
 416         *AsRect(dst),
 417         sk_ref_sp(AsImageFilter(input)));
 418     return ToImageFilter(filter.release());
 419 }
 420
 421 sk_imagefilter_t* sk_imagefilter_new_xfermode(
 422     sk_blendmode_t cmode,
 423     sk_imagefilter_t* background,
 424     sk_imagefilter_t* foreground /*NULL*/,
 425     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 426
 427     sk_sp<SkImageFilter> filter = SkXfermodeImageFilter::Make(
 428         (SkBlendMode)cmode,
 429         sk_ref_sp(AsImageFilter(background)),
 430         sk_ref_sp(AsImageFilter(foreground)),
 431         AsImageFilterCropRect(cropRect));
 432     return ToImageFilter(filter.release());
 433 }
 434
 435 SK_API sk_imagefilter_t* sk_imagefilter_new_arithmetic(
 436     float k1, float k2, float k3, float k4,
 437     bool enforcePMColor,
 438     sk_imagefilter_t* background,
 439     sk_imagefilter_t* foreground /*NULL*/,
 440     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 441
 442     sk_sp<SkImageFilter> filter = SkArithmeticImageFilter::Make(
 443         k1, k2, k3, k4,
 444         enforcePMColor,
 445         sk_ref_sp(AsImageFilter(background)),
 446         sk_ref_sp(AsImageFilter(foreground)),
 447         AsImageFilterCropRect(cropRect));
 448     return ToImageFilter(filter.release());
 449 }
 450
 451 sk_imagefilter_t* sk_imagefilter_new_image_source(
 452     sk_image_t* image,
 453     const sk_rect_t* srcRect,
 454     const sk_rect_t* dstRect,
 455     sk_filter_quality_t filterQuality) {
 456
 457     sk_sp<SkImageFilter> filter = SkImageSource::Make(
 458         sk_ref_sp(AsImage(image)),
 459         *AsRect(srcRect),
 460         *AsRect(dstRect),
 461         (SkFilterQuality)filterQuality);
 462     return ToImageFilter(filter.release());
 463 }
 464
 465 sk_imagefilter_t* sk_imagefilter_new_image_source_default(
 466     sk_image_t* image) {
 467
 468     sk_sp<SkImageFilter> filter = SkImageSource::Make(
 469         sk_ref_sp(AsImage(image)));
 470     return ToImageFilter(filter.release());
 471 }
 472
 473 sk_imagefilter_t* sk_imagefilter_new_paint(
 474     const sk_paint_t* paint,
 475     const sk_imagefilter_croprect_t* cropRect /*NULL*/) {
 476
 477     sk_sp<SkImageFilter> filter = SkPaintImageFilter::Make(
 478         AsPaint(*paint),
 479         AsImageFilterCropRect(cropRect));
 480     return ToImageFilter(filter.release());
 481 }