【Android 美颜相机】第五天：GPUImageFilterTools

GPUImageFilterTools

在android-gpuimage库（CyberAgent开源的Android GPU加速滤镜框架，对标iOS的GPUImage2）中，GPUImageFilterTools是一套专为滤镜选择、实例化设计的核心工具类。

它封装了海量内置滤镜的创建逻辑，提供可视化的滤镜选择弹窗，极大降低了开发者使用各类GPU滤镜的门槛。本文将基于代码库源码，从类的定位、核心结构、关键方法到实际应用，全面解析GPUImageFilterTools的设计与实现。

类的基础定位

1. 核心定位

GPUImageFilterTools是android-gpuimage示例模块（sample）下的工具类（object单例），核心职责是：

• 统一管理库中支持的所有滤镜类型（FilterType）；
• 提供可视化弹窗，让开发者/用户快速选择滤镜；
• 根据滤镜类型自动创建对应的GPUImageFilter子类实例，并设置合理的默认参数；
• 简化混合滤镜（Blend）、滤镜组（FilterGroup）等复杂滤镜的创建流程。

2. 依赖关联

该类高度依赖android-gpuimage核心库的以下类：

• GPUImageFilter：所有滤镜的基类，定义了滤镜的核心生命周期与渲染逻辑；
• GPUImageFilterGroup：滤镜组类，支持多滤镜链式叠加；
• 各类具体滤镜（如GPUImageSepiaToneFilter、GPUImageGammaFilter、GPUImageBlendFilter子类）；
• 安卓原生组件（AlertDialog）：实现滤镜选择弹窗。

3. 代码基础信息

// 包路径：jp.co.cyberagent.android.gpuimage.sample
package jp.co.cyberagent.android.gpuimage.sample

// 核心依赖导入
import android.app.AlertDialog
import android.content.Context
import jp.co.cyberagent.android.gpuimage.filter.*
import java.util.*

// 单例设计（Kotlin object）
object GPUImageFilterTools { ... }

核心结构

1. 滤镜类型管理：FilterList与FilterType

源码中通过FilterList（内部辅助类，代码未完全展示但可从调用推断）管理滤镜名称与类型的映射，核心逻辑是通过addFilter方法构建「滤镜名称 - FilterType」的关联列表：

// 构建滤镜列表的核心代码片段
val filters = FilterList().apply {
    // 基础调色滤镜
    addFilter("Contrast", FilterType.CONTRAST)
    addFilter("Gamma", FilterType.GAMMA)
    addFilter("Brightness", FilterType.BRIGHTNESS)
    // 风格化滤镜
    addFilter("Sepia", FilterType.SEPIA)
    addFilter("Grayscale", FilterType.GRAYSCALE)
    addFilter("Sketch", FilterType.SKETCH)
    // 混合模式滤镜
    addFilter("Blend (Difference)", FilterType.BLEND_DIFFERENCE)
    addFilter("Blend (Multiply)", FilterType.BLEND_MULTIPLY)
    // 滤镜组
    addFilter("Grouped filters", FilterType.FILTER_GROUP)
    // 共覆盖60+种内置滤镜（源码中包含完整列表）
}

FilterType是枚举类型（源码未完整展示），作为「滤镜类型标识」，是连接「用户选择」与「滤镜实例创建」的核心桥梁。

2. 核心方法总览

方法名	入参	返回值	核心作用
showDialog	Context、(GPUImageFilter) -> Unit（选中回调）	Unit	构建滤镜选择弹窗，用户选中后通过回调返回滤镜实例
createFilterForType	Context、FilterType	GPUImageFilter	根据FilterType创建对应的滤镜实例，设置默认参数
createBlendFilter（辅助）	Context、Class<out GPUImageBlendFilter>	GPUImageBlendFilter	统一创建混合模式滤镜（需加载混合纹理）

关键方法深度解析

1. showDialog：可视化滤镜选择弹窗

这是开发者最常调用的方法，核心逻辑是「构建滤镜列表 → 生成弹窗 → 选中后创建滤镜实例 → 回调返回」。

实现逻辑拆解

