devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity3D---通过Shader实现美颜_unity 美颜

作者：我家小花儿 | 2024-02-21 11:46:20

赞

踩

unity 美颜

 

视频类APP没有美颜功能大概没人会用吧？

鉴于此，有点心血来潮，打算用Unity实现简单的美颜。

真正的商业级美颜算法是很复杂的，经过无数次打磨才成型，包括磨皮、美白、瘦脸、大眼等等细节，我这里只是用Unity3D的后处理技术做个简单的磨皮、美白。

首先，美颜一般针对的是脸部区域，我们得先识别出脸部区域。

完整的人脸识别算法，这在Unity3D中实现起来有点困难（不借助SDK），因此我们需要换个思路，仔细想想，我们也没必要进行人脸识别，我们大可识别出肤色区域，然后在肤色区域进行美颜。

  1. Shader "Extand/Face/SkinCheck"
  2. {
  3.     Properties
  4.     {
  5.         _MainTex ("Texture", 2D) = "white" {}
  6.     }
  7.     SubShader
  8.     {
  9.         Tags { "RenderType"="Opaque" }
  10.         LOD 100
  11.  
  12.         Pass
  13.         {
  14.             CGPROGRAM
  15.             #pragma vertex vert
  16.             #pragma fragment frag
  17.  
  18.             #include "UnityCG.cginc"
  19.  
  20.             struct appdata
  21.             {
  22.                 float4 vertex : POSITION;
  23.                 float2 uv : TEXCOORD0;
  24.             };
  25.  
  26.             struct v2f
  27.             {
  28.                 float2 uv : TEXCOORD0;
  29.                 float4 vertex : SV_POSITION;
  30.             };
  31.  
  32.             sampler2D _MainTex;
  33.  
  34.             v2f vert (appdata v)
  35.             {
  36.                 v2f o;
  37.                 o.vertex = UnityObjectToClipPos(v.vertex);
  38. 				o.uv = v.uv;
  39.                 return o;
  40.             }
  41.  
  42. 			fixed4 check(fixed4 col)
  43. 			{
  44.                 //使用的是ycbcr颜色模型,一般肤色会在这个区间内
  45.                 //也可以使用RGB颜色模型，我试了下，感觉上面更准确
  46. 			    half u = (-0.169 * col.r - 0.331 * col.g + 0.5 * col.b + 0.5) * 255;
  47. 				half v = (0.5 * col.r - 0.419 * col.g - 0.081 * col.b + 0.5) * 255;
  48.  
  49. 				fixed t1 = saturate(sign(u - 80));
  50. 				fixed t2 = saturate(sign(121 - u));
  51. 				fixed t3 = saturate(sign(v - 124));
  52. 				fixed t4 = saturate(sign(175 - v));
  53.  
  54.                 //肤色区域 t=1
  55. 				fixed t = sign(t1 * t2 * t3 * t4);
  56.  
  57.                 //只显示肤色区域
  58.                 //return col * t;
  59.  
  60.                 //记录下肤色区域 t = 1
  61. 				return fixed4(col.rgb, t);
  62. 			}
  63.  
  64.             fixed4 frag (v2f i) : SV_Target
  65.             {
  66.                 fixed4 col = tex2D(_MainTex, i.uv);
  67. 				return check(col);
  68.             }
  69.             ENDCG
  70.         }
  71.  
  72. 		Pass
  73.         {
  74. 		    //降噪;
  75.             CGPROGRAM
  76.             #pragma vertex vert
  77.             #pragma fragment frag
  78.  
  79.             #include "UnityCG.cginc"
  80.  
  81.             struct appdata
  82.             {
  83.                 float4 vertex : POSITION;
  84.                 float2 uv : TEXCOORD0;
  85.             };
  86.  
  87.             struct v2f
  88.             {
  89.                 float2 uv[9] : TEXCOORD0;
  90.                 float4 vertex : SV_POSITION;
  91.             };
  92.  
  93.             sampler2D _MainTex;
  94. 			fixed4 _MainTex_TexelSize;
  95.  
  96.             v2f vert (appdata v)
  97.             {
  98.                 v2f o;
  99.                 o.vertex = UnityObjectToClipPos(v.vertex);
  100.  
  101. 				half size = 1;
  102. 				for(int m = 0; m < 2; m++)
  103. 				{
  104. 				    for(int n = 0; n < 2; n++)
  105. 				    {
  106. 					    float x = _MainTex_TexelSize.x * (n - 1);
  107. 						float y = _MainTex_TexelSize.y * (1 - m);
  108. 				        o.uv[m*3+n] = v.uv + float2(x, y) * size;
  109. 				    }
  110. 				}
  111.  
  112.                 return o;
  113.             }
  114.  
  115.             fixed4 frag (v2f i) : SV_Target
  116.             {
  117. 			    fixed4 color = tex2D(_MainTex, i.uv[4]);
  118.  
  119.                 half alpha = 0;
  120.  
  121. 				for(int m = 0; m < 2; m++)
  122. 				{
  123. 				    for(int n = 0; n < 2; n++)
  124. 				    {
  125. 					    fixed4 col = tex2D(_MainTex, i.uv[m*3+n]);
  126. 						alpha += col.a;
  127. 				    }
  128. 				}
  129.  
  130. 				half a0 = saturate((alpha - color.a - 0.5) * 10);//周围全黑;
  131. 				half a1 = 1 - saturate((alpha - color.a - 7.5) * 10);//周围全白;
  132.  
  133. 				return color * a0 * a1;
  134. 				//return fixed4(color.rgb, color.a * a0 * a1);
  135.             }
  136.             ENDCG
  137.         }
  138.  
  139. 		Pass
  140.         {
  141. 		    //降噪---除去肤色小块;
  142.             CGPROGRAM
  143.             #pragma vertex vert
  144.             #pragma fragment frag
  145.  
  146.             #include "UnityCG.cginc"
  147.  
  148.             struct appdata
  149.             {
  150.                 float4 vertex : POSITION;
  151.                 float2 uv : TEXCOORD0;
  152.             };
  153.  
  154.             struct v2f
  155.             {
  156.                 float2 uv : TEXCOORD0;
  157.                 float4 vertex : SV_POSITION;
  158.             };
  159.  
  160.             sampler2D _MainTex;
  161. 			fixed4 _MainTex_TexelSize;
  162.  
  163.             v2f vert (appdata v)
  164.             {
  165.                 v2f o;
  166.                 o.vertex = UnityObjectToClipPos(v.vertex);
  167. 				o.uv = v.uv;
  168. 				
  169.                 return o;
  170.             }
  171.  
  172. 			fixed isskin(v2f i)
  173. 			{
  174. 			    float r = min(_ScreenParams.x, _ScreenParams.y);
  175. 				r = round(r * 0.2);
  176. 				int step = max(1, round(r * 0.1));
  177.  
  178. 				half rate = 1;
  179. 				//向四个方向射出射线;
  180. 			    for(int m = 0; m < 5; m++)
  181. 				{
  182. 				    half alpha = 0;
  183. 					half count = 0.01;
  184.  
  185. 					for(int n = 0; n < r; n += step)
  186. 					{
  187. 						float x = n * ((m + 1) % 2) * sign(1 - m);
  188. 						float y = n * (m % 2) * sign(2 - m);
  189. 					
  190. 					    count += 1;
  191. 					    alpha += tex2D(_MainTex, i.uv + float2(x * _MainTex_TexelSize.x, y * _MainTex_TexelSize.y)).a;
  192. 					}
  193.  
  194. 					//采样75%都是肤色,说明这个区域是脸部;
  195. 				    rate = rate * saturate((0.9 - alpha / count) * 1000);
  196. 				
  197. 				}
  198.  
  199. 				return 1 - rate;
  200. 			}
  201.  
  202.  
  203.             fixed4 frag (v2f i) : SV_Target
  204.             {
  205. 			    fixed4 color = tex2D(_MainTex, i.uv);
  206. 				
  207. 				return color * color.a * isskin(i);
  208. 				//return fixed4(color.rgb, color.a * rate);
  209. 			
  210.             }
  211.             ENDCG
  212.         }
  213.     }
  214. }

