Unity3D---通过Shader实现美颜

Unity3D---通过Shader实现美颜

最近项目需要用到美颜的效果，参考了不少文章，最终选择了上面的这篇文章中的做法，效果还可以。

原图 美颜-1
美颜-2

实现主要是分以下几步：

1.对原图进行脸部区域识别，得到一张mask图；

2.对原图进行双边滤波得到一张双边滤波纹理；

3.对双边过滤得到的纹理分别进行x，y方向的高斯处理得到一张高斯纹理；

4.对原图进行增强：模糊+细节*k（细节 = 原图 - 模糊）；

5.对得到的增强纹理的脸部区域（mask图）进行亮度提升（美白），得到最终纹理。

下面是源码：

Shader "Custom/Face/SkinCheck"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100
 
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
 
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
 
            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
 
            sampler2D _MainTex;
 
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }
 
            fixed4 check(fixed4 col)
            {
                //使用的是ycbcr颜色模型,一般肤色会在这个区间内
                //也可以使用RGB颜色模型，我试了下，感觉上面更准确
                half u = (-0.169 * col.r - 0.331 * col.g + 0.5 * col.b + 0.5) * 255;
                half v = (0.5 * col.r - 0.419 * col.g - 0.081 * col.b + 0.5) * 255;
 
                fixed t1 = saturate(sign(u - 80));
                fixed t2 = saturate(sign(121 - u));
                fixed t3 = saturate(sign(v - 124));
                fixed t4 = saturate(sign(175 - v));
 
                //肤色区域 t=1
                fixed t = sign(t1 * t2 * t3 * t4);
 
                //只显示肤色区域
                //return col * t;
 
                //记录下肤色区域 t = 1
                return fixed4(col.rgb, t);
            }
 
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                return check(col);
            }
            ENDCG
        }
 
        Pass
        {
            //降噪;
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
 
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
 
            struct v2f
            {
                float2 uv[9] : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
 
            sampler2D _MainTex;
            fixed4 _MainTex_TexelSize;
 
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
 
                half size = 1;
                for(int m = 0; m < 2; m++)
                {
                    for(int n = 0; n < 2; n++)
                    {
                        float x = _MainTex_TexelSize.x * (n - 1);
                        float y = _MainTex_TexelSize.y * (1 - m);
                        o.uv[m*3+n] = v.uv + float2(x, y) * size;
                    }
                }
 
                return o;
            }
 
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 color = tex2D(_MainTex, i.uv[4]);
 
                half alpha = 0;
 
                for(int m = 0; m < 2; m++)
                {
                    for(int n = 0; n < 2; n++)
                    {
                        fixed4 col = tex2D(_MainTex, i.uv[m*3+n]);
                        alpha += col.a;
                    }
                }
 
                half a0 = saturate((alpha - color.a - 0.5) * 10);//周围全黑;
                half a1 = 1 - saturate((alpha - color.a - 7.5) * 10);//周围全白;
 
                return color * a0 * a1;
                //return fixed4(color.rgb, color.a * a0 * a1);
            }
            ENDCG
        }
 
        Pass
        {
            //降噪---除去肤色小块;
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
 
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
 
            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
 
            sampler2D _MainTex;
            fixed4 _MainTex_TexelSize;
 
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                
                return o;
            }
 
            fixed isskin(v2f i)
            {
                float r = min(_ScreenParams.x, _ScreenParams.y);
                r = round(r * 0.2);
                int step = max(1, round(r * 0.1));
 
                half rate = 1;
                //向四个方向射出射线;
                for(int m = 0; m < 5; m++)
                {
                    half alpha = 0;
                    half count = 0.01;
 
                    for(int n = 0; n < r; n += step)
                    {
                        float x = n * ((m + 1) % 2) * sign(1 - m);
                        float y = n * (m % 2) * sign(2 - m);
                    
                        count += 1;
                        alpha += tex2D(_MainTex, i.uv + float2(x * _MainTex_TexelSize.x, y * _MainTex_TexelSize.y)).a;
                    }
 
                    //采样75%都是肤色,说明这个区域是脸部;
                    rate = rate * saturate((0.9 - alpha / count) * 1000);
                
                }
 
                return 1 - rate;
            }
 
 
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 color = tex2D(_MainTex, i.uv);
                
                return color * color.a * isskin(i);
                //return fixed4(color.rgb, color.a * rate);
            }
            ENDCG
        }
    }
}