fun showDialog(
    context: Context,
    listener: (filter: GPUImageFilter) -> Unit
) {
    // 步骤1：构建完整的滤镜名称-类型列表
    val filters = FilterList().apply { ... } // 见上文滤镜列表构建逻辑
    
    // 步骤2：构建AlertDialog，展示滤镜名称列表
    val builder = AlertDialog.Builder(context)
    builder.setTitle("Choose a filter")
    builder.setItems(filters.names.toTypedArray()) { _, item ->
        // 步骤3：用户选中后，根据FilterType创建滤镜实例
        val selectedFilter = createFilterForType(context, filters.filters[item])
        // 步骤4：通过回调返回滤镜实例
        listener(selectedFilter)
    }
    builder.create().show()
}

核心亮点：

• 弹窗基于安卓原生AlertDialog，无需额外依赖；
• 滤镜列表与FilterType强绑定，确保选中的名称与实际创建的滤镜一一对应；
• 回调式设计，适配异步/主线程使用场景。

2. createFilterForType：滤镜实例的「工厂方法」

这是GPUImageFilterTools的核心逻辑，通过when分支匹配FilterType，创建对应的GPUImageFilter子类实例，并为每个滤镜设置合理的默认参数。

核心分支逻辑解析

private fun createFilterForType(context: Context, type: FilterType): GPUImageFilter {
    return when (type) {
        // 1. 基础调色滤镜：设置默认参数（非1.0/0.0，便于直观看到效果）
        FilterType.CONTRAST -> GPUImageContrastFilter(2.0f) // 对比度默认2倍
        FilterType.GAMMA -> GPUImageGammaFilter(2.0f) // 伽马值默认2.0
        FilterType.BRIGHTNESS -> GPUImageBrightnessFilter(1.5f) // 亮度默认1.5倍
        
        // 2. 风格化滤镜：无参数/默认参数
        FilterType.SEPIA -> GPUImageSepiaToneFilter() // 棕褐色滤镜（无默认参数）
        FilterType.GRAYSCALE -> GPUImageGrayscaleFilter() // 灰度滤镜
        FilterType.SKETCH -> GPUImageSketchFilter() // 素描滤镜
        
        // 3. 滤镜组：组合多个滤镜链式生效
        FilterType.FILTER_GROUP -> GPUImageFilterGroup(
            listOf(
                GPUImageContrastFilter(),
                GPUImageDirectionalSobelEdgeDetectionFilter(),
                GPUImageGrayscaleFilter()
            )
        )
        
        // 4. 色调曲线滤镜：加载内置资源文件
        FilterType.TONE_CURVE -> GPUImageToneCurveFilter().apply {
            setFromCurveFileInputStream(context.resources.openRawResource(R.raw.tone_cuver_sample))
        }
        
        // 5. 混合模式滤镜：调用辅助方法创建
        FilterType.BLEND_DIFFERENCE -> createBlendFilter(
            context,
            GPUImageDifferenceBlendFilter::class.java
        )
        FilterType.BLEND_MULTIPLY -> createBlendFilter(
            context,
            GPUImageMultiplyBlendFilter::class.java
        )
        
        // 其他滤镜分支（共60+种，逻辑类似）
        ...
    }
}

关键细节：

• 基础调色滤镜默认参数「非中性值」：比如对比度默认2.0f、亮度默认1.5f，目的是让开发者选中后能直观看到滤镜效果，而非无变化的中性值；
• 滤镜组（FilterGroup）示例：组合了「对比度调整 + 方向索贝尔边缘检测 + 灰度」三个滤镜，展示了多滤镜叠加的用法；
• 色调曲线滤镜（ToneCurve）：加载raw目录下的tone_cuver_sample曲线配置文件，支持自定义色调曲线；
• 混合滤镜（Blend）：通过createBlendFilter统一创建，需加载混合纹理（如另一张图片作为混合源）。

3. 混合滤镜辅助方法：createBlendFilter

混合滤镜需要依赖「源纹理 + 混合纹理」，createBlendFilter封装了混合纹理的加载逻辑（源码片段中未完全展示，但可推断其核心逻辑）：

