ColorUtils (refresh-layout API)

java.lang.Object
- com.scwang.smartrefresh.layout.util.ColorUtils

```
public final class ColorUtils
extends java.lang.Object
```
A set of color-related utility methods, building upon those available in Color.

方法概要

All Methods Static Methods Concrete Methods
限定符和类型	方法和说明
`static int`	`blendARGB(int color1, int color2, float ratio)` Blend between two ARGB colors using the given ratio.
`static void`	`blendHSL(float[] hsl1, float[] hsl2, float ratio, float[] outResult)` Blend between `hsl1` and `hsl2` using the given ratio.
`static void`	`blendLAB(double[] lab1, double[] lab2, double ratio, double[] outResult)` Blend between two CIE-LAB colors using the given ratio.
`static double`	`calculateContrast(int foreground, int background)` Returns the contrast ratio between `foreground` and `background`.
`static double`	`calculateLuminance(int color)` Returns the luminance of a color as a float between `0.0` and `1.0`.
`static int`	`calculateMinimumAlpha(int foreground, int background, float minContrastRatio)` Calculates the minimum alpha value which can be applied to `foreground` so that would have a contrast value of at least `minContrastRatio` when compared to `background`.
`static void`	`colorToHSL(int color, float[] outHsl)` Convert the ARGB color to its HSL (hue-saturation-lightness) components.
`static void`	`colorToLAB(int color, double[] outLab)` Convert the ARGB color to its CIE Lab representative components.
`static void`	`colorToXYZ(int color, double[] outXyz)` Convert the ARGB color to it's CIE XYZ representative components.
`static int`	`compositeColors(int foreground, int background)` Composite two potentially translucent colors over each other and returns the result.
`static double`	`distanceEuclidean(double[] labX, double[] labY)` Returns the euclidean distance between two LAB colors.
`static int`	`HSLToColor(float[] hsl)` Convert HSL (hue-saturation-lightness) components to a RGB color.
`static int`	`LABToColor(double l, double a, double b)` Converts a color from CIE Lab to its RGB representation.
`static void`	`LABToXYZ(double l, double a, double b, double[] outXyz)` Converts a color from CIE Lab to CIE XYZ representation.
`static void`	`RGBToHSL(int r, int g, int b, float[] outHsl)` Convert RGB components to HSL (hue-saturation-lightness).
`static void`	`RGBToLAB(int r, int g, int b, double[] outLab)` Convert RGB components to its CIE Lab representative components.
`static void`	`RGBToXYZ(int r, int g, int b, double[] outXyz)` Convert RGB components to it's CIE XYZ representative components.
`static int`	`setAlphaComponent(int color, int alpha)` Set the alpha component of `color` to be `alpha`.
`static int`	`XYZToColor(double x, double y, double z)` Converts a color from CIE XYZ to its RGB representation.
`static void`	`XYZToLAB(double x, double y, double z, double[] outLab)` Converts a color from CIE XYZ to CIE Lab representation.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细资料
  - compositeColors
```
public static int compositeColors(int foreground,
                                  int background)
```
    Composite two potentially translucent colors over each other and returns the result.
  - calculateLuminance
```
public static double calculateLuminance(int color)
```
    Returns the luminance of a color as a float between 0.0 and 1.0.
    Defined as the Y component in the XYZ representation of color.
  - calculateContrast
```
public static double calculateContrast(int foreground,
                                       int background)
```
    Returns the contrast ratio between foreground and background. background must be opaque.
    Formula defined here.
  - calculateMinimumAlpha
```
public static int calculateMinimumAlpha(int foreground,
                                        int background,
                                        float minContrastRatio)
```
    Calculates the minimum alpha value which can be applied to foreground so that would have a contrast value of at least minContrastRatio when compared to background.
    
    参数:
    
    foreground - the foreground color
    
    background - the opaque background color
    
    minContrastRatio - the minimum contrast ratio
    
    返回:
    
    the alpha value in the range 0-255, or -1 if no value could be calculated
  - RGBToHSL
