coreBugZJ

數(shù)字圖像處理上機(jī)之五：圖像平滑和銳化

在圖像中，通過鄰接點(diǎn)的相互平均可以去掉一些突然變化的點(diǎn)，從而過濾掉一定的噪聲，達(dá)到平滑的目的，但圖像有一定程度上的模糊。
本實(shí)驗(yàn)使用模板
        1  1  1
        1  1  1
        1  1  1
即每一個(gè)像素的灰度都是自身和周圍8個(gè)像素的平均值。

圖像銳化處理的目的是使模糊的圖像變得更加清晰起來，而圖像模糊的實(shí)質(zhì)就是圖像受到平均或積分運(yùn)算造成的，因此可以對(duì)圖像進(jìn)行逆運(yùn)算（如微分）來使圖像清晰化。梯度銳化是一種常用的微分銳化方法。

Sobel 初步嘗試，其卷積計(jì)算核有兩個(gè)，

Sx =
        -1  0  1
        -2  0  2
        -1  0  1

Sy =
        1   2   1
        0   0   0
       -1  -2  -1

一個(gè)對(duì)垂直邊緣影響最大，一個(gè)對(duì)水平邊緣影響最大。圖像中每點(diǎn)均分別用這兩個(gè)算子作卷積，取兩個(gè)卷積絕對(duì)值的和。

圖像中的邊緣及急劇變化部分與圖像高頻分量有關(guān)，利用低通濾波減弱高頻部分能實(shí)現(xiàn)圖像平滑，利用高通濾波減弱低頻部分能實(shí)現(xiàn)圖像銳化。

圖像FFT 后注意原點(diǎn)。

原圖



FFT 后



FFT 后高通濾波



高通濾波



FFT 后低通濾波



低通濾波



平滑



Sobel

/*
ProcessFilterZ.h

Copyright (C) 2011, coreBugZJ, all rights reserved.

濾波。
*/

#ifndef  __PROCESSFILTER_Z_H_INCLUDED__
#define  __PROCESSFILTER_Z_H_INCLUDED__

#include "TypeZ.h"
#include "ClassImageZ.h"

        /* 高通 低通 濾波器 */
        /* 對(duì)寬為 (1<<lgw) 高為 (1<<lgh) 且 2d FFT 后的矩陣 */
        /* 點(diǎn)的定位同 2d FFT */
        /* 會(huì)修改矩陣 */
        /* if 參數(shù)highPass then 高通 else 低通 */
        /* == radius 也通過 */
        /* 成功返回 ROK */
PublicFuncZ  R32  highLowPassFilterZ( CF64 *mat, U32 lgw, U32 lgh, F64 radius, B32 highPass );
        /* 在圖像上使用 n * n 的模板 mat，然后 乘以 mulFactor 除以 divFactor */
        /* 假設(shè) n 為奇數(shù) */
        /* 會(huì)修改圖像 */
        /* 模板 mat 中第 y 行第 x 列的點(diǎn)（x，y）為 mat[ y * n + x ] */
        /* 圖像邊緣無法使用模板處，保持不變 */
        /* 成功返回 ROK */
PublicFuncZ  R32  templateFilterZ( ImageZ img, I32 *mat, U32 n, I32 mulFactor, I32 divFactor );

        /* 平滑 */
        /* 會(huì)修改圖像 */
        /* 成功返回 ROK */
PublicFuncZ  R32  smoothImageZ( ImageZ img );
        /* 銳化 sobel */
        /* 會(huì)修改圖像 */
        /* 成功返回 ROK */
PublicFuncZ  R32  sharpImageZ( ImageZ img );

#endif /* __PROCESSFILTER_Z_H_INCLUDED__ */

/*
ProcessFilterZ.c

Copyright (C) 2011, coreBugZJ, all rights reserved.

濾波。
*/

#include "stdafx.h"
#include "ProcessFilterZ.h"
#include "ProcessGrayZ.h"

#include <malloc.h>