private fun createBlendFilter(
    context: Context,
    blendFilterClass: Class<out GPUImageBlendFilter>
): GPUImageBlendFilter {
    // 步骤1：创建混合滤镜实例
    val blendFilter = blendFilterClass.getConstructor().newInstance()
    // 步骤2：加载混合纹理（示例图片，如app内内置的混合素材）
    val blendBitmap = BitmapFactory.decodeResource(context.resources, R.drawable.blend_sample)
    // 步骤3：为混合滤镜设置混合纹理
    blendFilter.setBitmap(blendBitmap)
    return blendFilter
}

设计价值：统一混合滤镜的纹理加载逻辑，避免开发者重复编写「解码图片 → 设置混合纹理」的代码。

与核心滤镜类的关联

GPUImageFilterTools的核心是对GPUImageFilter及其子类的封装，其创建的所有滤镜实例均继承自GPUImageFilter（滤镜基类），遵循以下设计规则：

1. 所有滤镜实例均通过GPUImageFilter的子类构造函数创建，保证与库的渲染逻辑兼容；
2. 滤镜组（GPUImageFilterGroup）作为特殊的GPUImageFilter子类，支持多滤镜链式渲染；
3. 自定义滤镜可通过扩展FilterType和createFilterForType的分支逻辑，无缝集成到该工具类中。

以GPUImageGammaFilter为例（核心库中的滤镜类），GPUImageFilterTools为其设置默认参数2.0f，而GPUImageGammaFilter本身通过GLSL实现伽马校正：

// 核心库中GPUImageGammaFilter的GLSL片段着色器
public static final String GAMMA_FRAGMENT_SHADER = "" +
        "varying highp vec2 textureCoordinate;\n" +
        " uniform sampler2D inputImageTexture;\n" +
        " uniform lowp float gamma;\n" +
        " void main()\n" +
        " {\n" +
        "     lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n" +
        "     gl_FragColor = vec4(pow(textureColor.rgb, vec3(gamma)), textureColor.w);\n" +
        " }";

GPUImageFilterTools创建的GPUImageGammaFilter(2.0f)会将gamma参数传入该着色器，最终通过GPU完成伽马校正渲染。

实际使用示例

1. 调用GPUImageFilterTools选择并应用滤镜

// 在Activity/Fragment中调用
GPUImageFilterTools.showDialog(this) { selectedFilter ->
    // 选中滤镜后的回调逻辑
    val gpuImageView = findViewById<GPUImageView>(R.id.gpuImageView)
    // 加载图片（Uri示例）
    val imageUri = Uri.parse("android.resource://com.example.app/drawable/sample_image")
    gpuImageView.setImage(imageUri)
    // 应用选中的滤镜
    gpuImageView.setFilter(selectedFilter)
}

2. 扩展自定义滤镜

若需新增自定义滤镜（如GPUImageCustomFilter），可通过以下步骤扩展GPUImageFilterTools：

1. 新增FilterType.CUSTOM枚举值；

2. 在createFilterForType中添加分支：

   FilterType.CUSTOM -> GPUImageCustomFilter(/* 自定义参数 */)

3. 在showDialog的FilterList中添加：

   addFilter("Custom Filter", FilterType.CUSTOM)

源码注释

/*
 * Copyright (C) 2018 CyberAgent, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// 声明当前类所在的包路径，对应示例工程的工具类包
package jp.co.cyberagent.android.gpuimage.sample

// 导入安卓系统弹窗相关类，用于创建滤镜选择对话框
import android.app.AlertDialog
// 导入安卓上下文类，提供应用环境信息
import android.content.Context
// 导入位图工厂类，用于处理图片解码（滤镜混合时可能用到）
import android.graphics.BitmapFactory
// 导入浮点坐标点类，用于滤镜参数（如畸变中心、晕影位置等）
import android.graphics.PointF
// 导入OpenGL矩阵操作类，用于滤镜的变换计算
import android.opengl.Matrix
// 导入GPUImage所有滤镜相关类，是核心滤镜实现依赖
import jp.co.cyberagent.android.gpuimage.filter.*
// 导入Java工具类，用于构建滤镜列表
import java.util.*

/**
 * 滤镜工具类：提供滤镜选择对话框、滤镜实例创建的核心工具方法
 * 采用单例对象（object）实现，避免重复创建实例，全局复用
 */