Shader "Custom/Effect/BilateralFilters"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurSize("BlurSize", Range(1,12)) = 1
        _SigmaS("SigmaS", Range(1,10)) = 5
        _SigmaR("SigmaR", Range(0.01,1)) = 0.09
        _Range("Range", Range(1,10)) = 2
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100
 
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
 
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
 
            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
 
            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _BlurSize;
            float _SigmaS;
            float _SigmaR;
            float _Range;
 
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
 
                o.uv = v.uv;
 
                return o;
            }
 
            fixed4 bilater(v2f i)
            {
                half sigmas2 = 2 * _SigmaS * _SigmaS;//函数中常量系数,取5
                half sigmar2 = 2 * _SigmaR * _SigmaR;//函数中常量系数,取0.09
                half fenzi_r = 0,fenzi_g = 0,fenzi_b = 0;
                half fenmu_r = 0, fenmu_g = 0, fenmu_b = 0;
                fixed4 col = tex2D(_MainTex,i.uv);              
 
                for(int m = 0; m < 2*_Range+1; m++)
                {
                    half mpingfang = pow(m - _Range, 2);
                    for(int n = 0; n < 2*_Range+1; n++)
                    {
                        //_BlurSize为模糊级别，数值越大，模糊程度越高，图像失真也越大
                        fixed4 tcol = tex2D(_MainTex,i.uv + float2(_MainTex_TexelSize.x * (m-_Range), _MainTex_TexelSize.y * (n-_Range)) * _BlurSize);
  
                        fixed4 ncol = col - tcol;
                        half npingfang = pow((n-_Range),2);
                        half w_s = (mpingfang + npingfang) / sigmas2;
                        half wr = pow(2.718, -(w_s + ncol.r * ncol.r / sigmar2));//e常量=2.718...
                        half wg = pow(2.718, -(w_s + ncol.g * ncol.g / sigmar2));
                        half wb = pow(2.718, -(w_s + ncol.b * ncol.b / sigmar2));
                        fenmu_r += wr;
                        fenmu_g += wg;
                        fenmu_b += wb;
                        fenzi_r += wr * tcol.r;
                        fenzi_g += wg * tcol.g;
                        fenzi_b += wb * tcol.b;
                    }
                }
                return fixed4(fenzi_r/fenmu_r, fenzi_g/fenmu_g, fenzi_b/fenmu_b, col.a);
            }
 
            fixed4 frag (v2f i) : SV_Target
            {
                return bilater(i);
            }
            ENDCG
        }
    }
 
    FallBack Off
}

Shader "Custom/Effect/GaussBlur"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurSize("BlurSize", Range(0,20)) = 5
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100
 
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
 
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
 
            struct v2f
            {
                float2 uv[5] : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
 
            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _BlurSize;
 
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
 
                o.uv[0] = v.uv;
                //高斯-x方向的模糊(y方向同理)
                o.uv[1] = v.uv + float2(_MainTex_TexelSize.x * 1, 0) * _BlurSize;//_BlurSize模糊级别
                o.uv[2] = v.uv - float2(_MainTex_TexelSize.x * 1, 0) * _BlurSize;
                o.uv[3] = v.uv + float2(_MainTex_TexelSize.x * 2, 0) * _BlurSize;
                o.uv[4] = v.uv - float2(_MainTex_TexelSize.x * 2, 0) * _BlurSize;
 
                return o;
            }
 
            fixed4 frag (v2f i) : SV_Target
            {
                float weight[3] = {0.4026, 0.2442, 0.0545};
 
                fixed3 sum = tex2D(_MainTex, i.uv[0]).rgb * weight[0];
                
                for(int m = 1; m < 3; m++)
                {
                    sum += tex2D(_MainTex, i.uv[m * 2 - 1]).rgb * weight[m];
                    sum += tex2D(_MainTex, i.uv[m * 2]).rgb * weight[m];
                }
 
                return fixed4(sum, 1.0);
            }
            ENDCG
        }
 
 
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
 
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
 
            struct v2f
            {
                float2 uv[5] : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
 
            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _BlurSize;
 
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                
                o.uv[0] = v.uv;
 
                o.uv[1] = v.uv + float2(0, _MainTex_TexelSize.y * 1) * _BlurSize;
                o.uv[2] = v.uv - float2(0, _MainTex_TexelSize.y * 1) * _BlurSize;
                o.uv[3] = v.uv + float2(0, _MainTex_TexelSize.y * 2) * _BlurSize;
                o.uv[4] = v.uv - float2(0, _MainTex_TexelSize.y * 2) * _BlurSize;
 
                return o;
            }
 
            fixed4 frag (v2f i) : SV_Target
            {
                float weight[3] = {0.4026, 0.2442, 0.0545};
 
                fixed3 sum = tex2D(_MainTex, i.uv[0]).rgb * weight[0];
                
                for(int m = 1; m < 3; m++)
                {
                    sum += tex2D(_MainTex, i.uv[m * 2 - 1]).rgb * weight[m];
                    sum += tex2D(_MainTex, i.uv[m * 2]).rgb * weight[m];
                }
 
                return fixed4(sum, 1.0);
            }
            ENDCG
        }
    }
 
    FallBack Off
}

