附一张GPUImage的结构图：

GPUImage.png

GPUImage中的几个概念

output为输出源
input为输入源
filter为滤镜

GPUImage的四大输入基础类

GPUImageVideoCamera 摄像头-视频流
GPUImageStillCamera 摄像头-照相
GPUImagePicture 图片
GPUImageMovie 视频

  #import "GPUImageBrightnessFilter.h"                //  亮度 
  #import "GPUImageExposureFilter.h"                  //曝光  
  #import "GPUImageContrastFilter.h"                  //对比度： 
  #import "GPUImageSaturationFilter.h"                //饱和度 
  #import "GPUImageGammaFilter.h"                     //gamma：要应用的灰度调整（0.0 - 3.0，默认为1.0）
  #import "GPUImageColorInvertFilter.h"               //反色
  #import "GPUImageSepiaFilter.h"                     //褐色（怀旧）
  #import "GPUImageLevelsFilter.h"                    //色阶
  #import "GPUImageGrayscaleFilter.h"                 //灰度
  #import "GPUImageHistogramFilter.h"                 //色彩直方图，显示在图片上
  #import "GPUImageHistogramGenerator.h"              //色彩直方图
  #import "GPUImageRGBFilter.h"                       //RGB
  #import "GPUImageToneCurveFilter.h"                 //色调曲线
  #import "GPUImageMonochromeFilter.h"                //单色
  #import "GPUImageOpacityFilter.h"                   //不透明度
  #import "GPUImageHighlightShadowFilter.h"           //提亮阴影
  #import "GPUImageFalseColorFilter.h"                //色彩替换（替换亮部和暗部色彩）
  #import "GPUImageHueFilter.h"                       //色度
  #import "GPUImageChromaKeyFilter.h"                 //色度键
  #import "GPUImageWhiteBalanceFilter.h"              //白平横
  #import "GPUImageAverageColor.h"                    //像素平均色值
  #import "GPUImageSolidColorGenerator.h"             //纯色
  #import "GPUImageLuminosity.h"                      //亮度平均
  #import "GPUImageAverageLuminanceThresholdFilter.h" //像素色值亮度平均，图像黑白（有类似漫画效果） 
  #import "GPUImageLookupFilter.h"                    //lookup 色彩调整
  #import "GPUImageAmatorkaFilter.h"                  //Amatorka lookup
  #import "GPUImageMissEtikateFilter.h"               //MissEtikate lookup
  #import "GPUImageSoftEleganceFilter.h"              //SoftElegance lookup

  #pragma mark - 图像处理 Handle Image
 
  #import "GPUImageCrosshairGenerator.h"              //十字
  #import "GPUImageLineGenerator.h"                   //线条
  #import "GPUImageTransformFilter.h"                 //形状变化
  #import "GPUImageCropFilter.h"                      //剪裁
  #import "GPUImageSharpenFilter.h"                   //锐化
  #import "GPUImageUnsharpMaskFilter.h"               //反遮罩锐化 
 #import "GPUImageFastBlurFilter.h"                  //模糊
  #import "GPUImageGaussianBlurFilter.h"              //高斯模糊
  #import "GPUImageGaussianSelectiveBlurFilter.h"     //高斯模糊，选择部分清晰
  #import "GPUImageBoxBlurFilter.h"                   //盒状模糊
  #import "GPUImageTiltShiftFilter.h"                 //条纹模糊，中间清晰，上下两端模糊
  #import "GPUImageMedianFilter.h"                    //中间值，有种稍微模糊边缘的效果
  #import "GPUImageBilateralFilter.h"                 //双边模糊
  #import "GPUImageErosionFilter.h"                   //侵蚀边缘模糊，变黑白
  #import "GPUImageRGBErosionFilter.h"                //RGB侵蚀边缘模糊，有色彩
  #import "GPUImageDilationFilter.h"                  //扩展边缘模糊，变黑白
  #import "GPUImageRGBDilationFilter.h"               //RGB扩展边缘模糊，有色彩
  #import "GPUImageOpeningFilter.h"                   //黑白色调模糊
  #import "GPUImageRGBOpeningFilter.h"                //彩色模糊
  #import "GPUImageClosingFilter.h"                   //黑白色调模糊，暗色会被提亮
  #import "GPUImageRGBClosingFilter.h"                //彩色模糊，暗色会被提亮
  #import "GPUImageLanczosResamplingFilter.h"         //Lanczos重取样，模糊效果
  #import "GPUImageNonMaximumSuppressionFilter.h"     //非最大抑制，只显示亮度最高的像素，其他为黑
  #import "GPUImageThresholdedNonMaximumSuppressionFilter.h" //与上相比，像素丢失更多 
  #import "GPUImageSobelEdgeDetectionFilter.h"        //Sobel边缘检测算法(白边，黑内容，有点漫画的反色效果)
  #import "GPUImageCannyEdgeDetectionFilter.h"        //Canny边缘检测算法（比上更强烈的黑白对比度）
  #import "GPUImageThresholdEdgeDetectionFilter.h"    //阈值边缘检测（效果与上差别不大）
  #import "GPUImagePrewittEdgeDetectionFilter.h"      //普瑞维特(Prewitt)边缘检测(效果与Sobel差不多，貌似更平滑)
  #import "GPUImageXYDerivativeFilter.h"              //XYDerivative边缘检测，画面以蓝色为主，绿色为边缘，带彩色
  #import "GPUImageHarrisCornerDetectionFilter.h"     //Harris角点检测，会有绿色小十字显示在图片角点处
  #import "GPUImageNobleCornerDetectionFilter.h"      //Noble角点检测，检测点更多
  #import "GPUImageShiTomasiFeatureDetectionFilter.h" //ShiTomasi角点检测，与上差别不大
  #import "GPUImageMotionDetector.h"                  //动作检测
  #import "GPUImageHoughTransformLineDetector.h"      //线条检测
 #import "GPUImageParallelCoordinateLineTransformFilter.h" //平行线检测 
 #import "GPUImageLocalBinaryPatternFilter.h"        //图像黑白化，并有大量噪点 
 #import "GPUImageLowPassFilter.h"                   //用于图像加亮
 #import "GPUImageHighPassFilter.h"                  //图像低于某值时显示为黑
 #pragma mark - 视觉效果 Visual Effect
 #import "GPUImageSketchFilter.h"                    //素描
#import "GPUImageThresholdSketchFilter.h"           //阀值素描，形成有噪点的素描
 #import "GPUImageToonFilter.h"                      //卡通效果（黑色粗线描边）
 #import "GPUImageSmoothToonFilter.h"                //相比上面的效果更细腻，上面是粗旷的画风
 #import "GPUImageKuwaharaFilter.h"                  //桑原(Kuwahara)滤波,水粉画的模糊效果；处理时间比较长，慎用 
 #import "GPUImageMosaicFilter.h"                    //黑白马赛克
 #import "GPUImagePixellateFilter.h"                 //像素化
 #import "GPUImagePolarPixellateFilter.h"            //同心圆像素化
 #import "GPUImageCrosshatchFilter.h"                //交叉线阴影，形成黑白网状画面
 #import "GPUImageColorPackingFilter.h"              //色彩丢失，模糊（类似监控摄像效果） 
 #import "GPUImageVignetteFilter.h"                  //晕影，形成黑色圆形边缘，突出中间图像的效果
 #import "GPUImageSwirlFilter.h"                     //漩涡，中间形成卷曲的画面
#import "GPUImageBulgeDistortionFilter.h"           //凸起失真，鱼眼效果
 #import "GPUImagePinchDistortionFilter.h"           //收缩失真，凹面镜
#import "GPUImageStretchDistortionFilter.h"         //伸展失真，哈哈镜
#import "GPUImageGlassSphereFilter.h"               //水晶球效果
#import "GPUImageSphereRefractionFilter.h"          //球形折射，图形倒立     
 #import "GPUImagePosterizeFilter.h"                 //色调分离，形成噪点效果
 #import "GPUImageCGAColorspaceFilter.h"             //CGA色彩滤镜，形成黑、浅蓝、紫色块的画面
 #import "GPUImagePerlinNoiseFilter.h"               //柏林噪点，花边噪点
 #import "GPUImage3x3ConvolutionFilter.h"            //3x3卷积，高亮大色块变黑，加亮边缘、线条等
 #import "GPUImageEmbossFilter.h"                    //浮雕效果，带有点3d的感觉
 #import "GPUImagePolkaDotFilter.h"                  //像素圆点花样