object GPUImageFilterTools {
    /**
     * 显示滤镜选择对话框
     * @param context 上下文对象，用于创建对话框、访问资源等
     * @param listener 滤镜选择回调，用户选中某滤镜后触发，返回对应的滤镜实例
     */
    fun showDialog(
        context: Context,
        listener: (filter: GPUImageFilter) -> Unit
    ) {
        // 构建滤镜列表：封装滤镜名称和对应的类型枚举
        val filters = FilterList().apply {
            // 逐个添加滤镜项：格式为「显示名称 + 滤镜类型枚举」
            addFilter("Contrast", FilterType.CONTRAST)               // 对比度滤镜
            addFilter("Invert", FilterType.INVERT)                   // 颜色反转滤镜
            addFilter("Pixelation", FilterType.PIXELATION)           // 像素化滤镜
            addFilter("Hue", FilterType.HUE)                         // 色调调整滤镜
            addFilter("Gamma", FilterType.GAMMA)                     // 伽马校正滤镜
            addFilter("Brightness", FilterType.BRIGHTNESS)           // 亮度调整滤镜
            addFilter("Sepia", FilterType.SEPIA)                     // 棕褐色（老照片）滤镜
            addFilter("Grayscale", FilterType.GRAYSCALE)             // 灰度滤镜
            addFilter("Sharpness", FilterType.SHARPEN)               // 锐化滤镜
            addFilter("Sobel Edge Detection", FilterType.SOBEL_EDGE_DETECTION) // 索贝尔边缘检测
            addFilter("Threshold Edge Detection", FilterType.THRESHOLD_EDGE_DETECTION) // 阈值边缘检测
            addFilter("3x3 Convolution", FilterType.THREE_X_THREE_CONVOLUTION) // 3x3卷积滤镜
            addFilter("Emboss", FilterType.EMBOSS)                   // 浮雕滤镜
            addFilter("Posterize", FilterType.POSTERIZE)             // 色调分离滤镜
            addFilter("Grouped filters", FilterType.FILTER_GROUP)    // 组合滤镜（多个滤镜叠加）
            addFilter("Saturation", FilterType.SATURATION)           // 饱和度调整滤镜
            addFilter("Exposure", FilterType.EXPOSURE)               // 曝光度调整滤镜
            addFilter("Highlight Shadow", FilterType.HIGHLIGHT_SHADOW) // 高光阴影调整滤镜
            addFilter("Monochrome", FilterType.MONOCHROME)           // 单色滤镜
            addFilter("Opacity", FilterType.OPACITY)                 // 不透明度滤镜
            addFilter("RGB", FilterType.RGB)                         // RGB通道调整滤镜
            addFilter("White Balance", FilterType.WHITE_BALANCE)     // 白平衡滤镜
            addFilter("Vignette", FilterType.VIGNETTE)               // 晕影滤镜
            addFilter("ToneCurve", FilterType.TONE_CURVE)            // 色调曲线滤镜

            addFilter("Luminance", FilterType.LUMINANCE)             // 亮度提取滤镜
            addFilter("Luminance Threshold", FilterType.LUMINANCE_THRESHSOLD) // 亮度阈值滤镜

            // 各种混合模式滤镜（用于多图叠加）
            addFilter("Blend (Difference)", FilterType.BLEND_DIFFERENCE)
            addFilter("Blend (Source Over)", FilterType.BLEND_SOURCE_OVER)
            addFilter("Blend (Color Burn)", FilterType.BLEND_COLOR_BURN)
            addFilter("Blend (Color Dodge)", FilterType.BLEND_COLOR_DODGE)
            addFilter("Blend (Darken)", FilterType.BLEND_DARKEN)
            addFilter("Blend (Dissolve)", FilterType.BLEND_DISSOLVE)
            addFilter("Blend (Exclusion)", FilterType.BLEND_EXCLUSION)
            addFilter("Blend (Hard Light)", FilterType.BLEND_HARD_LIGHT)
            addFilter("Blend (Lighten)", FilterType.BLEND_LIGHTEN)
            addFilter("Blend (Add)", FilterType.BLEND_ADD)
            addFilter("Blend (Divide)", FilterType.BLEND_DIVIDE)
            addFilter("Blend (Multiply)", FilterType.BLEND_MULTIPLY)
            addFilter("Blend (Overlay)", FilterType.BLEND_OVERLAY)
            addFilter("Blend (Screen)", FilterType.BLEND_SCREEN)
            addFilter("Blend (Alpha)", FilterType.BLEND_ALPHA)
            addFilter("Blend (Color)", FilterType.BLEND_COLOR)
            addFilter("Blend (Hue)", FilterType.BLEND_HUE)
            addFilter("Blend (Saturation)", FilterType.BLEND_SATURATION)
            addFilter("Blend (Luminosity)", FilterType.BLEND_LUMINOSITY)
            addFilter("Blend (Linear Burn)", FilterType.BLEND_LINEAR_BURN)
            addFilter("Blend (Soft Light)", FilterType.BLEND_SOFT_LIGHT)
            addFilter("Blend (Subtract)", FilterType.BLEND_SUBTRACT)
            addFilter("Blend (Chroma Key)", FilterType.BLEND_CHROMA_KEY) // 色度键（绿幕抠图）
            addFilter("Blend (Normal)", FilterType.BLEND_NORMAL)

            addFilter("Lookup (Amatorka)", FilterType.LOOKUP_AMATORKA) // Lookup表滤镜（Amatorka风格）
            addFilter("Gaussian Blur", FilterType.GAUSSIAN_BLUR)     // 高斯模糊滤镜
            addFilter("Crosshatch", FilterType.CROSSHATCH)           // 交叉影线滤镜

            addFilter("Box Blur", FilterType.BOX_BLUR)               // 盒式模糊滤镜
            addFilter("CGA Color Space", FilterType.CGA_COLORSPACE)  // CGA色彩空间滤镜
            addFilter("Dilation", FilterType.DILATION)               // 膨胀滤镜（图像高亮区域扩张）
            addFilter("Kuwahara", FilterType.KUWAHARA)               // 桑原滤镜（风格化模糊）
            addFilter("RGB Dilation", FilterType.RGB_DILATION)       // RGB通道膨胀滤镜
            addFilter("Sketch", FilterType.SKETCH)                   // 素描滤镜
            addFilter("Toon", FilterType.TOON)                       // 卡通风格滤镜
            addFilter("Smooth Toon", FilterType.SMOOTH_TOON)         // 平滑卡通风格滤镜
            addFilter("Halftone", FilterType.HALFTONE)               // 半色调滤镜

            addFilter("Bulge Distortion", FilterType.BULGE_DISTORTION) // 凸面畸变滤镜
            addFilter("Glass Sphere", FilterType.GLASS_SPHERE)       // 玻璃球折射滤镜
            addFilter("Haze", FilterType.HAZE)                       // 雾霾滤镜
            addFilter("Laplacian", FilterType.LAPLACIAN)             // 拉普拉斯边缘检测
            addFilter("Non Maximum Suppression", FilterType.NON_MAXIMUM_SUPPRESSION) // 非极大值抑制
            addFilter("Sphere Refraction", FilterType.SPHERE_REFRACTION) // 球面折射滤镜
            addFilter("Swirl", FilterType.SWIRL)                     // 漩涡畸变滤镜
            addFilter("Weak Pixel Inclusion", FilterType.WEAK_PIXEL_INCLUSION) // 弱像素包含滤镜
            addFilter("False Color", FilterType.FALSE_COLOR)         // 伪彩色滤镜

            addFilter("Color Balance", FilterType.COLOR_BALANCE)     // 色彩平衡滤镜

            addFilter("Levels Min (Mid Adjust)", FilterType.LEVELS_FILTER_MIN) // 色阶调整（最小值/中间值）

            addFilter("Bilateral Blur", FilterType.BILATERAL_BLUR)   // 双边模糊滤镜
            addFilter("Zoom Blur", FilterType.ZOOM_BLUR)             // 变焦模糊滤镜
            addFilter("Transform (2-D)", FilterType.TRANSFORM2D)     // 2D变换滤镜（平移/旋转/缩放）
            addFilter("Solarize", FilterType.SOLARIZE)               // 曝光滤镜
            addFilter("Vibrance", FilterType.VIBRANCE)               // 自然饱和度滤镜
        }

        // 构建AlertDialog对话框，用于展示滤镜列表供用户选择
        val builder = AlertDialog.Builder(context)
        builder.setTitle("Choose a filter") // 设置对话框标题：选择滤镜
        // 设置对话框列表项：将滤镜名称数组传入，点击时触发回调
        builder.setItems(filters.names.toTypedArray()) { _, item ->
            // 用户点击第item个滤镜时，创建对应类型的滤镜实例，并通过listener回调返回
            listener(createFilterForType(context, filters.filters[item]))
        }
        // 创建并显示对话框
        builder.create().show()
    }

