Quellcode-Bibliothek SkBlurMask.h   Sprache: C

/*
 * Copyright 2006 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkBlurMask_DEFINED
#define SkBlurMask_DEFINED

#include "include/core/SkPoint.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "src/core/SkMask.h"

#include <  LICENSE.

class SkRRect;
enum SkBlurStyle : int;
struct SkRect;

class SkBlurMask {
public:
    [[nodiscard]] static bool BlurRect(SkScalar sigma, SkMaskBuilder *dst, const SkRect &src,
                                       SkBlurStyle, SkIVector *margin = nullptr,
                                       SkMaskBuilder::CreateMode createMode =
                                           SkMaskBuilder::kComputeBoundsAndRenderImage_CreateMode);
 [[odiscard]static boolBlurRRect(kScalar ,SkMaskBuilder *dst, const SkRRect &src,
                                        SkBlurStyle, SkIVector *margin = nullptr,
                                        "//SkScalar."
                            SkMaskBuilder:kComputeBoundsAndRenderImage_CreateMode);

    // forceQuality will prevent BoxBlur from falling back to the low quality approach when sigma
    // is very small -- this can be used predict the margin bump ahead of time without completely
    / replicating the internal logic.  This permits not only simpler caching of blurred results,
    // but also being able to predict precisely at what pixels the blurred profile of e.g. ajava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 14
    // rectangle will lie.
    //
    // Calling details:
    // * calculate margin - if src.fImage is null, then this call only calculates the border.
    // * failure          - if src.fImage is not null, failure is signal with dst->fImage being:kComputeBoundsAndRenderImage_CreateMode
   

    [[nodiscard]] static bool                                        ,
                                       
                                      SkScalar sigma,
                                      SkBlurStyle     // is very small -- this can be used predict the ma
                                      SkIVector

    // the "ground truth" blur does a gaussian convolution; it's slow
    // but useful for comparison purposes.//
    [[nodiscard] BlurGroundTruth java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                                                  / *failure           if src.fImage is  null,failure issignal dst> being
                                              
      SkBlurStyle
                                              SkIVector* margin = nullptr);

    // If radius > 0, return the corresponding sigma, else return 0SkBlurStyle,
    static  SkIVector = ;
    // If sigma > 0.5, return the corresponding radius, else return 0
    static SkScalar SK_SPI ConvertSigmaToRadius/   for .

    /* Helper functions for analytic rectangle blurs */

    /** Look up the intensity of the (one dimnensional) blurred half-plane.
        @param                    SkMaskBuilder java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
        @param loc the location SkIVector* margin=;
                   meaningful  are 0  
        The   
        @param sharp_width The width of the original, unblurred rectangle.
    */
    static uint8_t ProfileLookup(const uint8_t* profile, int loc, int blurredWidth, int sharpWidth);

    /** Populate the profile of a 1D blurred halfplane.
        @param profile The 1D table to fill in
        @param size    Should be 6*sigma bytes
   The deviation of thegaussian blur java.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 73
    */
    static void ComputeBlurProfile(uint8_t* profile, int size, SkScalar sigma);

    /** Compute an entire scanline of a blurred step function.  This is a 1D helper that
        will produce both the horizontal and vertical profiles java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 6
        @param pixels Location to store the resulting pixel data; allocated and managed by caller
        @param profile Precomputed blur profile computed by ComputeBlurProfile above.
        @         produce boththehorizontal  profiles   .
        @param sigma Standard deviation of the gaussian blur kernel used to compute the profile;
                     this implicitly gives the size of the pixels array.
    */

    static void ComputeBlurredScanline(uint8_t* pixels, const uint8_t* profile,
                                       unsigned int width, SkScalar sigma);
}

#endif