PublicFuncZ  R32  highLowPassFilterZ( CF64 *mat, U32 lgw, U32 lgh, F64 radius, B32 highPass ) {
        U32  x, y, w, h, xc, yc;
        F64  r2m4, d2m4, f0, f1;
        I32  cmp;

        if ( (NULL == mat) ) {
                return RERR;
        }

        w = PWR2_U32_Z( lgw );
        h = PWR2_U32_Z( lgh );
        MUL_F64_Z( r2m4, radius, radius );
        MUL_F64_U32_Z( r2m4, r2m4, 4 );

        for ( y = 0; y < h; ++y ) {
                yc = ( y + (h>>1) ) % h;
                for ( x = 0; x < w; ++x ) {
                        xc = ( x + (w>>1) ) % w;

                        MOV_F64_U32_Z( f0, xc );
                        ADD_F64_U32_Z( f0, f0, xc );
                        SUB_F64_U32_Z( f0, f0, w );
                        MUL_F64_Z( f0, f0, f0 );

                        MOV_F64_U32_Z( f1, yc );
                        ADD_F64_U32_Z( f1, f1, yc );
                        SUB_F64_U32_Z( f1, f1, h );
                        MUL_F64_Z( f1, f1, f1 );

                        ADD_F64_Z( d2m4, f0, f1 );

                        CMP_F64_Z( cmp, d2m4, r2m4 );
                        if ( highPass ) {
                                if ( cmp < 0 ) {
                                        MOV_CF64_U32_Z( mat[ y * w + x ], 0, 0 );
                                }
                        }
                        else {
                                if ( cmp > 0 ) {
                                        MOV_CF64_U32_Z( mat[ y * w + x ], 0, 0 );
                                }
                        }
                }
        }

        return ROK;
}

PublicFuncZ  R32  templateFilterZ( ImageZ img, I32 *mat, U32 n, I32 mulFactor, I32 divFactor ) {
        U32  w, h, x, y, ix, iy, nha;
        I32  pix, *ptrmat;
        U08  *ptrimg, *ptrpix;

        if ( (!isImageValidZ(img)) || (NULL == mat) || (0 == divFactor) || (3 > n) ) {
                return RERR;
        }

        if ( GRAY_NUM_Z != img->colorNum ) {
                return RERR; /* 目前只支持 256 灰度 */
        }

        nha = n / 2 + 1;
        w   = img->width;
        h   = img->height;

        for ( y = n; y <= h; ++y ) {
                ptrpix = img->pPixel + (y - nha) * img->linePitch + (n - nha);
                for ( x = n; x <= w; ++x ) {
                        pix = 0;
                        ptrmat = mat;
                        for ( iy = y-n; iy < y; ++iy ) {
                                ptrimg = img->pPixel + iy * img->linePitch + (x - n);
                                for ( ix = x-n; ix < x; ++ix ) {
                                        pix += (*ptrimg) * (*ptrmat);
                                        ++ptrimg;
                                        ++ptrmat;
                                }
                        }
                        pix = pix * mulFactor / divFactor;
                        if ( pix >= GRAY_NUM_Z ) {
                                pix = GRAY_NUM_Z - 1;
                        }
                        *ptrpix = (U08)(pix);
                        ++ptrpix;
                }
        }

        return ROK;
}

PublicFuncZ  R32  smoothImageZ( ImageZ img ) {
        I32 mat[] = {
                1, 1, 1,
                1, 1, 1,
                1, 1, 1
        };
        return templateFilterZ( img, mat, 3, 1, 9 );
}

PublicFuncZ  R32  sharpImageZ( ImageZ img ) {
        I32    *mat = NULL;
        U32    width, height, x, y;
        I32    v0, v1;
        R32    res;

        if ( !isImageValidZ(img) ) {
                return RERR;
        }

        if ( GRAY_NUM_Z != img->colorNum ) {
                return RERR; /* 256 級(jí)灰度 */
        }

        width  = img->width;
        height = img->height;

        mat = (I32*)malloc( width * height * sizeof(I32) );
        if ( NULL == mat ) {
                return RERR;
        }

#define  PIX(ix,iy)  ((I32)(img->pPixel[(iy) * img->linePitch + (ix)]))
        for ( y = 0; y < height; ++y ) {
                for ( x = 0; x < width; ++x ) {
                        v0 = ( PIX(x+1, y-1) + 2*PIX(x+1, y) + PIX(x+1, y+1) ) -
                             ( PIX(x-1, y-1) + 2*PIX(x-1, y) + PIX(x-1, y+1) );
                        if ( 0 > v0 ) v0 = -v0;

                        v1 = ( PIX(x-1, y+1) + 2*PIX(x, y+1) + PIX(x+1, y+1) ) -
                             ( PIX(x-1, y+1) + 2*PIX(x, y+1) + PIX(x+1, y-1) );
                        if ( 0 > v1 ) v1 = -v1;

                        mat[ y * width + x ] = v0 + v1;
                }
        }
#undef  PIX

        res = scaleImageZ( img, mat, width, height );

        free( mat );
        mat = NULL;

        return res;
}