    /**
     * 根据滤镜类型创建对应的滤镜实例
     * @param context 上下文，用于访问资源（如ToneCurve的acv文件、Lookup的纹理文件等）
     * @param type 滤镜类型枚举，标识要创建的滤镜种类
     * @return 对应类型的GPUImageFilter子类实例
     */
    private fun createFilterForType(context: Context, type: FilterType): GPUImageFilter {
        // 根据类型枚举分支创建滤镜，每个分支对应一个具体滤镜的实例化
        return when (type) {
            FilterType.CONTRAST -> GPUImageContrastFilter(2.0f) // 对比度滤镜，默认值2.0
            FilterType.GAMMA -> GPUImageGammaFilter(2.0f)       // 伽马校正，默认值2.0
            FilterType.INVERT -> GPUImageColorInvertFilter()    // 颜色反转，无参数
            FilterType.PIXELATION -> GPUImagePixelationFilter() // 像素化，默认参数
            FilterType.HUE -> GPUImageHueFilter(90.0f)          // 色调调整，默认旋转90度
            FilterType.BRIGHTNESS -> GPUImageBrightnessFilter(1.5f) // 亮度，默认1.5倍
            FilterType.GRAYSCALE -> GPUImageGrayscaleFilter()   // 灰度，无参数
            FilterType.SEPIA -> GPUImageSepiaToneFilter()       // 棕褐色，默认参数
            FilterType.SHARPEN -> GPUImageSharpenFilter()       // 锐化，默认参数
            FilterType.SOBEL_EDGE_DETECTION -> GPUImageSobelEdgeDetectionFilter() // 索贝尔边缘检测
            FilterType.THRESHOLD_EDGE_DETECTION -> GPUImageThresholdEdgeDetectionFilter() // 阈值边缘检测
            FilterType.THREE_X_THREE_CONVOLUTION -> GPUImage3x3ConvolutionFilter() // 3x3卷积
            FilterType.EMBOSS -> GPUImageEmbossFilter()         // 浮雕，默认参数
            FilterType.POSTERIZE -> GPUImagePosterizeFilter()   // 色调分离，默认参数
            // 组合滤镜：叠加对比度、方向索贝尔边缘检测、灰度三个滤镜
            FilterType.FILTER_GROUP -> GPUImageFilterGroup(
                listOf(
                    GPUImageContrastFilter(),
                    GPUImageDirectionalSobelEdgeDetectionFilter(),
                    GPUImageGrayscaleFilter()
                )
            )
            FilterType.SATURATION -> GPUImageSaturationFilter(1.0f) // 饱和度，默认1.0（无调整）
            FilterType.EXPOSURE -> GPUImageExposureFilter(0.0f)     // 曝光度，默认0.0
            FilterType.HIGHLIGHT_SHADOW -> GPUImageHighlightShadowFilter(0.0f, 1.0f) // 高光阴影，默认参数
            // 单色滤镜：默认强度1.0，颜色值(0.6, 0.45, 0.3, 1.0)
            FilterType.MONOCHROME -> GPUImageMonochromeFilter(
                1.0f, floatArrayOf(0.6f, 0.45f, 0.3f, 1.0f)
            )
            FilterType.OPACITY -> GPUImageOpacityFilter(1.0f)   // 不透明度，默认1.0（完全不透明）
            FilterType.RGB -> GPUImageRGBFilter(1.0f, 1.0f, 1.0f) // RGB通道，默认无调整
            FilterType.WHITE_BALANCE -> GPUImageWhiteBalanceFilter(5000.0f, 0.0f) // 白平衡，默认色温5000K
            // 晕影滤镜：中心(0.5,0.5)，颜色黑色(0,0,0)，起始半径0.3，结束半径0.75
            FilterType.VIGNETTE -> GPUImageVignetteFilter(
                PointF(0.5f, 0.5f),
                floatArrayOf(0.0f, 0.0f, 0.0f),
                0.3f,
                0.75f
            )
            // 色调曲线滤镜：加载raw目录下的tone_cuver_sample.acv文件
            FilterType.TONE_CURVE -> GPUImageToneCurveFilter().apply {
                setFromCurveFileInputStream(context.resources.openRawResource(R.raw.tone_cuver_sample))
            }
            FilterType.LUMINANCE -> GPUImageLuminanceFilter()   // 亮度提取
            FilterType.LUMINANCE_THRESHSOLD -> GPUImageLuminanceThresholdFilter(0.5f) // 亮度阈值，默认0.5
            // 各种混合模式滤镜：通过通用方法创建，传入对应的混合滤镜类
            FilterType.BLEND_DIFFERENCE -> createBlendFilter(
                context,
                GPUImageDifferenceBlendFilter::class.java
            )
            FilterType.BLEND_SOURCE_OVER -> createBlendFilter(
                context,
                GPUImageSourceOverBlendFilter::class.java
            )
            FilterType.BLEND_COLOR_BURN -> createBlendFilter(
                context,
                GPUImageColorBurnBlendFilter::class.java
            )
            FilterType.BLEND_COLOR_DODGE -> createBlendFilter(
                context,
                GPUImageColorDodgeBlendFilter::class.java
            )
            FilterType.BLEND_DARKEN -> createBlendFilter(
                context,
                GPUImageDarkenBlendFilter::class.java
            )
            FilterType.BLEND_DISSOLVE -> createBlendFilter(
                context,
                GPUImageDissolveBlendFilter::class.java
            )
            FilterType.BLEND_EXCLUSION -> createBlendFilter(
                context,
                GPUImageExclusionBlendFilter::class.java
            )
            FilterType.BLEND_HARD_LIGHT -> createBlendFilter(
                context,
                GPUImageHardLightBlendFilter::class.java
            )
            // 其余滤镜类型可按此逻辑补充...
            else -> GPUImageFilter() // 默认返回空滤镜（无效果）
        }
    }