```
public static void RGBToHSL(int r,
                            int g,
                            int b,
                            @NonNull
                            float[] outHsl)
```
    Convert RGB components to HSL (hue-saturation-lightness).
    - outHsl[0] is Hue [0 .. 360)
    - outHsl[1] is Saturation [0...1]
    - outHsl[2] is Lightness [0...1]
    参数:
    
    r - red component value [0..255]
    
    g - green component value [0..255]
    
    b - blue component value [0..255]
    
    outHsl - 3-element array which holds the resulting HSL components
  - colorToHSL
```
public static void colorToHSL(int color,
                              @NonNull
                              float[] outHsl)
```
    Convert the ARGB color to its HSL (hue-saturation-lightness) components.
    - outHsl[0] is Hue [0 .. 360)
    - outHsl[1] is Saturation [0...1]
    - outHsl[2] is Lightness [0...1]
    参数:
    
    color - the ARGB color to convert. The alpha component is ignored
    
    outHsl - 3-element array which holds the resulting HSL components
  - HSLToColor
```
public static int HSLToColor(@NonNull
                             float[] hsl)
```
    Convert HSL (hue-saturation-lightness) components to a RGB color.
    - hsl[0] is Hue [0 .. 360)
    - hsl[1] is Saturation [0...1]
    - hsl[2] is Lightness [0...1]
    If hsv values are out of range, they are pinned.
    参数:
    
    hsl - 3-element array which holds the input HSL components
    
    返回:
    
    the resulting RGB color
  - setAlphaComponent
```
public static int setAlphaComponent(int color,
                                    int alpha)
```
    Set the alpha component of color to be alpha.
  - colorToLAB
```
public static void colorToLAB(int color,
                              @NonNull
                              double[] outLab)
```
    Convert the ARGB color to its CIE Lab representative components.
    
    参数:
    
    color - the ARGB color to convert. The alpha component is ignored
    
    outLab - 3-element array which holds the resulting LAB components
  - RGBToLAB
```
public static void RGBToLAB(int r,
                            int g,
                            int b,
                            @NonNull
                            double[] outLab)
```
    Convert RGB components to its CIE Lab representative components.
    - outLab[0] is L [0 ...1)
    - outLab[1] is a [-128...127)
    - outLab[2] is b [-128...127)
    参数:
    
    r - red component value [0..255]
    
    g - green component value [0..255]
    
    b - blue component value [0..255]
    
    outLab - 3-element array which holds the resulting LAB components
  - colorToXYZ
```
public static void colorToXYZ(int color,
                              @NonNull
                              double[] outXyz)
```
    Convert the ARGB color to it's CIE XYZ representative components.
    The resulting XYZ representation will use the D65 illuminant and the CIE 2° Standard Observer (1931).
    - outXyz[0] is X [0 ...95.047)
    - outXyz[1] is Y [0...100)
    - outXyz[2] is Z [0...108.883)
    参数:
    
    color - the ARGB color to convert. The alpha component is ignored
    
    outXyz - 3-element array which holds the resulting LAB components
  - RGBToXYZ
```
public static void RGBToXYZ(int r,
                            int g,
                            int b,
                            @NonNull
                            double[] outXyz)
```
    Convert RGB components to it's CIE XYZ representative components.
    The resulting XYZ representation will use the D65 illuminant and the CIE 2° Standard Observer (1931).
    - outXyz[0] is X [0 ...95.047)
    - outXyz[1] is Y [0...100)
    - outXyz[2] is Z [0...108.883)
    参数:
    
    r - red component value [0..255]
    
    g - green component value [0..255]
    
    b - blue component value [0..255]
    
    outXyz - 3-element array which holds the resulting XYZ components
  - XYZToLAB
```
public static void XYZToLAB(double x,
                            double y,
                            double z,
                            @NonNull
                            double[] outLab)
```
    Converts a color from CIE XYZ to CIE Lab representation.
    This method expects the XYZ representation to use the D65 illuminant and the CIE 2° Standard Observer (1931).
    - outLab[0] is L [0 ...1)
    - outLab[1] is a [-128...127)
    - outLab[2] is b [-128...127)
    参数:
    
    x - X component value [0...95.047)
    
    y - Y component value [0...100)
    
    z - Z component value [0...108.883)
    
    outLab - 3-element array which holds the resulting Lab components
  - LABToXYZ