PublicFuncZ  ImageZ  createImageScaleZ( I32 *mat, U32 width, U32 height ) {
        ImageZ  img = NULL;

        if ( (NULL == mat) || (1 > width) || (1 > height) ) {
                return NULL;
        }

        img = createImageZ( width, height, GRAY_NUM_Z );
        if ( NULL == img ) {
                return NULL;
        }

        if ( ROK == scaleImageZ(img, mat, width, height) ) {
                return img;
        }

        destroyImageZ( img );
        img = NULL;

        return NULL;
}

PublicFuncZ  R32  scaleImageZ( ImageZ img, I32 *mat, U32 width, U32 height ) {
        U32     x, y, i;
        I32     matMin, matMax, mv;

        if ( (NULL == mat) || (1 > width) || (1 > height) ||
             (!isImageValidZ(img)) || (GRAY_NUM_Z != img->colorNum) ||
             (width != img->width) || (height != img->height)
           ) {
                return RERR;
        }

        for ( i = 0; i < GRAY_NUM_Z; ++i ) {
                img->pPalette[ i * IMAGEZ_COLOR_SIZE_Z + IMAGEZ_OFFSET_BLUE_Z  ] =
                img->pPalette[ i * IMAGEZ_COLOR_SIZE_Z + IMAGEZ_OFFSET_GREEN_Z ] =
                img->pPalette[ i * IMAGEZ_COLOR_SIZE_Z + IMAGEZ_OFFSET_RED_Z   ] = (U08)(i);
                img->pPalette[ i * IMAGEZ_COLOR_SIZE_Z + IMAGEZ_OFFSET_ALPHA_Z ] = 255;
        }

        matMin = matMax = mat[ 0 ];
        for ( y = 0; y < height; ++y ) {
                for ( x = 0; x < width; ++x ) {
                        mv = mat[ y * width + x ];
                        if ( matMin > mv ) {
                                matMin = mv;
                        }
                        if ( matMax < mv ) {
                                matMax = mv;
                        }
                }
        }

        mv = matMax - matMin;
        if ( 0 == mv ) {
                mv = 1;
        }
        for ( y = 0; y < height; ++y ) {
                for ( x = 0; x < width; ++x ) {
                        img->pPixel[ y * img->linePitch + x ] = (U08)(
                                (mat[ y * width + x ] - matMin) * (GRAY_NUM_Z-1) / mv );
                }
        }

        return ROK;
}

PublicFuncZ  ImageZ  createImageFromFftDataZ( CF64 *mat, U32 lgw, U32 lgh ) {
        ImageZ  img = NULL;
        U32     w, h, x, y, i, tu;
        F64     tf255, tf;
        U08     *ptrimg;
        CF64    *ptrmat;

        if ( NULL == mat ) {
                return NULL;
        }

        w   = PWR2_U32_Z( lgw );
        h   = PWR2_U32_Z( lgh );
        img = createImageZ( w, h, GRAY_NUM_Z );
        if ( NULL == img ) {
                return NULL;
        }

        ptrimg = img->pPalette;
        for ( i = 0; i < GRAY_NUM_Z; ++i ) {
                ptrimg[ IMAGEZ_OFFSET_BLUE_Z  ] =
                        ptrimg[ IMAGEZ_OFFSET_GREEN_Z ] =
                        ptrimg[ IMAGEZ_OFFSET_RED_Z   ] = (U08)(i);
                ptrimg[ IMAGEZ_OFFSET_ALPHA_Z ] = 255;
                ptrimg += IMAGEZ_COLOR_SIZE_Z;
        }

        MOV_F64_U32_Z( tf255, 255 );
        for ( y = 0; y < h; ++y ) {
                ptrimg = img->pPixel + ((y+(h>>1))%h) * img->linePitch;
                ptrmat = mat + y * w;
                for ( x = 0; x < w; ++x ) {
                        M_CF64_Z( tf, *ptrmat );
                        ++ptrmat;
                        DIV_F64_U32_Z( tf, tf, 100 );
                        MIN_F64_Z( tf, tf, tf255 );
                        MOV_U32_F64_Z( tu, tf );
                        *(ptrimg + (x+(w>>1))%w ) = (U08)(tu);
                }
        }

        return img;
}

posted on 2011-12-14 20:21 coreBugZJ 閱讀(3010) 評(píng)論(0)  編輯 收藏 引用 所屬分類: VideoImage 、Algorithm 、課內(nèi)作業(yè)