最终我们发现，肤色识别算法可以大体识别出肤色区域，但是会有噪点（环境中类似肤色的点被误识别），我们可以继续优化，去除部分噪点，也可以放任不管，毕竟这只是一个Mask， 环境中有少量的点被美颜了也没事。

接下来是磨皮，磨皮的本质是模糊算法，以祛痘祛斑。

模糊算法有很多，我这里主要选择的是双边滤波算法（一种保边算法），高斯模糊作为辅助，相较于一般模糊算法，双边滤波可以在降噪平滑的同时保留边缘的一些细节，至于具体的原理，请同学们自行搜索（懒Orz）

我们直接上核心源码，是不是简单粗暴？

  1. Shader "Extand/Effect/BilateralFilters"
  2. {
  3.     Properties
  4.     {
  5.         _MainTex ("Texture", 2D) = "white" {}
  6. 		_BlurSize("BlurSize", Range(1,12)) = 1
  7. 		_SigmaS("_SigmaS", Range(1,10)) = 5
  8. 		_SigmaR("_SigmaR", Range(0.01,1)) = 0.09
  9.     }
  10.     SubShader
  11.     {
  12.         Tags { "RenderType"="Opaque" }
  13.         LOD 100
  14.  
  15. 		Pass
  16.         {
  17.             CGPROGRAM
  18.             #pragma vertex vert
  19.             #pragma fragment frag
  20.             
  21.             #include "UnityCG.cginc"
  22.  
  23.             struct appdata
  24.             {
  25.                 float4 vertex : POSITION;
  26.                 float2 uv : TEXCOORD0;
  27.             };
  28.  
  29.             struct v2f
  30.             {
  31.                 float2 uv : TEXCOORD0;
  32.                 float4 vertex : SV_POSITION;
  33.             };
  34.  
  35.             sampler2D _MainTex;
  36.             float4 _MainTex_TexelSize;
  37. 			float _BlurSize;
  38. 			float _SigmaS;
  39. 			float _SigmaR;
  40.  
  41.             v2f vert (appdata v)
  42.             {
  43.                 v2f o;
  44.                 o.vertex = UnityObjectToClipPos(v.vertex);
  45.  
  46. 				o.uv = v.uv;
  47.  
  48.                 return o;
  49.             }
  50.  
  51. 			fixed4 bilater(v2f i)
  52. 			{
  53. 	            half sigmas2 = 2 * _SigmaS * _SigmaS;//函数中常量系数,取5
  54. 				half sigmar2 = 2 * _SigmaR * _SigmaR;//函数中常量系数,取0.09
  55. 				half fenzi_r = 0,fenzi_g = 0,fenzi_b = 0;
  56.                 half fenmu_r = 0, fenmu_g = 0, fenmu_b = 0;
  57. 				fixed4 col = tex2D(_MainTex,i.uv);				
  58.  
  59. 			    for(int m = 0; m < 5; m++)
  60. 				{
  61. 				    half mpingfang = pow(m - 2, 2);
  62. 				    for(int n = 0; n < 5; n++)
  63. 					{
  64.                         //_BlurSize为模糊级别，数值越大，模糊程度越高，图像失真也越大
  65. 					    fixed4 tcol = tex2D(_MainTex,i.uv + float2(_MainTex_TexelSize.x * (m-2), _MainTex_TexelSize.y * (n-2)) * _BlurSize);
  66.   
  67.                         fixed4 ncol = col - tcol;
  68. 			            half npingfang = pow((n-2),2);
  69. 						half w_s = (mpingfang + npingfang) / sigmas2;
  70. 						half wr = pow(2.718, -(w_s + ncol.r * ncol.r / sigmar2));//e常量=2.718...
  71. 						half wg = pow(2.718, -(w_s + ncol.g * ncol.g / sigmar2));
  72. 						half wb = pow(2.718, -(w_s + ncol.b * ncol.b / sigmar2));
  73. 						fenmu_r += wr;
  74. 						fenmu_g += wg;
  75. 						fenmu_b += wb;
  76. 						fenzi_r += wr * tcol.r;
  77. 						fenzi_g += wg * tcol.g;
  78. 						fenzi_b += wb * tcol.b;
  79. 				    }
  80. 				}
  81. 				return fixed4(fenzi_r/fenmu_r, fenzi_g/fenmu_g, fenzi_b/fenmu_b, col.a);
  82. 			}
  83.  
  84.             fixed4 frag (v2f i) : SV_Target
  85.             {
  86.                 return bilater(i);
  87.             }
  88.             ENDCG
  89.         }
  90.     }
  91.  
  92. 	FallBack Off
  93. }
  1. Shader "Extand/Effect/GaussBlur"
  2. {
  3.     Properties
  4.     {
  5.         _MainTex ("Texture", 2D) = "white" {}
  6. 		_BlurSize("BlurSize", Range(1,20)) = 5
  7.     }
  8.     SubShader
  9.     {
  10.         Tags { "RenderType"="Opaque" }
  11.         LOD 100
  12.  
  13.         Pass
  14.         {
  15.             CGPROGRAM
  16.             #pragma vertex vert
  17.             #pragma fragment frag
  18.             
  19.             #include "UnityCG.cginc"
  20.  
  21.             struct appdata
  22.             {
  23.                 float4 vertex : POSITION;
  24.                 float2 uv : TEXCOORD0;
  25.             };
  26.  
  27.             struct v2f
  28.             {
  29.                 float2 uv[5] : TEXCOORD0;
  30.                 float4 vertex : SV_POSITION;
  31.             };
  32.  
  33.             sampler2D _MainTex;
  34.             float4 _MainTex_TexelSize;
  35. 			float _BlurSize;
  36.  
  37.             v2f vert (appdata v)
  38.             {
  39.                 v2f o;
  40.                 o.vertex = UnityObjectToClipPos(v.vertex);
  41.  
  42. 				o.uv[0] = v.uv;
  43.                 //高斯-x方向的模糊(y方向同理)
  44. 				o.uv[1] = v.uv + float2(_MainTex_TexelSize.x * 1, 0) * _BlurSize;//_BlurSize模糊级别
  45. 				o.uv[2] = v.uv - float2(_MainTex_TexelSize.x * 1, 0) * _BlurSize;
  46. 				o.uv[3] = v.uv + float2(_MainTex_TexelSize.x * 2, 0) * _BlurSize;
  47. 				o.uv[4] = v.uv - float2(_MainTex_TexelSize.x * 2, 0) * _BlurSize;
  48.  
  49.                 return o;
  50.             }
  51.  
  52.             fixed4 frag (v2f i) : SV_Target
  53.             {
  54. 				float weight[3] = {0.4026, 0.2442, 0.0545};
  55.  
  56. 				fixed3 sum = tex2D(_MainTex, i.uv[0]).rgb * weight[0];
  57. 				
  58. 				for(int m = 1; m < 3; m++)
  59. 				{
  60. 				    sum += tex2D(_MainTex, i.uv[m * 2 - 1]).rgb * weight[m];
  61. 				    sum += tex2D(_MainTex, i.uv[m * 2]).rgb * weight[m];
  62. 				}
  63.  
  64.                 return fixed4(sum, 1.0);
  65.             }
  66.             ENDCG
  67.         }
  68.  
  69.  
  70. 		Pass
  71.         {
  72.             CGPROGRAM
  73.             #pragma vertex vert
  74.             #pragma fragment frag
  75.             
  76.             #include "UnityCG.cginc"
  77.  
  78.             struct appdata
  79.             {
  80.                 float4 vertex : POSITION;
  81.                 float2 uv : TEXCOORD0;
  82.             };
  83.  
  84.             struct v2f
  85.             {
  86.                 float2 uv[5] : TEXCOORD0;
  87.                 float4 vertex : SV_POSITION;
  88.             };
  89.  
  90.             sampler2D _MainTex;
  91.             float4 _MainTex_TexelSize;
  92. 			float _BlurSize;
  93.  
  94.             v2f vert (appdata v)
  95.             {
  96.                 v2f o;
  97.                 o.vertex = UnityObjectToClipPos(v.vertex);
  98.                 
  99. 				o.uv[0] = v.uv;
  100.  
  101. 				o.uv[1] = v.uv + float2(0, _MainTex_TexelSize.y * 1) * _BlurSize;
  102. 				o.uv[2] = v.uv - float2(0, _MainTex_TexelSize.y * 1) * _BlurSize;
  103. 				o.uv[3] = v.uv + float2(0, _MainTex_TexelSize.y * 2) * _BlurSize;
  104. 				o.uv[4] = v.uv - float2(0, _MainTex_TexelSize.y * 2) * _BlurSize;
  105.  
  106.                 return o;
  107.             }
  108.  
  109.             fixed4 frag (v2f i) : SV_Target
  110.             {
  111. 				float weight[3] = {0.4026, 0.2442, 0.0545};
  112.  
  113. 				fixed3 sum = tex2D(_MainTex, i.uv[0]).rgb * weight[0];
  114. 				
  115. 				for(int m = 1; m < 3; m++)
  116. 				{
  117. 				    sum += tex2D(_MainTex, i.uv[m * 2 - 1]).rgb * weight[m];
  118. 				    sum += tex2D(_MainTex, i.uv[m * 2]).rgb * weight[m];
  119. 				}
  120.  
  121.                 return fixed4(sum, 1.0);
  122.             }
  123.             ENDCG
  124.         }
  125.     }
  126.  
  127. 	FallBack Off
  128. }