```
public static void LABToXYZ(double l,
                            double a,
                            double b,
                            @NonNull
                            double[] outXyz)
```
    Converts a color from CIE Lab to CIE XYZ representation.
    The resulting XYZ representation will use the D65 illuminant and the CIE 2° Standard Observer (1931).
    - outXyz[0] is X [0 ...95.047)
    - outXyz[1] is Y [0...100)
    - outXyz[2] is Z [0...108.883)
    参数:
    
    l - L component value [0...100)
    
    a - A component value [-128...127)
    
    b - B component value [-128...127)
    
    outXyz - 3-element array which holds the resulting XYZ components
  - XYZToColor
```
public static int XYZToColor(double x,
                             double y,
                             double z)
```
    Converts a color from CIE XYZ to its RGB representation.
    This method expects the XYZ representation to use the D65 illuminant and the CIE 2° Standard Observer (1931).
    
    参数:
    
    x - X component value [0...95.047)
    
    y - Y component value [0...100)
    
    z - Z component value [0...108.883)
    
    返回:
    
    int containing the RGB representation
  - LABToColor
```
public static int LABToColor(double l,
                             double a,
                             double b)
```
    Converts a color from CIE Lab to its RGB representation.
    
    参数:
    
    l - L component value [0...100]
    
    a - A component value [-128...127]
    
    b - B component value [-128...127]
    
    返回:
    
    int containing the RGB representation
  - distanceEuclidean
```
public static double distanceEuclidean(@NonNull
                                       double[] labX,
                                       @NonNull
                                       double[] labY)
```
    Returns the euclidean distance between two LAB colors.
  - blendARGB
```
public static int blendARGB(int color1,
                            int color2,
                            float ratio)
```
    Blend between two ARGB colors using the given ratio.
    A blend ratio of 0.0 will result in color1, 0.5 will give an even blend, 1.0 will result in color2.
    
    参数:
    
    color1 - the first ARGB color
    
    color2 - the second ARGB color
    
    ratio - the blend ratio of color1 to color2
  - blendHSL
```
public static void blendHSL(@NonNull
                            float[] hsl1,
                            @NonNull
                            float[] hsl2,
                            float ratio,
                            @NonNull
                            float[] outResult)
```
    Blend between hsl1 and hsl2 using the given ratio. This will interpolate the hue using the shortest angle.
    A blend ratio of 0.0 will result in hsl1, 0.5 will give an even blend, 1.0 will result in hsl2.
    
    参数:
    
    hsl1 - 3-element array which holds the first HSL color
    
    hsl2 - 3-element array which holds the second HSL color
    
    ratio - the blend ratio of hsl1 to hsl2
    
    outResult - 3-element array which holds the resulting HSL components
  - blendLAB
```
public static void blendLAB(@NonNull
                            double[] lab1,
                            @NonNull
                            double[] lab2,
                            double ratio,
                            @NonNull
                            double[] outResult)
```
    Blend between two CIE-LAB colors using the given ratio.
    A blend ratio of 0.0 will result in lab1, 0.5 will give an even blend, 1.0 will result in lab2.
    
    参数:
    
    lab1 - 3-element array which holds the first LAB color
    
    lab2 - 3-element array which holds the second LAB color
    
    ratio - the blend ratio of lab1 to lab2
    
    outResult - 3-element array which holds the resulting LAB components

类 ColorUtils

方法概要

从类继承的方法 java.lang.Object

方法详细资料

compositeColors

calculateLuminance

calculateContrast

calculateMinimumAlpha

RGBToHSL

colorToHSL

HSLToColor

setAlphaComponent

colorToLAB

RGBToLAB

colorToXYZ

RGBToXYZ

XYZToLAB

LABToXYZ

XYZToColor

LABToColor

distanceEuclidean

blendARGB

blendHSL

blendLAB