Shader "Custom/Face/Beauty"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurTex ("BlurTex", 2D) = "white" {}
        _GaussTex ("GaussTex", 2D) = "white" {}
        _SkinTex ("SkinTex", 2D) = "white" {}
 
        _SkinWhite("SkinWhite", Range(0,1)) = 0
        _Weight("Weight", Range(0,1)) = 0.2
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100
 
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
 
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
 
            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
 
            sampler2D _MainTex;
            float4 _BlurTex_TexelSize;
            sampler2D _BlurTex;
            sampler2D _GaussTex;
            sampler2D _SkinTex;
            float _SkinWhite;
            float4 _Weight;
 
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }
 
            fixed4 skin(fixed4 col)
            {
                half u = (-0.169 * col.r - 0.331 * col.g + 0.5 * col.b + 0.5) * 255;
                half v = (0.5 * col.r - 0.419 * col.g - 0.081 * col.b + 0.5) * 255;
 
                fixed t1 = saturate(sign(u - 80));
                fixed t2 = saturate(sign(121 - u));
                fixed t3 = saturate(sign(v - 124));
                fixed t4 = saturate(sign(175 - v));
 
                fixed t = sign(t1 * t2 * t3 * t4);
                return fixed4(col.r, col.g, col.b, t);
            }
 
            half luminance(fixed4 color){
                return 0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b;
            }
 
            fixed4 bright(fixed4 col)
            {
                //美颜提亮算法
                half BrightLevel = 5; 
                half3 temp = (0,0,0);
                temp.x = log(col.r * (BrightLevel - 1) + 1) / log(BrightLevel);
                temp.y = log(col.g * (BrightLevel - 1) + 1) / log(BrightLevel);
                temp.z = log(col.b * (BrightLevel - 1) + 1) / log(BrightLevel);
                return  fixed4(temp, col.a);
            }
 
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);      //原图
                fixed4 cskin = tex2D(_SkinTex, i.uv);    //肤色Mask
                fixed4 bilater = tex2D(_BlurTex, i.uv);  //双边过滤
                fixed4 gauss = tex2D(_GaussTex, i.uv);   //高斯模糊
                //按照我们的设想，只需要对肤色区域进行双边过滤，再提亮即可完成美颜
                //而实际上，这样做的效果不算理想，因为双边过滤算法虽然是保边算法，但它不可能做到绝对保边
                //因此，我们需要再给模糊后的纹理，增加脸部细节 
                //主要算法原理： 
                //1.原图 = 模糊 + 细节  --->  细节 = 原图 - 模糊   
                //2.增强 = 模糊 + 细节 * k
                //这一步具有很强的主观性，是试出来的 
                //0.2 * (col - bilater)   是取原图双边过滤剩下的细节
                //0.8 * (bilater - gauss) 是取原图双边过滤再高斯模糊剩下的细节
                half4 nblur = bilater + _Weight * (col - bilater) + (1 - _Weight) * (bilater - gauss);
                nblur.r = saturate(nblur.r);//防止颜色值溢出
                nblur.g = saturate(nblur.g);
                nblur.b = saturate(nblur.b);
                //使用肤色Mask，如果是肤色区域，即取模糊值，否则取原图
                fixed4 final = lerp(col, fixed4(nblur.rgb,1) , cskin.a);
                //提亮
                fixed4 cbright = bright(final);
                //根据提亮级别插值
                final = lerp(final, cbright , _SkinWhite);
             
                final.a = 1;
                return final;
            }
 
            ENDCG
        }
    }
 
    FallBack Off
}

using UnityEngine;

public class BeautyEffect : MonoBehaviour
{
    public Material bilateralFilterMat;
    public Material gaussBlurMat;
    public Material skinCheckMat;
    public Material beautyMat;

    private void OnRenderImage(RenderTexture src, RenderTexture dest)
    {
        Beauty(src,dest);
    }

    private void Beauty(RenderTexture src, RenderTexture dest)
    {
        RenderTexture tex0 = RenderTexture.GetTemporary(src.width,src.height);
        RenderTexture tex1 = RenderTexture.GetTemporary(src.width,src.height);
        RenderTexture tex2 = RenderTexture.GetTemporary(src.width,src.height);
        RenderTexture tex3 = RenderTexture.GetTemporary(src.width,src.height);
        
        //双边过滤
        Graphics.Blit(src,tex0,bilateralFilterMat);
        //高斯模糊
        //对双边过滤结果进行x方向高斯模糊
        Graphics.Blit(tex0,tex1,gaussBlurMat,0);
        //对双边过滤结果进行y方向高斯模糊
        Graphics.Blit(tex1,tex2,gaussBlurMat,1);
        
        //对原图进行肤色识别，得到肤色mask
        Graphics.Blit(src,tex1,skinCheckMat,0);
        //对肤色mask进行处理，减少噪点
        Graphics.Blit(tex1,tex3,skinCheckMat,1);
        RenderTexture.ReleaseTemporary(tex1);
        
        //将几张纹理图传入beauty.shader
        //我们将在beauty.shader中进行处理
        beautyMat.SetTexture("_BlurTex",tex0);//双边过滤得到的纹理
        beautyMat.SetTexture("_GaussTex",tex2);//对双边过滤结果进行高斯模糊得到的纹理
        beautyMat.SetTexture("_SkinTex",tex3);//原图进行肤色识别
        Graphics.Blit(src,dest,beautyMat);
        
        RenderTexture.ReleaseTemporary(tex0);
        RenderTexture.ReleaseTemporary(tex2);
        RenderTexture.ReleaseTemporary(tex3);
    }
}