#import "GPUImageHalftoneFilter.h"                  //点染,图像黑白化，由黑点构成原图的大致图形 
 
  #pragma mark - 混合模式 Blend
 
  #import "GPUImageMultiplyBlendFilter.h"             //通常用于创建阴影和深度效果
  #import "GPUImageNormalBlendFilter.h"               //正常
  #import "GPUImageAlphaBlendFilter.h"                //透明混合,通常用于在背景上应用前景的透明度
  #import "GPUImageDissolveBlendFilter.h"             //溶解
  #import "GPUImageOverlayBlendFilter.h"              //叠加,通常用于创建阴影效果
  #import "GPUImageDarkenBlendFilter.h"               //加深混合,通常用于重叠类型
  #import "GPUImageLightenBlendFilter.h"              //减淡混合,通常用于重叠类型
  #import "GPUImageSourceOverBlendFilter.h"           //源混合
  #import "GPUImageColorBurnBlendFilter.h"            //色彩加深混合
  #import "GPUImageColorDodgeBlendFilter.h"           //色彩减淡混合
  #import "GPUImageScreenBlendFilter.h"               //屏幕包裹,通常用于创建亮点和镜头眩光
  #import "GPUImageExclusionBlendFilter.h"            //排除混合
  #import "GPUImageDifferenceBlendFilter.h"           //差异混合,通常用于创建更多变动的颜色
  #import "GPUImageSubtractBlendFilter.h"             //差值混合,通常用于创建两个图像之间的动画变暗模糊效果
  #import "GPUImageHardLightBlendFilter.h"            //强光混合,通常用于创建阴影效果
  #import "GPUImageSoftLightBlendFilter.h"            //柔光混合
  #import "GPUImageChromaKeyBlendFilter.h"            //色度键混合
  #import "GPUImageMaskFilter.h"                      //遮罩混合
  #import "GPUImageHazeFilter.h"                      //朦胧加暗
  #import "GPUImageLuminanceThresholdFilter.h"        //亮度阈
  #import "GPUImageAdaptiveThresholdFilter.h"         //自适应阈值
  #import "GPUImageAddBlendFilter.h"                  //通常用于创建两个图像之间的动画变亮模糊效果
  #import "GPUImageDivideBlendFilter.h"               //通常用于创建两个图像之间的动画变暗模糊效果

颜色调整

GPUImageBrightnessFilter：调整图像的亮度

亮度：调整亮度（-1.0 - 1.0，默认为0.0）
GPUImageExposureFilter：调整图像的曝光

曝光：调整曝光（-10.0 - 10.0，默认为0.0）
GPUImageContrastFilter：调整图像的对比度

对比度：调整的对比度（0.0 - 4.0，默认为1.0）
GPUImageSaturationFilter：调整图像的饱和度

饱和度：应用于图像的饱和度或去饱和度（0.0 - 2.0，默认为1.0）
GPUImageGammaFilter：调整图像的灰度系数

gamma：要应用的灰度调整（0.0 - 3.0，默认为1.0）
GPUImageLevelsFilter：Photoshop级别调整。min ，max，minOut和maxOut参数是范围[0,1]中的浮点数如果你有来自Photoshop的参数，范围为[0,255]，则必须首先将它们转换为[0， 1] 。gamma / mid参数是一个float> = 0的值。这与Photoshop的值匹配如果要对RGB以及单个通道应用级别，则需要使用此过滤器两​​次 - 首先用于单个通道，然后用于所有通道。

GPUImageColorMatrixFilter：通过向图像应用矩阵来转换图像的颜色

colorMatrix：一个4x4矩阵，用于变换图像中的每种颜色
intensity：新变换颜色的原始颜色的程度
GPUImageRGBFilter：调整图像的每个 RGB通道

红色：每个颜色通道乘以的标准化值。范围是从0.0开始，默认为1.0。
绿色：
蓝色：
GPUImageHueFilter：调整图像的色调

色相角：以度为单位。默认为90度
GPUImageVibranceFilter：调整图像的动态

光彩：在光彩调整申请，使用0.0作为默认设置，分别为-1.2左右和1.2，建议最小/最大。
GPUImageWhiteBalanceFilter：调整图像的白平衡。

温度：以ºK单位为调整图像的温度值4000是非常酷，7000非常温暖。默认值为5000。请注意，4000和5000之间的刻度与5000和7000之间的刻度几乎相同。
色调：图像调整色调的值为-200 非常绿色，200 非常粉红色。默认值为0。
GPUImageToneCurveFilter：根据每个颜色通道的样条曲线调整图像的颜色。

redControlPoints：
greenControlPoints：
blueControlPoints：
rgbCompositeControlPoints：色调曲线采用一系列控制点，这些控制点为每个颜色分量或复合材料中的所有三个分量定义样条曲线。这些作为NSValue封装的CGPoints存储在NSArray中，标准化的X和Y坐标0到1.默认值为（0,0），（0.5,0.5），（1,1）。
GPUImageHighlightShadowFilter：调整图像的阴影和高光

阴影：增加到减弱阴影，从0.0到1.0，默认值为0.0。
亮点：减少高亮显示，从1.0到0.0，默认为1.0。
GPUImageHighlightShadowTintFilter：允许您使用颜色和强度独立地着色图像的阴影和高光