再来，美白提亮算法

我也已经很贴心地帮你们把原理说明找到了

核心源码技术点就是这些，我们只需要将这些整合一下，即可形成一个完整的美颜功能。

  1. Shader "Extand/Face/Beauty"
  2. {
  3.     Properties
  4.     {
  5.         _MainTex ("Texture", 2D) = "white" {}
  6. 		_BilateralTex ("_BlurTex", 2D) = "white" {}
  7. 		_GaussTex ("GaussTex", 2D) = "white" {}
  8. 		_SkinTex ("SkinTex", 2D) = "white" {}
  9.  
  10. 		_SkinWhite("SkinWhite", Range(0,1)) = 0
  11.     }
  12.     SubShader
  13.     {
  14.         Tags { "RenderType"="Opaque" }
  15.         LOD 100
  16.  
  17.         Pass
  18.         {
  19.             CGPROGRAM
  20.             #pragma vertex vert
  21.             #pragma fragment frag
  22.             
  23.             #include "UnityCG.cginc"
  24.  
  25.             struct appdata
  26.             {
  27.                 float4 vertex : POSITION;
  28.                 float2 uv : TEXCOORD0;
  29.             };
  30.  
  31.             struct v2f
  32.             {
  33.                 float2 uv : TEXCOORD0;
  34.                 float4 vertex : SV_POSITION;
  35.             };
  36.  
  37.             sampler2D _MainTex;
  38. 			float4 _BlurTex_TexelSize;
  39. 			sampler2D _BlurTex;
  40. 			sampler2D _GaussTex;
  41. 			sampler2D _SkinTex;
  42. 			float _SkinWhite;
  43.  
  44.             v2f vert (appdata v)
  45.             {
  46.                 v2f o;
  47.                 o.vertex = UnityObjectToClipPos(v.vertex);
  48. 				o.uv = v.uv;
  49.                 return o;
  50.             }
  51.  
  52. 			fixed4 skin(fixed4 col)
  53. 			{
  54. 			    half u = (-0.169 * col.r - 0.331 * col.g + 0.5 * col.b + 0.5) * 255;
  55. 				half v = (0.5 * col.r - 0.419 * col.g - 0.081 * col.b + 0.5) * 255;
  56.  
  57. 				fixed t1 = saturate(sign(u - 80));
  58. 				fixed t2 = saturate(sign(121 - u));
  59. 				fixed t3 = saturate(sign(v - 124));
  60. 				fixed t4 = saturate(sign(175 - v));
  61.  
  62. 				fixed t = sign(t1 * t2 * t3 * t4);
  63. 				return fixed4(col.r, col.g, col.b, t);
  64. 			}
  65.  
  66. 			half luminance(fixed4 color){
  67. 			    return 0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b;
  68. 			}
  69.  
  70. 			fixed4 bright(fixed4 col)
  71. 			{
  72. 				//美颜提亮算法
  73. 				half BrightLevel = 5; 
  74. 			    half3 temp = (0,0,0);
  75. 			    temp.x = log(col.r * (BrightLevel - 1) + 1) / log(BrightLevel);
  76. 			    temp.y = log(col.g * (BrightLevel - 1) + 1) / log(BrightLevel);
  77. 			    temp.z = log(col.b * (BrightLevel - 1) + 1) / log(BrightLevel);
  78. 			    return  fixed4(temp, col.a);
  79. 			}
  80.  
  81.             fixed4 frag (v2f i) : SV_Target
  82.             {
  83. 			    fixed4 col = tex2D(_MainTex, i.uv);      //原图
  84. 				fixed4 cskin = tex2D(_SkinTex, i.uv);    //肤色Mask
  85. 				fixed4 bilater = tex2D(_BlurTex, i.uv);  //双边过滤
  86. 				fixed4 gauss = tex2D(_GaussTex, i.uv);   //高斯模糊
  87. 				//按照我们的设想，只需要对肤色区域进行双边过滤，再提亮即可完成美颜
  88. 				//而实际上，这样做的效果不算理想，因为双边过滤算法虽然是保边算法，但它不可能做到绝对保边
  89. 				//因此，我们需要再给模糊后的纹理，增加脸部细节 
  90. 				//主要算法原理： 
  91. 				//1.原图 = 模糊 + 细节  --->  细节 = 原图 - 模糊   
  92. 				//2.增强 = 模糊 + 细节 * k
  93. 				//这一步具有很强的主观性，是试出来的 
  94. 				//0.2 * (col - bilater)   是取原图双边过滤剩下的细节
  95. 				//0.8 * (bilater - gauss) 是取原图双边过滤再高斯模糊剩下的细节
  96. 				half4 nblur = bilater + 0.2 * (col - bilater) + 0.8 * (bilater - gauss);
  97. 				nblur.r = saturate(nblur.r);//防止颜色值溢出
  98. 				nblur.g = saturate(nblur.g);
  99. 				nblur.b = saturate(nblur.b);
  100. 				//使用肤色Mask，如果是肤色区域，即取模糊值，否则取原图
  101. 				fixed4 final = lerp(col, fixed4(nblur.rgb,1) , cskin.a);
  102. 				//提亮
  103. 				fixed4 cbright = bright(final);
  104. 				//根据提亮级别插值
  105. 				final = lerp(final, cbright , _SkinWhite);
  106. 			 
  107. 				final.a = 1;
  108.                 return final;
  109.             }
  110.  
  111.             ENDCG
  112.         }
  113.     }
  114.  
  115. 	FallBack Off
  116. }

搞定收工！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/123503?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号