低級的模仿的圖像卷積算法

圖像處理的基本操作就是矩陣運算了吧，也算是稍微理解下那些算法是怎麼操作的

不過後來又看了一下，發現自己寫的很幼稚。不管了，先擺出來，以後有時間再看。

#include <iostream>
#include <assert.h>
using namespace std;
#define MAX 100//矩陣最大階

double Kernel[MAX][MAX] = { 0 };            //卷積核

class Pixel_INMAGE
{
public:
    double Pixel[MAX][MAX];         //像素陣
    double Result[MAX][MAX];            //變換結果矩陣
    //構造
    Pixel_INMAGE()
    {
        memset(Pixel, 0, sizeof(Pixel));
        memset(Result, 0, sizeof(Result));
    }
    //大小比較
    inline int max(int a, int b){ return a > b ? a : b; }
//*********************************************************
//函 數 名：Convolution_One
//參    數：  k    n    m
//         卷積核  行  列
//返 回 值：無
//備    注：壓縮卷積
//*********************************************************
    void Convolution_One(int k, int n, int m)   //flag爲1
    {
        assert(k <= m && k <= n);               //壓縮矩陣
        for (int ROW_OF_RESULT = k / 2; ROW_OF_RESULT < n - k / 2; ROW_OF_RESULT++)
        {
            for (int COL_OF_RESULT = k / 2; COL_OF_RESULT < m - k / 2; COL_OF_RESULT++)
            {
                for (int ROW_OF_PIXEL = ROW_OF_RESULT - k / 2; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)//像素矩陣行,等於號問題也是根據示例調出來的。
                {
                    int ROW_OF_KERNEL = ROW_OF_PIXEL - ROW_OF_RESULT + k / 2;
                    for (int COL_OF_PIXEL = COL_OF_RESULT - k / 2; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                    {
                        int COL_OF_KERNEL = COL_OF_PIXEL - COL_OF_RESULT + k / 2;   //我自己都佩服我自己
                        Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                    }
                }
            }
        }
    }
//*********************************************************
//函 數 名：Convolution_Two
//參    數：  k    n    m
//         卷積核  行  列
//返 回 值：無
//備    注：本來是要分情況考慮的，太碎了，還不如來一個整體的。我認爲難點在於等於號的取捨
//*********************************************************
    void Convolution_Two(int k, int n, int m)   //flag爲2
    {
        for (int ROW_OF_RESULT = 0; ROW_OF_RESULT < n; ROW_OF_RESULT++)
        {
            for (int COL_OF_RESULT = 0; COL_OF_RESULT < m; COL_OF_RESULT++)
            {
                if (ROW_OF_RESULT - k / 2 >= 0 && COL_OF_RESULT - k / 2 >= 0)//卷積後的result[ROW_OF_RESULT][COL_OF_RESULT]對應的卷積核在Piexl之內
                {
                    for (int ROW_OF_PIXEL = ROW_OF_RESULT - k / 2; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)//像素矩陣行
                    {
                        int ROW_OF_KERNEL = ROW_OF_PIXEL - ROW_OF_RESULT + k / 2;
                        for (int COL_OF_PIXEL = COL_OF_RESULT - k / 2; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = COL_OF_PIXEL - COL_OF_RESULT + k / 2;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
                else if (ROW_OF_RESULT - k / 2 >= 0 && COL_OF_RESULT - k / 2 < 0)//若是像素陣列數爲負
                {
                    for (int ROW_OF_PIXEL = ROW_OF_RESULT - k / 2; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)
                    {
                        int ROW_OF_KERNEL = ROW_OF_PIXEL - ROW_OF_RESULT + k / 2;
                        for (int COL_OF_PIXEL = 0; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = k / 2 + COL_OF_PIXEL;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
                else if (ROW_OF_RESULT - k / 2 < 0 && COL_OF_RESULT - k / 2 >= 0)//行數爲負
                {
                    for (int ROW_OF_PIXEL = 0; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)
                    {
                        int ROW_OF_KERNEL = k / 2 + ROW_OF_PIXEL;
                        for (int COL_OF_PIXEL = COL_OF_RESULT - k / 2; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = COL_OF_PIXEL - COL_OF_RESULT + k / 2;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
                else            //行數列數全爲負
                {
                    for (int ROW_OF_PIXEL = 0; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)
                    {
                        int ROW_OF_KERNEL = k / 2 + ROW_OF_PIXEL;
                        for (int COL_OF_PIXEL = 0; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = k / 2 + COL_OF_PIXEL;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
            }
        }
    }
//*********************************************************
//函 數 名：print
//參    數：  k    n    m    CONVOLUTIONAl_FLAG
//         卷積核  行  列    flag
//返 回 值：無
//備    注：輸出答案
//*********************************************************
    void print(int k, int n, int m, int CONVOLUTIONAl_FLAG)
    {
        if (CONVOLUTIONAl_FLAG == 1)    //類型一輸出，按照計算的時候輸出
        {
            for (int ROW_OF_RESULT = k / 2; ROW_OF_RESULT < n - k / 2; ROW_OF_RESULT++)
            {
                for (int COL_OF_RESULT = k / 2; COL_OF_RESULT < m - k / 2; COL_OF_RESULT++)
                {
                    cout << (int)Result[ROW_OF_RESULT][COL_OF_RESULT] << ' ';
                }
                cout << endl;
            }
        }
        else                //類型二輸出，圖片無壓縮
        {
            for (int ROW_OF_RESULT = 0; ROW_OF_RESULT < n; ROW_OF_RESULT++)
            {
                for (int COL_OF_RESULT = 0; COL_OF_RESULT < m; COL_OF_RESULT++)
                {
                    cout << (int)Result[ROW_OF_RESULT][COL_OF_RESULT] << ' ';
                }
                cout << endl;
            }
        }
        Pixel[MAX][MAX] = { 0 };
        Result[MAX][MAX] = { 0 };//矩陣重置爲零
        Kernel[MAX][MAX] = { 0 };
    }
//*********************************************************
//函 數 名：Picture_Input
//參    數：   n    m
//             行  列
//返 回 值：無
//備    注：輸入圖像
//*********************************************************
    void Picture_Input(int n, int m)
    {
        for (int ROW_OF_PIXEL = 0; ROW_OF_PIXEL < n; ROW_OF_PIXEL++)//像素矩陣。
        {
            for (int COL_OF_PIXEL = 0; COL_OF_PIXEL < m; COL_OF_PIXEL++)

                cin >> Pixel[ROW_OF_PIXEL][COL_OF_PIXEL];
        }
    }
};
//*********************************************************
//函 數 名：Kernel_Input
//參    數：  k 卷積核
//返 回 值：無
//備    注：輸入卷積核
//*********************************************************
void Kernel_Input(int k)
{
    for (int ROW_OF_KERNEL = 0; ROW_OF_KERNEL < k; ROW_OF_KERNEL++)//卷積核。
    {
        for (int COL_OF_KERNEL = 0; COL_OF_KERNEL < k; COL_OF_KERNEL++)
        {
            cin >> Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
        }
    }
}
int main()
{
    Pixel_INMAGE Picture;
    int k, n, m, CONVOLUTIONAl_FLAG;//k是k階卷積核矩陣且k一定是奇數。n是行數，m是列數
    cin >> k >> n >> m >> CONVOLUTIONAl_FLAG;
    assert(k % 2 != 0);     //k堅決不爲二
    Picture.Picture_Input(n, m);
    Kernel_Input(k);
    if (CONVOLUTIONAl_FLAG == 1)Picture.Convolution_One(k, n, m);
    else if (CONVOLUTIONAl_FLAG == 2)Picture.Convolution_Two(k, n, m);
    Picture.print(k, n, m, CONVOLUTIONAl_FLAG);
    return 0;
}