    /**
     * 通用混合滤镜创建方法（源码中未完整展示，补充核心逻辑注释）
     * 混合滤镜需要第二个输入纹理（叠加图），此处简化实现：加载默认纹理作为混合源
     * @param context 上下文，用于加载默认混合纹理
     * @param clazz 混合滤镜的Class类型，通过反射创建实例
     * @return 初始化好的混合滤镜实例
     */
    private fun <T : GPUImageTwoInputFilter> createBlendFilter(context: Context, clazz: Class<T>): T {
        // 1. 加载默认混合纹理（示例：从assets/raw加载默认图片）
        val bitmap = BitmapFactory.decodeResource(context.resources, R.raw.default_blend_texture)
        // 2. 通过反射创建混合滤镜实例（所有混合滤镜均继承GPUImageTwoInputFilter）
        val filter = clazz.getConstructor().newInstance()
        // 3. 设置第二个输入纹理（混合源）
        filter.setBitmap(bitmap)
        // 4. 返回初始化后的滤镜
        return filter
    }

    /**
     * 内部辅助类：封装滤镜名称和类型的映射关系
     * 用于统一管理滤镜列表的名称和类型，方便对话框展示
     */
    private class FilterList {
        // 存储滤镜名称列表（用于对话框展示）
        val names = mutableListOf<String>()
        // 存储滤镜类型列表（与名称列表一一对应）
        val filters = mutableListOf<FilterType>()

