附一張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：調整圖像的白平衡。

溫度：以oK單位為調整圖像的溫度值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];

大神深度解析