shadowTintColor：阴影色调RGB颜色（GPUVector4）。默认值:( {1.0f, 0.0f, 0.0f, 1.0f}红色）。
highlightTintColor：突出显示色彩RGB颜色（GPUVector4）。默认值:( {0.0f, 0.0f, 1.0f, 1.0f}蓝色）。
shadowTintIntensity：阴影色调强度，从0.0到1.0。默认值：0.0
highlightTintIntensity：突出显示从0.0到1.0的色调强度，默认值为0.0。
GPUImageLookupFilter：使用RGB颜色查找图像重新映射图像中的颜色。首先，使用最最喜欢的照片编辑应用程序将过滤器应用于GPUImage / framework / Resources中的lookup.png。为了使其正常工作，每个像素颜色不能依赖于其他像素（例如模糊不起作用）。如果您需要更复杂的过滤器，您可以根据需要创建任意数量的查找表。准备好后，使用您的新lookup.png文件作为GPUImageLookupFilter的第二个输入。

GPUImageAmatorkaFilter：基于Amatorka的Photoshop操作的照片过滤器：http：//amatorka.deviantart.com/art/Amatorka-Action-2-121069631。如果要使用此效果，您必须从lookup_amatorka.png从GPUImage资源文件夹添加到应用程序包。

GPUImageMissEtikateFilter：由Etikate小姐基于Photoshop操作的照片过滤器：http：//miss-etikate.deviantart.com/art/Photoshop-Action-15-120151961。如果要使用此效果，您必须将lookup_miss_etikate.png从GPUImage资源文件夹添加到应用程序包。

GPUImageSoftEleganceFilter：另一个基于查找的颜色重映射过滤器。如果要使用此效果，您必须将lookup_soft_elegance_1.png和lookup_soft_elegance_2.png从GPUImage资源文件夹添加到应用程序包。

GPUImageSkinToneFilter：一个肤色调整过滤器，影响一个独特范围的轻肤色调，并相应地调整粉色/绿色或粉色/橙色的范围。默认值针对公平的白种人皮肤，但可以根据需要进行调整。

skinToneAdjust：调整肤色的量。默认值：0.0，建议最小值/最大值：-0.3和0.3。
skinHue：皮肤色调被检测到。默认值：0.05（正常的白种人到微红的皮肤）。
skinHueThreshold：皮肤色调的方差量。
maxHueShift：允许的最大色差偏移量。
maxSaturationShift =要移动的最大饱和度（使用橙色时）。
upperSkinToneColor = GPUImageSkinToneUpperColorGreen或GPUImageSkinToneUpperColorOrange
GPUImageColorInvertFilter：反转图像的颜色

GPUImageGrayscaleFilter：将图像转换为灰度（饱和度滤镜的实现略快，但无法改变颜色贡献）

GPUImageMonochromeFilter：根据每个像素的亮度将图像转换为单色版本

intensity：特定颜色替换正常图像颜色的程度（0.0 - 1.0，默认为1.0）
color：用作效果基础的颜色，以（0.6,0.45,0.3,1.0）作为默认值。
GPUImageFalseColorFilter：使用图像的亮度在两个用户指定的颜色之间混合

firstColor：状语从句：第一第二颜色组分别指定什么颜色组替换图像的暗区域亮状语从句：区域默认值为（0.0,0.0,0.5）AMD公司（1.0,0.0,0.0）。
secondColor：
GPUImageHazeFilter：用于添加或删除雾度（类似于UV过滤器）

distance：应用的颜色的强度。-.3和.3之间的值最好。
斜率：颜色变化量。-.3和.3之间的值最好。
GPUImageSepiaFilter：简单的棕褐色调滤波器

intensity：棕黄色代替正常图像颜色的程度（0.0 - 1.0，默认为1.0）
GPUImageOpacityFilter：调整传入图像的Alpha通道

opacity：将每个像素的传入alpha通道乘以（0.0 - 1.0，默认值为1.0）的值，
GPUImageSolidColorGenerator：这将输出生成的图像的纯色。您需要使用-forceProcessingAtSize定义图像大小：

color：以四分格式显示的颜色，用于填充图像。
GPUImageLuminanceThresholdFilter：亮度高于阈值的像素将显示为白色，下面的像素将为黑色

threshold：亮度阈值，从0.0到1.0，默认值为0.5
GPUImageAdaptiveThresholdFilter：确定像素周边的局部亮度，然后如果像素低于该局部亮度，则将像素变为黑色，如果以上则为白色。这可以用于在不同的照明条件下挑选文本。

blurRadiusInPixels：背景平均模糊半径（以像素为单位）的乘数，默认值为4。
GPUImageAverageLuminanceThresholdFilter：这个应用阈值操作，其中基于场景的平均亮度连续地调整阈值。

thresholdMultiplier：这是平均亮度将被乘以的因子，以便达到要使用的最下限阈值。
GPUImageHistogramFilter：它分析传入的图像，并且创建一个输出直方图，其中出现每个颜色值的频率。该滤波器的输出是3像素高，256像素宽的图像，其中发生各种颜色值的频率的像素。每个颜色值占据256个宽度位置中的一个，从左边的0到右边的255. 可以针对各个颜色通道（kGPUImageHistogramRed，kGPUImageHistogramGreen，kGPUImageHistogramBlue），图像的亮度（kGPUImageHistogramLuminance ）或者一次针对所有三个颜色通道（kGPUImageHistogramRGB）生成该直方图。

downsamplingFactor：这不是对每个像素进行采样，而是指示图像的哪个部分被采样。默认情况下，这是16，最小值为1.这是需要防止饱和直方图，它只能记录每个颜色值的256个像素，在它变得重载之前。
GPUImageHistogramGenerator：这是一个特殊的过滤器，因为它主要打算使用GPUImageHistogramFilter。它生成由GPUImageHistogramFilter生成的颜色直方图的输出表示，但它可以重新用于显示其他类型的值。它采取一个图像，看中心垂直）像素。然后它在输出纹理中的单独的彩色图表中绘制RGB分量的数值。您可能需要强制此过滤器的大小，以其输出可见。

GPUImageAverageColor：通过对图像中每个像素的RGBA分量进行平均，处理输入图像并确定场景的平均颜色。使用缩小处理来逐步向下取样GPU上的源图像，接着在CPU进行上短的平均计算此过滤器的输出无意义，但您需要将colorAverageProcessingFinishedBlock属性设置为接收四个颜色分块和一个帧时间的块，并对它们执行某些操作。

GPUImageLuminosity：像GPUImageAverageColor一样，这会将图像缩小到其平均亮度。你需要设置luminosityProcessingFinishedBlock来处理这个过滤器的输出，它会返回一个光度值和一个帧时间。

GPUImageChromaKeyFilter：对于图像中的给定颜色，将Alpha通道设置为0.这与GPUImageChromaKeyBlendFilter类似，只是不是在第二个图像中混合匹配的颜色，这不在第二个图像中，颜色透明。

thresholdSensitivity：颜色匹配需要存在到要求的目标颜色的接近程度（默认值为0.4）
平滑：如何平滑地混合颜色匹配（默认值为0.1）
图像处理

GPUImageTransformFilter：这将对应图像应用任意的2-D或3-D变换

affineTransform：这需要一个CGAffineTransform来调整2-D图像
transform3D：这需要一个CATransform3D来操纵3-D中的图像
ignoreAspectRatio：默认情况下，保持变换图像的宽高比，但可以将其设置为YES，use变换与宽高比无关
GPUImageCropFilter：将图像裁剪到特定区域，然后只将该区域传递到过滤器的下一个阶段

cropRegion：裁剪出图像的矩形区域，标准化为0.0 - 1.0的坐标。（0.0,0.0）位置在图像的左上角。
GPUImageLanczosResamplingFilter：这使您可以使用Lanczos重采样对图像进行上采样或下采样，这将产生比标准线性或三线性插值明显更好的质量。只需使用-forceProcessingAtSize：设置过滤器的目标输出分辨率，并且将为该新大小重新采样图像。

GPUImageSharpenFilter：锐化图像

锐度：应用的锐度调整（-4.0 - 4.0，默认值为0.0）
GPUImageUnsharpMaskFilter：应用反锐化掩码

blurRadiusInPixels：底层高斯模糊的模糊半径。
intensity：锐化的强度，从0.0开始，默认值为1.0
GPUImageGaussianBlurFilter：一种硬件优化，可变半径高斯模糊

texelSpacingMultiplier：范围从0.0开始，默认值为1.0。调整这可能会稍微增加模糊强度，但会在结果中引入伪影。强烈建议先使用其他参数，然后触摸此一个。
blurRadiusInPixels：用于模糊的半径（以像素为单位），默认值为2.0。这调整了高斯分布函数中的σ变量。
blurRadiusAsFractionOfImageWidth：
blurRadiusAsFractionOfImageHeight：设置这些属性将允许模糊半径随图像大小缩放
blurPasses：顺序模糊输入图像的次数。通过越多，过滤器越慢。
GPUImageBoxBlurFilter：一个硬件优化，可变半径框模糊

texelSpacingMultiplier：范围从0.0开始，默认值为1.0。调整这可能会稍微增加模糊强度，但会在结果中引入伪影。强烈建议先使用其他参数，然后触摸此一个。
blurRadiusInPixels：用于模糊的半径（以像素为单位），默认值为2.0。这调整了高斯分布函数中的σ变量。
blurRadiusAsFractionOfImageWidth：
blurRadiusAsFractionOfImageHeight：设置这些属性将允许模糊半径随图像大小缩放
blurPasses：顺序模糊输入图像的次数。通过越多，过滤器越慢。
GPUImageSingleComponentGaussianBlurFilter：仅对红色组件操作的GPUImageGaussianBlurFilter的修改

texelSpacingMultiplier：范围从0.0开始，默认值为1.0。调整这可能会稍微增加模糊强度，但会在结果中引入伪影。强烈建议先使用其他参数，然后触摸此一个。
blurRadiusInPixels：用于模糊的半径（以像素为单位），默认值为2.0。这调整了高斯分布函数中的σ变量。
blurRadiusAsFractionOfImageWidth：
blurRadiusAsFractionOfImageHeight：设置这些属性将允许模糊半径随图像大小缩放
blurPasses：顺序模糊输入图像的次数。通过越多，过滤器越慢。
GPUImageGaussianSelectiveBlurFilter：保持圆形区域内焦点的高斯模糊

blurRadiusInPixels：用于模糊的像素的半径，默认值为5.0。这调整了高斯分布函数中的σ变量。
excludeCircleRadius：从模糊中排除的圆形区域的半径
excludeCirclePoint：从模糊中排除的圆形区域的中心
excludeBlurSize：模糊部分和清晰圆之间的区域的大小
aspect ratio：图像的宽高比，用于调整对焦区域的圆形度。默认情况下，这与图像宽高比相匹配，但您可以覆盖此值。
GPUImageGaussianBlurPositionFilter：GPUImageGaussianSelectiveBlurFilter的逆，只在特定圆圈内应用模糊

blurSize：模糊大小的乘数，范围从0.0开始，默认值为1.0
blurCenter：模糊的中心，默认为0.5,0.5
blurRadius：模糊的半径，默认为1.0
GPUImageiOSBlurFilter：尝试复制在图片控制中心这样的iOS 7上使用的背景模糊。

blurRadiusInPixels：用于模糊的半径（以像素为单位），默认值为12.0。这调整了高斯分布函数中的σ变量。
“饱和度”英文“饱和度” 英文“饱和度”英文“饱和度”英文“饱和度
下采样：下采样，然后上采样输入图像以最小化高斯模糊内的计算的程度，默认为4.0。
GPUImageMedianFilter：获取三个颜色分量的中值，超过3x3区域

GPUImageBilateralFilter：双边模糊，它试图模糊相似的颜色值，同时保留锐利的边缘

texelSpacingMultiplier：texel 读取间距的乘数，范围从0.0开始，默认值为4.0
distanceNormalizationFactor：中心颜色和样本颜色之间的距离归一化因子，默认值为8.0。
GPUImageTiltShiftFilter：模拟倾斜移位镜头效果

blurRadiusInPixels：底层模糊的半径，以像素为单位。
topFocusLevel：图片中对焦区域顶部的标准化位置，此值应低于bottomFocusLevel，默认为0.4
bottomFocusLevel：图片中对焦区域底部的归一化位置，此值应高于topFocusLevel，默认为0.6
focusFallOffRate：图像变得离开对焦区域的速率，默认为0.2
GPUImage3x3ConvolutionFilter：针对映像运行3x3卷积内核

卷积核：卷积核是应用于像素及其8个周围像素的值的3×3矩阵。矩阵以行主要顺序指定，左上角的像素为one.one，右下角为三。如果矩阵中的value不等于1.0，则图像可以变亮或变暗。
GPUImageSobelEdgeDetectionFilter：Sobel边缘检测，边缘以白色突出显示

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
edgeStrength：调整滤波器的动态范围。值越高，边缘越强，但可以使强度色空间饱和。
GPUImagePrewittEdgeDetectionFilter：Prewitt边缘检测，边缘以白色突出显示

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
edgeStrength：调整滤波器的动态范围。值越高，边缘越强，但可以使强度色空间饱和。
GPUImageThresholdEdgeDetectionFilter：执行Sobel边缘检测，但应用阈值，而不提供渐进强度值

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
edgeStrength：调整滤波器的动态范围。值越高，边缘越强，但可以使强度色空间饱和。
threshold：高于此阈值的任何边将为黑色，任何低于白色的边。范围从0.0到1.0，默认为0.8
GPUImageCannyEdgeDetectionFilter：这使用完整的Canny过程来突出显示一个像素宽的边缘

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
blurRadiusInPixels：高斯模糊的基础模糊半径。
blurTexelSpacingMultiplier：底层模糊纹理像素间距乘数。
upperThreshold：front threshold：任意边缘，将默认值设为0.4。
lowerThreshold：梯度幅度低于此阈值的任何边将失败，并从最终结果中删除。
GPUImageHarrisCornerDetectionFilter：对输入图像运行哈里斯角点检测算法，并生成一个图像，这些角点为白色像素，一切为黑色。可以设置cornersDetectedBlock，并且您将获得一个角度列表（在标准化的0..1 X， Y坐标），在回调中你想要执行的任何额外的操作。

blurRadiusInPixels：底层高斯模糊的半径。
灵敏度：应用于调整过滤器中生成的角点的动态范围的内部缩放因子。
门槛：将点检测为角的阈值。这可以根据大小，照明条件和iOS的设备摄像头类型显着变化，因此可能需要一些实验来适当的情况。默认值为0.20。
GPUImageNobleCornerDetectionFilter：在哈里斯角点检测器上运行Noble变量。它的行为如上所述的哈里斯检测器。

blurRadiusInPixels：底层高斯模糊的半径。
灵敏度：应用于调整过滤器中生成的角点的动态范围的内部缩放因子。
门槛：将点检测为角的阈值。这可以根据大小，照明条件和iOS的设备摄像头类型显着变化，因此可能需要一些实验来适当的情况。默认值为0.2。
GPUImageShiTomasiCornerDetectionFilter：运行Shi-Tomasi特征检测器。它的行为如上所述的哈里斯检测器。

blurRadiusInPixels：底层高斯模糊的半径。
灵敏度：应用于调节过滤器中生成的角点的动态范围的内部缩放因子。
门槛：将点检测为角的阈值。这可以根据大小，照明条件和iOS的设备摄像头类型显着变化，因此可能需要一些实验来适当的情况。默认值为0.2。
GPUImageNonMaximumSuppressionFilter：当前仅用作哈里斯角点检测滤波器的一部分，这将对每个像素周围的1像素框进行采样，并中心确定的像素红色通道是否的英文该区域中的最大值如果的英文，它停留。如果不是，则对于所有颜色分量将其设置为0。

GPUImageXYDerivativeFilter：哈里斯角点检测滤波器内的一个内部组件，它计算这个点左右像素之间的平方差，这个点之上和之下的像素的平方差，以及这两个差值的乘积。

GPUImageCrosshairGenerator：它在图像上绘制一系列十字线，最常用于识别机器视觉特征。它不像其他过滤器那样接受标准图像，而是在其–renderCrosshairsFromArray：count：方法中包含一系列点，这是实际绘图。您将需要强制此过滤器以您需要的特定输出大小进行渲染。

crosshairWidth：要在屏幕上绘制的十字准线的宽度（以像素为单位）。
GPUImageDilationFilter：这执行图像扩张操作，其中矩形邻域的红色通道的最强强度用于该像素的强度。初始化时指定采样的矩形区域的半径，范围为1-4个像素。这是为了用灰度图像，它扩展明亮的区域。

GPUImageRGBDilationFilter：这与GPUImageDilationFilter相同，只是它作用于所有颜色通道，而不只是红色通道。

GPUImageErosionFilter：执行图像侵蚀操作，其中矩形邻域中的红色通道的最强度用于该像素的强度。初始化时指定采样的矩形区域的半径，范围为1-4个像素。这是用于灰度图像，它扩展黑暗区域。

GPUImageRGBErosionFilter：这与GPUImageErosionFilter相同，只是它在所有颜色通道上起作用，而不只是红色通道。

GPUImageOpeningFilter：这对图像的红色通道执行侵蚀，随后是相同半径的膨胀。初始化时间设置半径，范围为1-4个像素。

GPUImageRGBOpeningFilter：这与GPUImageOpeningFilter相同，除了这个作用于所有颜色通道，而不只是红色通道。

GPUImageClosingFilter：它对图像的红色通道执行扩展，然后是相同半径的侵蚀。初始化时间设置半径，范围为1-4个像素。

GPUImageRGBClosingFilter：这与GPUImageClosingFilter相同，除了这个作用于所有颜色通道，而不只是红色通道。

GPUImageLocalBinaryPatternFilter：它执行8个周围像素和中心像素的红色通道的强度的比较，将比较结果编码成成为该像素强度的位串。最低有效位是右上角比较，逆时针转向以正确的比较结束作为最高有效位。

GPUImageLowPassFilter：对于输入的视频帧应用一个低通滤波器。这基本上累积了当前帧和当前帧的加权滚动平均值它可以用于去噪视频，添加运动模糊或用于创建高通滤波器。

filterStrength：这控制了前一个累加帧与当前帧的混合程度。范围从0.0到1.0，默认值为0.5。
GPUImageHighPassFilter：对输入的视频帧应用高通滤波器。这是低通滤波器的反相，示出了当前帧与前一帧的加权滚动平均值之间的差。这对运动检测最有用。

filterStrength：this控制先前累加的帧被混合的程度，然后从当前的累加帧中减去。范围从0.0到1.0，默认值为0.5。
GPUImageMotionDetector：这是一个基于高通滤波器的运动检测器。您设置motionDetectionBlock，并且在每个传入帧中，它将为您提供场景中任何检测到的运动的质心（以标准化的X，Y坐标）以及场景的运动强度。

lowPassFilterStrength：this控制了幕后使用的低通滤波器的强度，以建立与输入帧进行比较的基线。范围从0.0到1.0，默认值为0.5。
GPUImageHoughTransformLineDetector：使用霍夫变换检测图像中的线到平行坐标空间。这种方法完全基于由布尔诺科技大学的Graph @ FIT研究小组开发的PC线路过程，并在他们的出版物中描述：M.Dubská ，J.Havel，and A.Helout。使用平行坐标和OpenGL的线的实时检测。Proceedings of SCCG 2011，Bratislava，SK，第7 页（http://medusa.fit.vutbr.cz/public/data/论文/ 2011-SCCG-Dubska-Real-Time-Line-Detection-Using-PC-and-OpenGL.pdf）和M.Dubská，J.Havel，Herout。PClines -使用平行坐标的线检测。2011年计算机视觉与模式识别（CVPR）IEEE刀豆ference，对1489年至1494年（http://medusa.fit.vutbr.cz/public/data/papers /2011-CVPR-Dubska-PClines.pdf）。

edgeThreshold：检测到点属于用于确定线的边缘的阈值。
lineDetectionThreshold：检测到局部最大值属于平行坐标空间中的线的阈值。
linesDetectedBlock：在检测行时调用此块，通常在每个处理的帧上。包含m，b对（y = mx + b）中的归一化斜率和截距的AC阵列与所检测的线的数目和视频帧的当前时间戳的计数一起被传入。
GPUImageLineGenerator：生成可以覆盖场景的线的辅助类。这些线的颜色可以使用-setLineColorRed：green：blue：

lineWidth：行的宽度（以像素为单位），默认值为1.0。
GPUImageMotionBlurFilter：对图像应用定向运动模糊

blurSize：模糊大小的乘数，范围从0.0开始，默认值为1.0
blurAngle：模糊的角度方向，以度为单位。
GPUImageZoomBlurFilter：对图像应用定向运动模糊

blurSize：模糊大小的乘数，范围从0.0开始，默认值为1.0
blurCenter：模糊的标准化中心。（0.5,0.5）
混合模式

GPUImageChromaKeyBlendFilter：use第二个图像选择性替换第一个图像中的颜色

thresholdSensitivity：颜色匹配需要存在到要求的目标颜色的接近程度（默认值为0.4）
平滑：如何平滑地混合颜色匹配（默认值为0.1）
GPUImageDissolveBlendFilter：应用两个图像的溶解混合

mix：第二个图像覆盖第一个图像的程度（0.0-1.0，默认为0.5）
GPUImageMultiplyBlendFilter：应用两个图像的乘法混合

GPUImageAddBlendFilter：应用两个图像的加法混合

GPUImageSubtractBlendFilter：应用两个图像的减法混合

GPUImageDivideBlendFilter：应用两个图像的分割混合

GPUImageOverlayBlendFilter：应用两个图像的叠加混合

GPUImageDarkenBlendFilter：通过获取图像之间每个颜色分量的最小值来混合两个图像

GPUImageLightenBlendFilter：通过获取图像之间每个颜色分量的最大值来混合两个图像

GPUImageColorBurnBlendFilter：应用两个图像的颜色混合

GPUImageColorDodgeBlendFilter：应用两个图像的颜色闪避混合

GPUImageScreenBlendFilter：应用两个图像的屏幕混合

GPUImageExclusionBlendFilter：应用两个图像的排除混合

GPUImageDifferenceBlendFilter：应用两个图像的差异混合

GPUImageHardLightBlendFilter：应用一个硬光混合的两个图像

GPUImageSoftLightBlendFilter：应用两个图像的柔和光混合

GPUImageAlphaBlendFilter：根据第二个alpha通道，将第二个图像混合在第一个图像上

mix：第二个图像覆盖第一个图像的程度（0.0 - 1.0，默认为1.0）
GPUImageSourceOverBlendFilter：在两个图像的混合上应用源

GPUImageColorBurnBlendFilter：应用两个图像的颜色混合

GPUImageColorDodgeBlendFilter：应用两个图像的颜色闪避混合

GPUImageNormalBlendFilter：应用两个图像的正常混合

GPUImageColorBlendFilter：应用两个图像的颜色混合

GPUImageHueBlendFilter：应用两个图像的色调混合

GPUImageSaturationBlendFilter：应用两个图像的饱和混合

GPUImageLuminosityBlendFilter：应用两个图像的亮度混合

GPUImageLinearBurnBlendFilter：应用两个图像的线性刻录混合

GPUImagePoissonBlendFilter：应用两个图像的泊松混合

混合：混合范围从0.0（只有图像1）到1.0（只有图像2梯度），1.0为正常水平
numIterations：传播梯度的次数如果你想获得任何接近收敛，这个高达100或甚至1000 是的，这会很慢。
GPUImageMaskFilter：使用另一个图像掩蔽一个图像

视觉效果

GPUImagePixellateFilter：对图像或视频应用像素化效果

fractionalWidthOfAPixel：像素的大小，作为图像宽度和高度的一部分（0.0 - 1.0，默认为0.05）
GPUImagePolarPixellateFilter：对图片或视频应用像素化效果，基于极坐标，而不是笛卡尔坐标

center：应用像素的中心，默认为（0.5,0.5）
pixelSize：分别像素大小，拆分为width和height组件。默认值为（0.05,0.05）
GPUImagePolkaDotFilter：将图像分割成常规网格中的彩色点

fractionalWidthOfAPixel：点的大小，作为图像宽度和高度的一部分（0.0 - 1.0，默认为0.05）
dotScaling：每个网格空间的小部分由一个点占据，从0.0到1.0，默认值为0.9。
GPUImageHalftoneFilter：对图像应用半色调效果，如新闻打印

fractionalWidthOfAPixel：半色调点的大小，作为图像宽度和高度的一部分（0.0 - 1.0，默认为0.05）
GPUImageCrosshatchFilter：将图像转换为黑白交叉阴影图案

crossHatchSpacing：图像的分数宽度，用作交叉影线的间距。
lineWidth：交叉线的相对宽度。默认值为0.003。
GPUImageSketchFilter：将视像转换为外观像草图。这只是Sobel边缘检测滤镜的颜色反转

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
edgeStrength：调整滤波器的动态范围。值越高，边缘越强，但可以使强度色空间饱和。
GPUImageThresholdSketchFilter：与草图过滤器相同，只有边缘是阈值，而不是灰度

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
edgeStrength：调整滤波器的动态范围。值越高，边缘越强，但可以使强度色空间饱和。
threshold：高于此阈值的任何边将为黑色，任何低于白色的边。范围从0.0到1.0，默认为0.8
GPUImageToonFilter：这使用Sobel边缘检测在对象周围放置一个黑色边框，然后它量化图像中呈现的颜色，以给图像一个卡通般的质量。

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
threshold：边缘检测的灵敏度，较低的值更敏感。范围从0.0到1.0，默认为0.2
quantizationLevels：在最终图像中表示的颜色级别的数量。默认值为10.0
GPUImageSmoothToonFilter：这使用与GPUImageToonFilter类似的过程，只有它之前的toon效果与高斯模糊，以平滑噪声。

texelWidth：
texelHeight：这些参数影响检测到的边缘的可见性
blurRadiusInPixels：底层高斯模糊的半径。
threshold：边缘检测的灵敏度，较低的值更敏感。范围从0.0到1.0，默认为0.2
quantizationLevels：在最终图像中表示的颜色级别的数量。默认值为10.0
GPUImageEmbossFilter：在图像上应用浮雕效果

强度：压花的强度，从0.0到4.0，用1.0作为正常水平
GPUImagePosterizeFilter：这将颜色动态范围减少到指定的步骤数，导致图像的卡通式简单阴影。

colorLevels：将图像空间缩小到的颜色级数。取值范围为1〜256，缺省值为10。
GPUImageSwirlFilter：在图像上创建漩涡失真

radius：从中心到应用失真的半径，默认值为0.5
center：图像的中心（从0 - 1.0的归一化坐标），默认为（0.5,0.5）
angle：应用于图像的扭曲量，默认值为1.0
GPUImageBulgeDistortionFilter：在图像上创建凸起失真

radius：从中心到应用失真的半径，默认值为0.25
center：图像的中心（从0 - 1.0的归一化坐标），对于其将失真，默认为（0.5,0.5）
scale：应用的失真量，从-1.0到1.0，默认值为0.5
GPUImagePinchDistortionFilter：创建图像的混合失真

radius：从中心到应用失真的半径，默认值为1.0
center：图像的中心（从0 - 1.0的归一化坐标），对于其将失真，默认为（0.5,0.5）
scale：应用的失真量，从-2.0到2.0，默认值为1.0
GPUImageStretchDistortionFilter：创建图像的拉伸失真

center：图像的中心（从0 - 1.0的归一化坐标），对于其将失真，默认为（0.5,0.5）
GPUImageSphereRefractionFilter：模拟通过玻璃球的折射

center：应用失真的中心，默认为（0.5,0.5）
radius：失真的半径，范围从0.0到1.0，默认值为0.25
refractiveindex：球体的折射率，默认值为0.71
GPUImageGlassSphereFilter：与GPUImageSphereRefractionFilter相同，只有图像不被反转，并且在玻璃的边缘有一点点结霜

center：应用失真的中心，默认为（0.5,0.5）
radius：失真的半径，范围从0.0到1.0，默认值为0.25
refractiveindex：球体的折射率，默认值为0.71
GPUImageVignetteFilter：执行渐晕效果，在边缘淡出图像

vignetteCenter：tex coords中的小插曲的中心（CGPoint），默认值为0.5,0.5
vignetteColor：用于小插曲（GPUVector3）的颜色，默认为黑色
vignetteStart：从晕影效果开始的中心的标准化距离，默认值为0.5
vignetteEnd：从晕影效果结束的中心的标准化距离，默认值为0.75
GPUImageKuwaharaFilter：Kuwahara图像抽象，绘制自Kyprianidis等人的工作。et al。在他们的出版物“GPU中”英文相邻词汇热门词汇“GPU” 英文“昂贵的，因此它可能需要几秒钟来渲染在iPad 2上的框架。这可能最适合用于静态图像。

radius：整数，指定应用滤镜时从中心像素向外测试的像素数，默认值为4.较高的值会创建更抽象的图像，但代价是处理时间更长。
GPUImageKuwaharaRadius3Filter：一个修改版本的Kuwahara过滤器，优化工作超过三个像素的半径

GPUImagePerlinNoiseFilter：生成一个充满Perlin噪声的图像

colorStart：
colorFinish：生成噪声的颜色范围
scale：正在生成的噪声的缩放
GPUImageCGAColorspaceFilter：模拟CGA显示器的色彩空间

GPUImageMosaicFilter：此过滤器接受一个输入的瓷砖集，瓷砖必​​须以亮度上升。它查看输入图像并根据该瓦片的亮度用输入瓦片替换每个显示瓦片。这个想法是复制在其他应用程序中看到的ASCII视频过滤器，但是tileset可以是任何东西。

inputTileSize：
numTiles：
displayTileSize：
colorOn：
GPUImageJFAVoronoiFilter：生成Voronoi地图，供以后阶段使用。

sizeInPixels：单个元素的大小
GPUImageVoronoiConsumerFilter：在Voronoi地图中，并使用它来过滤进入的图像。

sizeInPixels：单个元素的大小

先来介绍几个基础概念

1、GPUImageFilter

GPUImage的滤镜的基类
作用：
1.都遵守GPUImageInput的协议
2.获得响应链上游的纹理，经过自己的处理，生成新的纹理，向响应链的下一个对象传递

extern NSString *const kGPUImageVertexShaderString;//顶点着色器
extern NSString *const kGPUImagePassthroughFragmentShaderString;//片段着色器

struct GPUVector4 {//4维坐标
    GLfloat one;
    GLfloat two;
    GLfloat three;
    GLfloat four;
};

typedef struct GPUVector4 GPUVector4;

struct GPUVector3 {//3维坐标系
    GLfloat one;
    GLfloat two;
    GLfloat three;
};
typedef struct GPUVector3 GPUVector3;

struct GPUMatrix4x4 {//4x4矩阵
    GPUVector4 one;
    GPUVector4 two;
    GPUVector4 three;
    GPUVector4 four;
};
typedef struct GPUMatrix4x4 GPUMatrix4x4;

struct GPUMatrix3x3 {{//3x3矩阵
    GPUVector3 one;
    GPUVector3 two;
    GPUVector3 three;
};
typedef struct GPUMatrix3x3 GPUMatrix3x3;

/** GPUImage's base filter class
GPUImage的滤镜的基类

 Filters and other subsequent elements in the chain conform to the GPUImageInput protocol, which lets them take in the supplied or processed texture from the previous link in the chain and do something with it. Objects one step further down the chain are considered targets, and processing can be branched by adding multiple targets to a single output or filter.
作用：
1.都遵守GPUImageInput的协议
2.获得响应链上游的纹理，经过自己的处理，生成新的纹理，向响应链的下一个对象传递
 */

@interface GPUImageFilter : GPUImageOutput <GPUImageInput>
{
    GPUImageFramebuffer *firstInputFramebuffer;//输入帧缓存

    GLProgram *filterProgram;//openGL源程序
    GLint filterPositionAttribute, filterTextureCoordinateAttribute;//顶点属性、纹理属性
    GLint filterInputTextureUniform;//输入纹理常量
    GLfloat backgroundColorRed, backgroundColorGreen, backgroundColorBlue, backgroundColorAlpha;//r  g  b  a

    BOOL isEndProcessing;//是否处理完成

    CGSize currentFilterSize;//当前滤镜的尺寸
    GPUImageRotationMode inputRotation;//旋转模式

    BOOL currentlyReceivingMonochromeInput;//是否接受黑白输入

    NSMutableDictionary *uniformStateRestorationBlocks;//
    dispatch_semaphore_t imageCaptureSemaphore;//信号量
}

@property(readonly) CVPixelBufferRef renderTarget;//像素对象
@property(readwrite, nonatomic) BOOL preventRendering;//是否方式渲染
@property(readwrite, nonatomic) BOOL currentlyReceivingMonochromeInput;//是否接受黑白输入

- (id)initWithVertexShaderFromString:(NSString *)vertexShaderString fragmentShaderFromString:(NSString *)fragmentShaderString;// init
- (id)initWithFragmentShaderFromString:(NSString *)fragmentShaderString;// init
- (id)initWithFragmentShaderFromFile:(NSString *)fragmentShaderFilename;// init
- (void)initializeAttributes;// init属性
- (void)setupFilterForSize:(CGSize)filterFrameSize;//设置滤镜尺寸
- (CGSize)rotatedSize:(CGSize)sizeToRotate forIndex:(NSInteger)textureIndex;//旋转尺寸
- (CGPoint)rotatedPoint:(CGPoint)pointToRotate forRotation:(GPUImageRotationMode)rotation;//旋转顶点
- (CGSize)sizeOfFBO;//帧缓存大小
+ (const GLfloat *)textureCoordinatesForRotation:(GPUImageRotationMode)rotationMode;//纹理旋转
- (void)renderToTextureWithVertices:(const GLfloat *)vertices textureCoordinates:(const GLfloat *)textureCoordinates;//根据顶点和纹理渲染
- (void)informTargetsAboutNewFrameAtTime:(CMTime)frameTime;//通知响应链下游的对象
- (CGSize)outputFrameSize;//输出
/// 一些列set方法
- (void)setBackgroundColorRed:(GLfloat)redComponent green:(GLfloat)greenComponent blue:(GLfloat)blueComponent alpha:(GLfloat)alphaComponent;
- (void)setInteger:(GLint)newInteger forUniformName:(NSString *)uniformName;
- (void)setFloat:(GLfloat)newFloat forUniformName:(NSString *)uniformName;
- (void)setSize:(CGSize)newSize forUniformName:(NSString *)uniformName;
- (void)setPoint:(CGPoint)newPoint forUniformName:(NSString *)uniformName;
- (void)setFloatVec3:(GPUVector3)newVec3 forUniformName:(NSString *)uniformName;
- (void)setFloatVec4:(GPUVector4)newVec4 forUniform:(NSString *)uniformName;
- (void)setFloatArray:(GLfloat *)array length:(GLsizei)count forUniform:(NSString*)uniformName;

- (void)setMatrix3f:(GPUMatrix3x3)matrix forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setMatrix4f:(GPUMatrix4x4)matrix forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setFloat:(GLfloat)floatValue forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setPoint:(CGPoint)pointValue forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setSize:(CGSize)sizeValue forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setVec3:(GPUVector3)vectorValue forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setVec4:(GPUVector4)vectorValue forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setFloatArray:(GLfloat *)arrayValue length:(GLsizei)arrayLength forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;
- (void)setInteger:(GLint)intValue forUniform:(GLint)uniform program:(GLProgram *)shaderProgram;

- (void)setAndExecuteUniformStateCallbackAtIndex:(GLint)uniform forProgram:(GLProgram *)shaderProgram toBlock:(dispatch_block_t)uniformStateBlock;
- (void)setUniformsForProgramAtIndex:(NSUInteger)programIndex;

@end

2、GPUImageFramebuffer

GPUmageFramebuffer类用于管理帧缓冲对象，负责帧缓冲对象的创建和销毁，读取帧缓冲内容。

@property(readonly) CGSize size;//只读属性，在实现中，设置缓冲区的size
@property(readonly) GPUTextureOptions textureOptions;//纹理的选项
@property(readonly) GLuint texture;//管理纹理
@property(readonly) BOOL missingFramebuffer;//指示是否丢失帧缓冲对象

// Initialization and teardown
/*
创建一个size为framebufferSize大小的帧缓冲对象
参数 framebuffer的size。
返回：创建成功的帧缓冲对象。
*/
- (id)initWithSize:(CGSize)framebufferSize;
/*
创建一个size为framebufferSize大小的帧缓冲对象
参数：framebufferSize为framebuffer的size。fboTextureOptions是纹理的详细配置。onlyGenerateTexture说明是否只创建纹理而不创建陈帧缓冲对象。
返回：创建成功的帧缓冲对象。
*/
- (id)initWithSize:(CGSize)framebufferSize textureOptions:(GPUTextureOptions)fboTextureOptions onlyTexture:(BOOL)onlyGenerateTexture;
/*
创建一个size为framebufferSize大小的帧缓冲对象
参数：inputTexture为输入的纹理，用于渲染图片。
返回：创建成功的帧缓冲对象。
*/
- (id)initWithSize:(CGSize)framebufferSize overriddenTexture:(GLuint)inputTexture;

// Usage
- (void)activateFramebuffer;//激活刚创建的framebuffer对象。只有调用它后，才会起作用。

// Reference counting
- (void)lock;//引用计数管理 +1
- (void)unlock;//引用计数管理 -1
- (void)clearAllLocks;//引用计数管理 设置为0
- (void)disableReferenceCounting;//引用计数管理 禁用引用计数
- (void)enableReferenceCounting;//引用计数管理 启用引用计数

// Image capture
- (CGImageRef)newCGImageFromFramebufferContents;
- (void)restoreRenderTarget;//还原渲染目标对象

// Raw data bytes
- (void)lockForReading;//[锁](http://www.liuhaihua.cn/archives/tag/%e9%94%81)定PixelBuffer
- (void)unlockAfterReading;//解锁PixelBuffer
- (NSUInteger)bytesPerRow;//获取pixel buffer的行字节数
- (GLubyte *)byteBuffer;//获取pixel buffer的基地址

参考

GPUImage详细解析
GPUImage API文档之GPUImageFramebuffer类

简单的使用一下GPUImage

导入头文件

#import <GPUImageView.h>
#import <GPUImage/GPUImageSepiaFilter.h>//褐色怀旧

实现

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    UIImageView* imageView = [[UIImageView alloc] initWithFrame:self.view.bounds];
    [self.view addSubview:imageView];
    
    GPUImageSepiaFilter* filter = [[GPUImageSepiaFilter alloc] init];
    UIImage* image = [UIImage imageNamed:@"timg.jpeg"];
     [imageView setImage:[filter imageByFilteringImage:image]];
}

效果图

屏幕快照 2017-03-02 下午3.47.08.png

case 100:  
        {//            亮度  
            GPUImageBrightnessFilter *brightness = [[GPUImageBrightnessFilter alloc] init];//创建滤镜对象  
            brightness.brightness = vlaue;//设置亮度 -1.0 to 1.0 默认 0.0  
            [brightness forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [brightness useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:brightness];//渲染图片并显示  
        }  
            break;  
              
        case 101:  
        {//            曝光度  
            GPUImageExposureFilter *exposure = [[GPUImageExposureFilter alloc] init];//创建滤镜对象  
            exposure.exposure = vlaue;//设置亮度 -10 to 10 默认 0  
            [exposure forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [exposure useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:exposure];//渲染图片并显示  
        }  
            break;  
              
        case 102:  
        {//            对比度  
            GPUImageContrastFilter *contrast = [[GPUImageContrastFilter alloc] init];//创建滤镜对象  
            contrast.contrast = vlaue;//设置对比度 0 to 4 默认 1  
            [contrast forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [contrast useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:contrast];//渲染图片并显示  
        }  
            break;  
             
        case 103:  
        {//            饱和度  
            GPUImageSaturationFilter *saturation = [[GPUImageSaturationFilter alloc] init];//创建滤镜对象  
            saturation.saturation = vlaue;//设置饱和度 0 to 2 默认 1  
            [saturation forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [saturation useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:saturation];//渲染图片并显示  
        }  
            break;  
              
        case 104:  
        {//            锐化  
            GPUImageSharpenFilter *sharpen = [[GPUImageSharpenFilter alloc] init];//创建滤镜对象  
            sharpen.sharpness = vlaue;//设置饱和度 -4 to 4 默认 0  
            [sharpen forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [sharpen useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:sharpen];//渲染图片并显示  
        }  
            break;  
              
        case 105:  
        {//            形变  
            GPUImageTransformFilter *transform = [[GPUImageTransformFilter alloc] init];//创建滤镜对象  
            transform.transform3D = CATransform3DMakeScale(vlaue, vlaue, vlaue);//设置属性  
            [transform forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [transform useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:transform];//渲染图片并显示  
        }  
            break;  
              
        case 106:  
        {//            高斯模糊  
        GPUImageGaussianBlurFilter *gaussianBlur = [[GPUImageGaussianBlurFilter alloc] init];//创建滤镜对象  
            gaussianBlur.texelSpacingMultiplier = vlaue;  
            [gaussianBlur forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [gaussianBlur useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:gaussianBlur];//渲染图片并显示  
        }  
            break;  
              
        case 107:  
        {//            卡通效果  
             GPUImageToonFilter *sketch = [[GPUImageToonFilter alloc] init];//创建滤镜对象  
            sketch.quantizationLevels = 10;  
            [sketch forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [sketch useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:sketch];//渲染图片并显示  
        }  
            break;  
              
        case 108:  
        {//            球形倒立效果  
            GPUImageSphereRefractionFilter *glass = [[GPUImageSphereRefractionFilter alloc] init];//创建滤镜对象  
            glass.radius = vlaue; //设置球 半径  
            [glass forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [glass useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:glass];//渲染图片并显示  
        }  
            break;  
              
        case 109:  
        {//            怀旧效果  
            GPUImageSepiaFilter *sepia = [[GPUImageSepiaFilter alloc] init];//创建滤镜对象  
  
            [sepia forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [sepia useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:sepia];//渲染图片并显示  
        }  
            break;  
              
        case 110:  
        {//            反色效果  
            GPUImageColorInvertFilter *colorInvert = [[GPUImageColorInvertFilter alloc] init];//创建滤镜对象  
            [colorInvert forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [colorInvert useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:colorInvert];//渲染图片并显示  
        }  
            break;  
              
        case 111:  
        {//            色彩丢失效果  
        GPUImageColorPackingFilter *colorPacking = [[GPUImageColorPackingFilter alloc] init];//创建滤镜对象  
            [colorPacking forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [colorPacking useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:colorPacking];//渲染图片并显示  
        }  
            break;  
           
        case 112:  
        {//            晕影效果  
            GPUImageVignetteFilter *vigette = [[GPUImageVignetteFilter alloc] init];//创建滤镜对象  
            vigette.vignetteStart = 0;  
            [vigette forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [vigette useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:vigette];//渲染图片并显示  
        }  
            break;  
              
        case 113:  
        {//            交叉线效果  
            GPUImageCrosshatchFilter *crosshatch = [[GPUImageCrosshatchFilter alloc] init];//创建滤镜对象  
            crosshatch.crossHatchSpacing = vlaue;  
            [crosshatch forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [crosshatch useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:crosshatch];//渲染图片并显示  
        }  
            break;  
          
        case 114:  
        {//            哈哈镜效果  
        GPUImageStretchDistortionFilter *stretch = [[GPUImageStretchDistortionFilter alloc] init];//创建滤镜对象  
            stretch.center = CGPointMake(vlaue, vlaue);  
            [stretch forceProcessingAtSize:self.image.size];//设置要渲染的区域  
            [stretch useNextFrameForImageCapture];//捕获图片效果  
            [self filterWithObject:stretch];//渲染图片并显示  
        }  
            break;  
              

大概使用步骤是

1、创建亮度滤镜对象
GPUImageBrightnessFilter *filter = [[GPUImageBrightnessFilter alloc] init];
2、设置亮度的值
filter.brightness = value;
3、设置纹理尺寸
[filter forceProcessingAtSize:image.size];
4、创建GPUImagePicture对象
GPUImagePicture *pic = [[GPUImagePicture alloc] initWithImage:image];
5、向创建好的GPUImagePicture对象添加addTarget
[pic addTarget:filter];
6、处理图像（需要注意 使用processImage这个方法尽量要调用useNextFrameForImageCapture)
[pic processImage]; [filter useNextFrameForImageCapture];
7、获取处理后的图像
image ＝ [filter imageFromCurrentFramebuffer];

3、GPUImagePicture 图片处理类

GPUImagePicture是PGUImage的图像处理类，继承GPUImageOutput，一般作为响应链的源头。
GPUImagePicture类静态图像处理操作，它可以是需要处理的静态图像，也可以是一张作为纹理使用的图片，调用向它发送processImage消息，进行图像滤镜处理。

属性介绍
pixelSizeOfImage 图像的像素大小。
hasProcessedImage 图像是否已处理。
imageUpdateSemaphore 图像处理的GCD信号量。


方法介绍


- (id)initWithURL:(NSURL *)url
说明：使用指定url的图片来初始化GPUImagePicture
- (id)initWithImage:(UIImage *)newImageSource
说明：使用指定的UIImage对象来初始化GPUImagePicture
- (id)initWithCGImage:(CGImageRef)newImageSource
说明：使用指定的CGImageRef对象来初始化GPUImagePicture
- (id)initWithImage:(UIImage *)newImageSource smoothlyScaleOutput:(BOOL)smoothlyScaleOutput
说明：使用指定的UIImage对象来初始化GPUImagePicture，是否按比例调整输入图像的尺寸
- (void)processImage
说明：进行图像处理实际操作。
- (BOOL)processImageWithCompletionHandler:(void (^)(void))completion
说明：进行图像处理实际的操作，completion为当处理结束执行的操作。

4、GPUImageFilterGroup（组合滤镜）

GPUImageFilterGroup是多个filter的集合，terminalFilter为最终的filter，initialFilters为filter数组。GPUImageFilterGroup本身不绘制图像，对GPUImageFilterGroup添加删除Target操作的操作都会转为terminalFilter的操作。

常用混合滤镜

#import "GPUImageMultiplyBlendFilter.h"             //通常用于创建阴影和深度效果
  #import "GPUImageNormalBlendFilter.h"               //正常
  #import "GPUImageAlphaBlendFilter.h"                //透明混合,通常用于在背景上应用前景的透明度
  #import "GPUImageDissolveBlendFilter.h"             //溶解
  #import "GPUImageOverlayBlendFilter.h"              //叠加,通常用于创建阴影效果
  #import "GPUImageDarkenBlendFilter.h"               //加深混合,通常用于重叠类型
  #import "GPUImageLightenBlendFilter.h"              //减淡混合,通常用于重叠类型
  #import "GPUImageSourceOverBlendFilter.h"           //源混合
  #import "GPUImageColorBurnBlendFilter.h"            //色彩加深混合
  #import "GPUImageColorDodgeBlendFilter.h"           //色彩减淡混合
  #import "GPUImageScreenBlendFilter.h"               //屏幕包裹,通常用于创建亮点和镜头眩光
  #import "GPUImageExclusionBlendFilter.h"            //排除混合
  #import "GPUImageDifferenceBlendFilter.h"           //差异混合,通常用于创建更多变动的颜色
  #import "GPUImageSubtractBlendFilter.h"             //差值混合,通常用于创建两个图像之间的动画变暗模糊效果
  #import "GPUImageHardLightBlendFilter.h"            //强光混合,通常用于创建阴影效果
  #import "GPUImageSoftLightBlendFilter.h"            //柔光混合
  #import "GPUImageChromaKeyBlendFilter.h"            //色度键混合
  #import "GPUImageMaskFilter.h"                      //遮罩混合
  #import "GPUImageHazeFilter.h"                      //朦胧加暗
  #import "GPUImageLuminanceThresholdFilter.h"        //亮度阈
  #import "GPUImageAdaptiveThresholdFilter.h"         //自适应阈值
  #import "GPUImageAddBlendFilter.h"                  //通常用于创建两个图像之间的动画变亮模糊效果
  #import "GPUImageDivideBlendFilter.h"               //通常用于创建两个图像之间的动画变暗模糊效果

示例代码

// 图片输入源
    _inputImage = [UIImage imageNamed:@"icon"];

    // 初始化 picture
    _picture    = [[GPUImagePicture alloc] initWithImage:_inputImage smoothlyScaleOutput:YES];

    // 初始化 imageView
    _imageView  = [[GPUImageView alloc] initWithFrame:self.iconImageView.bounds];
    [self.iconImageView addSubview:_imageView];

    // 初始化 filterGroup
    _filterGroup = [[GPUImageFilterGroup alloc] init];
    [_picture addTarget:_filterGroup];


    // 添加 filter
    /**
     原理：
     1. filterGroup(addFilter) 滤镜组添加每个滤镜
     2. 按添加顺序（可自行调整）前一个filter(addTarget) 添加后一个filter
     3. filterGroup.initialFilters = @[第一个filter]];
     4. filterGroup.terminalFilter = 最后一个filter;

     */
    GPUImageRGBFilter *filter1         = [[GPUImageRGBFilter alloc] init];
    GPUImageToonFilter *filter2        = [[GPUImageToonFilter alloc] init];
    GPUImageColorInvertFilter *filter3 = [[GPUImageColorInvertFilter alloc] init];
    GPUImageSepiaFilter       *filter4 = [[GPUImageSepiaFilter alloc] init];
    [self addGPUImageFilter:filter1];
    [self addGPUImageFilter:filter2];
    [self addGPUImageFilter:filter3];
    [self addGPUImageFilter:filter4];

    // 处理图片
    [_picture processImage];
    [_filterGroup useNextFrameForImageCapture];

    self.iconImageView.image = [_filterGroup imageFromCurrentFramebuffer];

大神深度解析