unity图片后期处理

处理算法如下，在Start方法中分别调用想要的效果就行了。其中，将你需要处理的 图片 拖拽到 image参数上。注意，如果想要图片保持原来的尺寸不被压缩，需要更改图片的导入设置如下图，主要的Texture Type 和 Non Power of 2 这两个参数。

using UnityEngine;
using System.Collections;
using System.IO;

public class ImageDeal : MonoBehaviour
{
    public Texture2D image;
    private Texture2D outPut;
    int Width;
    int Height;
    // Use this for initialization
    void Start ()
    {
        Width = image.width;
        Height = image.height;
        outPut = new Texture2D (Width, Height);
        Flur ();

        writeImage ();
    }

    /// <summary>
    /// 底片效果.
    /// </summary>
    private void Dipian ()
    {
        Color pixel;
        for (int x = ; x < Width; x++) {
            for (int y = ; y < Height; y++) {
                float r, g, b;
                pixel = image.GetPixel (x, y);
                r = 1f - pixel.r;
                g = 1f - pixel.g;
                b = 1f - pixel.b;
                outPut.SetPixel (x, y, new Color (r, g, b));
            }
        }
    }

    /// <summary>
    /// 浮雕效果
    /// </summary>
    private void Fudiao ()
    {
        //以浮雕效果显示图像
        Color pixel1, pixel2;
        for (int x = ; x < Width - ; x++) {
            for (int y = ; y < Height - ; y++) {
                float r = , g = , b = ;
                pixel1 = image.GetPixel (x, y);
                pixel2 = image.GetPixel (x + , y + );
                r = Mathf.Abs (pixel1.r - pixel2.r +  / );
                g = Mathf.Abs (pixel1.g - pixel2.g +  / );
                b = Mathf.Abs (pixel1.b - pixel2.b +  / );

                outPut.SetPixel (x, y, new Color (r, g, b));
            }
        }

    }
    /// <summary>
    /// 黑白效果
    /// </summary>
    private void Heibai(){
        Color pixel;
        for (int x = ; x < Width; x++)
            for (int y = ; y < Height; y++) {
                pixel = image.GetPixel (x, y);
                float r, g, b, Result = ;
                r = pixel.r;
                g = pixel.g;
                b = pixel.b;
                //实例程序以加权平均值法产生黑白图像
                int iType = ;
                switch (iType) {
                case ://平均值法
                    Result = ((r + g + b) / );
                    break;
                case ://最大值法
                    Result = r > g ? r : g;
                    Result = Result > b ? Result : b;
                    break;
                case ://加权平均值法
                    Result = ((0.7f * r) + (0.2f * g) + (0.1f * b));
                    break;
                }
                outPut.SetPixel (x, y, new Color (Result, Result, Result));
            }
    }
    /// <summary>
    /// 柔化3x3高斯模型
    /// </summary>
    private void Rouhua3(){
        Color pixel;
        int[] Gauss ={ , , , , , , , ,  };
        for (int x = ; x < Width - ; x++)
            for (int y = ; y < Height - ; y++)
            {
                float r = , g = , b = ;
                int Index = ;
                for (int col = -; col <= ; col++)
                    for (int row = -; row <= ; row++)
                    {
                        pixel = image.GetPixel(x + row, y + col);
                        r += pixel.r * Gauss[Index];
                        g += pixel.g * Gauss[Index];
                        b += pixel.b * Gauss[Index];
                        Index++;
                    }
                r /= ;
                g /= ;
                b /= ;
                outPut.SetPixel(x - , y - , new Color(r, g, b));
            }
    }
    /// <summary>
    /// 柔化5x5高斯模型
    /// </summary>
    private void Rouhua5(){
        Color pixel;
        int[] Gauss = { , , , , , , , , , , , , , , , , , , , , , , , ,  };
        for (int x = ; x < Width - ; x++)
            for (int y = ; y < Height - ; y++)
            {
                float r = , g = , b = ;
                int Index = ;
                for (int col = -; col <= ; col++)
                    for (int row = -; row <= ; row++)
                    {
                        pixel = image.GetPixel(x + row, y + col);
                        r += pixel.r * Gauss[Index];
                        g += pixel.g * Gauss[Index];
                        b += pixel.b * Gauss[Index];
                        Index++;
                    }
                r /= ;
                g /= ;
                b /= ;
                outPut.SetPixel(x - , y - , new Color(r, g, b));
            }
    }
    /// <summary>
    /// 柔化，高斯模糊通用方法
    /// </summary>
    private void Flur(){
        Color pixel;
        float[] Gauss = GaussianSmooth (10.0f);
        for (int x = ; x < Width - ; x++)
            for (int y = ; y < Height - ; y++)
            {
                float r = , g = , b = ;
                int Index = ;
                int length = (int)Mathf.Sqrt (Gauss.Length) / ;
                for (int col = -length; col <= length; col++)
                    for (int row = -length; row <= length; row++)
                    {
                        pixel = image.GetPixel(x + row, y + col);
                        r += pixel.r * Gauss[Index];
                        g += pixel.g * Gauss[Index];
                        b += pixel.b * Gauss[Index];
                        Index++;
                    }
                outPut.SetPixel(x - , y - , new Color(r, g, b));
            }
    }
    /// <summary>
    /// 锐化效果
    /// </summary>
    private void Ruihua(){
        Color pixel;
        //拉普拉斯模板
        int[] Laplacian ={ -, -, -, -, , -, -, -, - };
        for (int x = ; x < Width - ; x++)
            for (int y = ; y < Height - ; y++)
            {
                float r = , g = , b = ;
                int Index = ;
                for (int col = -; col <= ; col++)
                    for (int row = -; row <= ; row++)
                    {
                        pixel = image.GetPixel(x + row, y + col);
                        r += pixel.r * Laplacian[Index];
                        g += pixel.g * Laplacian[Index];
                        b += pixel.b * Laplacian[Index];
                        Index++;
                    }
                outPut.SetPixel(x - , y - , new Color(r, g, b));
            }
    }
    /// <summary>
    /// 写文件
    /// </summary>
    private void writeImage ()
    {
        byte[] bytes = outPut.EncodeToJPG ();
        File.WriteAllBytes (Application.dataPath + "/test.jpg", bytes);
    }

    /// <summary>
    /// 动态生成高斯模型
    /// </summary>
    /// <returns>The smooth.</returns>
    /// <param name="sigma">Sigma.</param>
    private float[] GaussianSmooth( float sigma)
    {
        sigma = sigma >  ? sigma : -sigma;
        //高斯核矩阵的大小为(6*sigma+1)*(6*sigma+1)
        //ksize为奇数
        int ksize = (int)Mathf.Ceil(sigma * ) *  + ;   

        //计算一维高斯核
        float[] kernel = new float[ksize];  

        float scale = -0.5f / (sigma * sigma);
        const float PI = 3.141592653f;
        float cons = / Mathf.Sqrt(-scale / PI);  

        float sum = ;
        int kcenter = ksize/;
        int i = , j = ;
        for(i = ; i < ksize; i++)
        {
            int x = i - kcenter;
            kernel[i] = cons * Mathf.Exp(x * x * scale);//一维高斯函数
            sum +=kernel[i];  

        }
        //归一化,确保高斯权值在[0,1]之间
        for(i = ; i < ksize; i++)
        {
            kernel[i] =  kernel[i] / sum;
        }
        return kernel;
    }
}