        /**
         * 添加滤镜项到列表
         * @param name 滤镜显示名称
         * @param type 滤镜类型枚举
         */
        fun addFilter(name: String, type: FilterType) {
            names.add(name)
            filters.add(type)
        }
    }

    /**
     * 滤镜类型枚举：标识所有支持的滤镜种类
     * 与createFilterForType中的分支一一对应
     */
    private enum class FilterType {
        CONTRAST, INVERT, PIXELATION, HUE, GAMMA, BRIGHTNESS, SEPIA, GRAYSCALE,
        SHARPEN, SOBEL_EDGE_DETECTION, THRESHOLD_EDGE_DETECTION, THREE_X_THREE_CONVOLUTION,
        EMBOSS, POSTERIZE, FILTER_GROUP, SATURATION, EXPOSURE, HIGHLIGHT_SHADOW,
        MONOCHROME, OPACITY, RGB, WHITE_BALANCE, VIGNETTE, TONE_CURVE, LUMINANCE,
        LUMINANCE_THRESHSOLD, BLEND_DIFFERENCE, BLEND_SOURCE_OVER, BLEND_COLOR_BURN,
        BLEND_COLOR_DODGE, BLEND_DARKEN, BLEND_DISSOLVE, BLEND_EXCLUSION, BLEND_HARD_LIGHT,
        BLEND_LIGHTEN, BLEND_ADD, BLEND_DIVIDE, BLEND_MULTIPLY, BLEND_OVERLAY, BLEND_SCREEN,
        BLEND_ALPHA, BLEND_COLOR, BLEND_HUE, BLEND_SATURATION, BLEND_LUMINOSITY,
        BLEND_LINEAR_BURN, BLEND_SOFT_LIGHT, BLEND_SUBTRACT, BLEND_CHROMA_KEY, BLEND_NORMAL,
        LOOKUP_AMATORKA, GAUSSIAN_BLUR, CROSSHATCH, BOX_BLUR, CGA_COLORSPACE, DILATION,
        KUWAHARA, RGB_DILATION, SKETCH, TOON, SMOOTH_TOON, HALFTONE, BULGE_DISTORTION,
        GLASS_SPHERE, HAZE, LAPLACIAN, NON_MAXIMUM_SUPPRESSION, SPHERE_REFRACTION,
        SWIRL, WEAK_PIXEL_INCLUSION, FALSE_COLOR, COLOR_BALANCE, LEVELS_FILTER_MIN,
        BILATERAL_BLUR, ZOOM_BLUR, TRANSFORM2D, SOLARIZE, VIBRANCE
    }
}

类的设计价值与局限性

1. 核心价值

• 降低使用门槛：无需记忆数十种滤镜的类名和构造参数，通过弹窗可视化选择；
• 统一创建逻辑：所有滤镜实例的创建集中管理，避免参数错误或纹理加载遗漏；
• 示例参考价值 ：createFilterForType中包含所有内置滤镜的默认参数配置，是开发者调优滤镜效果的最佳参考；
• 适配库的生态 ：与GPUImageView、GPUImageFilterGroup等核心类无缝衔接。

2. 局限性

• 仅用于示例模块 ：该类位于sample模块，而非核心库（library），开发者需复制到项目中使用；
• 默认参数固定 ：若需动态调整参数（如通过SeekBar调整对比度），需额外封装FilterAdjuster；
• 混合滤镜依赖固定纹理 ：createBlendFilter中混合纹理为内置图片，需手动修改以支持自定义混合源。

总结

GPUImageFilterTools是android-gpuimage库中极具实用价值的工具类，它将「滤镜类型管理 - 可视化选择 - 实例化 - 参数配置」全流程封装，是开发者快速集成多类型GPU滤镜的最佳入口。

理解该类的设计逻辑，不仅能高效使用内置滤镜，也能基于其「工厂模式 + 回调设计」扩展自定义滤镜，适配更多业务场景（如图片编辑、直播美颜、短视频特效等）。