• Open Source Computer Vision Library

Cv圖像處理

Wikipedia,自由的百科全书

註意:本章描述圖像處理和分析的一些函數。大多數函數都是針對兩維象素數組的,這裡,我們稱這些數組為“圖像”,但是它們不一定非得是IplImage 結構,也可以是CvMat或者CvMatND結構。


目錄

梯度、邊緣和角點

Sobel

使用擴展 Sobel 運算元計算一階、二階、三階或混合圖像差分

void cvSobel( const CvArr* src, CvArr* dst, int xorder, int yorder, int aperture_size=3 );
src
輸入圖像.
dst
輸出圖像.
xorder
x 方向上的差分階數
yorder
y 方向上的差分階數
aperture_size
擴展 Sobel 核的大小,必須是 1, 3, 5 或 7。 除了尺寸為 1, 其它情況下, aperture_size ×aperture_size 可分離內核將用來計算差分。對 aperture_size=1的情況, 使用 3x1 或 1x3 內核 (不進行高斯平滑操作)。這裡有一個特殊變數 CV_SCHARR (=-1),對應 3x3 Scharr 濾波器,可以給出比 3x3 Sobel 濾波更精確的結果。Scharr 濾波器繫數是:

\begin{bmatrix}     -3 & 0 & 3 \\     -10 & 0 & 10 \\     -3 & 0 & 3  \end{bmatrix}

對 x-方向 或矩陣轉置後對 y-方向。

函數 cvSobel 通過對圖像用相應的內核進行捲積操作來計算圖像差分:

dst(x,y) = \frac{d^{xorder+yorder}src} {dx^{xorder} dy^{yorder}} |(x,y)

由於Sobel 運算元結合了 Gaussian 平滑和微分,所以,其結果或多或少對雜訊有一定的魯棒性。通常情況,函數調用採用如下參數 (xorder=1, yorder=0, aperture_size=3) 或 (xorder=0, yorder=1, aperture_size=3) 來計算一階 x- 或 y- 方向的圖像差分。第一種情況對應:

\begin{bmatrix}     -1 & 0 & 1 \\     -2 & 0 & 2 \\     -1 & 0 & 1  \end{bmatrix} 核。

第二種對應:

\begin{bmatrix}     -1 & -2 & -1 \\     0 & 0 & 0 \\     1 & 2 & 1  \end{bmatrix}

或者

\begin{bmatrix}     1 & 2 & 1 \\     0 & 0 & 0 \\     -1 & -2 & -1  \end{bmatrix}

核的選則依賴於圖像原點的定義 (origin 來自 IplImage 結構的定義)。由於該函數不進行圖像尺度變換,所以和輸入圖像(數組)相比,輸出圖像(數組)的元素通常具有更大的絕對數值(譯者註:即像素的位深)。為防止溢出,當輸入圖像是 8 位的,要求輸出圖像是 16 位的。當然可以用函數 cvConvertScale 或 cvConvertScaleAbs 把運算結果(dst)轉換為 8 位的。除了8-點陣圖像,函數也接受 32-位 浮點數圖像。所有輸入和輸出圖像都必須是單通道的,並且具有相同的圖像尺寸或者ROI尺寸。

Laplace

計算圖像的 Laplacian 變換

void cvLaplace( const CvArr* src, CvArr* dst, int aperture_size=3 );
src
輸入圖像.
dst
輸出圖像.
aperture_size
核大小 (與 cvSobel 中定義一樣).

函數 cvLaplace 計算輸入圖像的 Laplacian變換,方法是先用 sobel 運算元計算二階 x- 和 y- 差分,再求和:

dst(x,y) = \frac{d^{2}src}{dx^{2}} + \frac{d^{2}src} {dy^{2}}

對 aperture_size=1 則給出最快計算結果,相當於對圖像採用如下內核做捲積:

\begin{bmatrix}     0 & 1 & 0 \\     1 & -4 & 1 \\     0 & 1 & 0  \end{bmatrix}

類似於 cvSobel 函數,該函數也不作圖像的尺度變換,所支持的輸入、輸出圖像類型的組合和cvSobel一致。

Canny

採用 Canny 演算法做邊緣檢測

void cvCanny( const CvArr* image, CvArr* edges, double threshold1,
              double threshold2, int aperture_size=3 );
image
單通道輸入圖像.
edges
單通道存儲邊緣的輸出圖像
threshold1
第一個閾值
threshold2
第二個閾值
aperture_size
Sobel 運算元內核大小 (見 cvSobel).

函數 cvCanny 採用 CANNY 演算法發現輸入圖像的邊緣而且在輸出圖像中標識這些邊緣。threshold1和threshold2 當中的小閾值用來控制邊緣連接,大的閾值用來控制強邊緣的初始分割。

PreCornerDetect

計算用於角點檢測的特征圖,

void cvPreCornerDetect( const CvArr* image, CvArr* corners, int aperture_size=3 );
image
輸入圖像.
corners
保存候選角點的特征圖
aperture_size
Sobel 運算元的核大小(見cvSobel).

函數 cvPreCornerDetect 計算函數D_x^2D_{yy}+D_y^2D_{xx} - 2D_xD_yD_{xy} 其中 D_{\cdot} 表示一階圖像差分,D_{\cdot \cdot} 表示二階圖像差分。 角點被認為是函數的局部最大值:

// 假設圖像格式為浮點數
IplImage* corners = cvCloneImage(image);
IplImage* dilated_corners = cvCloneImage(image);
IplImage* corner_mask = cvCreateImage( cvGetSize(image), 8, 1 );
cvPreCornerDetect( image, corners, 3 );
cvDilate( corners, dilated_corners, 0, 1 );
cvSub( corners, dilated_corners, corners );
cvCmpS( corners, 0, corner_mask, CV_CMP_GE );
cvReleaseImage( &corners );
cvReleaseImage( &dilated_corners );

CornerEigenValsAndVecs

計算圖像塊的特征值和特征向量,用於角點檢測

void cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
                               int block_size, int aperture_size=3 );
image
輸入圖像.
eigenvv
保存結果的數組。必須比輸入圖像寬 6 倍。
block_size
鄰域大小 (見討論).
aperture_size
Sobel 運算元的核尺寸(見 cvSobel).

對每個象素,函數 cvCornerEigenValsAndVecs 考慮 block_size × block_size 大小的鄰域 S(p),然後在鄰域上計算圖像差分的相關矩陣:

M=\begin{bmatrix} \sum_{S(p)}(\frac {dI}{dx})^2  & \sum_{S(p)}(\frac{dI}{dx} \cdot \frac{dI}{dy})^{2} \\ \sum_{S(p)}(\frac{dI}{dx} \cdot \frac{dI}{dy})^{2} & \sum_{S(p)}(\frac {dI}{dy})^2 \end{bmatrix}


然後它計算矩陣的特征值和特征向量,並且按如下方式(λ1, λ2, x1, y1, x2, y2)存儲這些值到輸出圖像中,其中

λ1, λ2 - M 的特征值,沒有排序
(x1, y1) - 特征向量,對 λ1
(x2, y2) - 特征向量,對 λ2

CornerMinEigenVal

計算梯度矩陣的最小特征值,用於角點檢測

void cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval, int block_size, int aperture_size=3 );
image
輸入圖像.
eigenval
保存最小特征值的圖像. 與輸入圖像大小一致
block_size
鄰域大小 (見討論 cvCornerEigenValsAndVecs).
aperture_size
Sobel 運算元的核尺寸(見 cvSobel). 當輸入圖像是浮點數格式時,該參數表示用來計算差分固定的浮點濾波器的個數.

函數 cvCornerMinEigenVal 與 cvCornerEigenValsAndVecs 類似,但是它僅僅計算和存儲每個象素點差分相關矩陣的最小特征值,即前一個函數的 min(λ1, λ2)

CornerHarris

哈裡斯(Harris)角點檢測

void cvCornerHarris( const CvArr* image, CvArr* harris_responce, int block_size, int aperture_size=3, double k=0.04 );
image
輸入圖像。
harris_responce
存儲哈裡斯(Harris)檢測responces的圖像。與輸入圖像等大。
block_size
鄰域大小(見關於cvCornerEigenValsAndVecs的討論)。
aperture_size
擴展 Sobel 核的大小(見 cvSobel)。格式. 當輸入圖像是浮點數格式時,該參數表示用來計算差分固定的浮點濾波器的個數。
k
harris 檢測器的自由參數。參見下麵的公式。
函數 cvCornerHarris 對輸入圖像進行 Harris 邊界檢測。類似於 cvCornerMinEigenVal 和 cvCornerEigenValsAndVecs。對每個像素,在 block_size*block_size 大小的鄰域上,計算其2*2梯度共變矩陣(或相關異變矩陣)M。然後,將
det(M) - k*trace(M)2 (這裡2是平方)

保存到輸出圖像中。輸入圖像中的角點在輸出圖像中由局部最大值表示。

FindCornerSubPix

精確角點位置

void cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
                         int count, CvSize win, CvSize zero_zone,
                         CvTermCriteria criteria );
image
輸入圖像.
corners
輸入角點的初始坐標,也存儲精確的輸出坐標
count
角點數目
win
搜索視窗的一半尺寸。如果 win=(5,5) 那麼使用 5*2+1 × 5*2+1 = 11 × 11 大小的搜索視窗
zero_zone
死區的一半尺寸,死區為不對搜索區的中央位置做求和運算的區域。它是用來避免自相關矩陣出現的某些可能的奇異性。當值為 (-1,-1) 表示沒有死區。
criteria
求角點的迭代過程的終止條件。即角點位置的確定,要麼迭代數大於某個設定值,或者是精確度達到某個設定值。 criteria 可以是最大迭代數目,或者是設定的精確度,也可以是它們的組合。

函數 cvFindCornerSubPix 通過迭代來發現具有子象素精度的角點位置,或如圖所示的放射鞍點(radial saddle points)。

Image:Cornersubpix.png

子象素級角點定位的實現是基於對向量正交性的觀測而實現的,即從中央點q到其鄰域點p 的向量和p點處的圖像梯度正交(服從圖像和測量雜訊)。考慮以下的表達式:

εi=DIpiT•(q-pi)

其中,DIpi表示在q的一個鄰域點pi處的圖像梯度,q的值通過最小化εi得到。通過將εi設為0,可以建立系統方程如下:

sumi(DIpi•DIpiT)•q - sumi(DIpi•DIpiT•pi) = 0

其中q的鄰域(搜索窗)中的梯度被累加。調用第一個梯度參數G和第二個梯度參數b,得到:

q=G-1•b

該演算法將搜索窗的中心設為新的中心q,然後迭代,直到找到低於某個閾值點的中心位置。

GoodFeaturesToTrack

確定圖像的強角點

void cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image, CvArr* temp_image,
                            CvPoint2D32f* corners, int* corner_count,
                            double quality_level, double min_distance,
                            const CvArr* mask=NULL );
image
輸入圖像,8-位或浮點32-比特,單通道
eig_image
臨時浮點32-點陣圖像,尺寸與輸入圖像一致
temp_image
另外一個臨時圖像,格式與尺寸與 eig_image 一致
corners
輸出參數,檢測到的角點
corner_count
輸出參數,檢測到的角點數目
quality_level
最大最小特征值的乘法因數。定義可接受圖像角點的最小質量因數。
min_distance
限制因數。得到的角點的最小距離。使用 Euclidian 距離
mask
ROI:感興趣區域。函數在ROI中計算角點,如果 mask 為 NULL,則選擇整個圖像。 必須為單通道的灰度圖,大小與輸入圖像相同。mask對應的點不為0,表示計算該點。

函數 cvGoodFeaturesToTrack 在圖像中尋找具有大特征值的角點。該函數,首先用cvCornerMinEigenVal 計算輸入圖像的每一個象素點的最小特征值,並將結果存儲到變數 eig_image 中。然後進行非最大值抑制(僅保留3x3鄰域中的局部最大值)。下一步將最小特征值小於 quality_level•max(eig_image(x,y)) 排除掉。最後,函數確保所有發現的角點之間具有足夠的距離,(最強的角點第一個保留,然後檢查新的角點與已有角點之間的距離大於 min_distance )。

採樣、插值和幾何變換

InitLineIterator

初始化線段迭代器

int cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
                        CvLineIterator* line_iterator, int connectivity=8 );
image
帶採線段的輸入圖像.
pt1
線段起始點
pt2
線段結束點
line_iterator
指向線段迭代器狀態結構的指針
connectivity
被掃描線段的連通數,4 或 8.

函數 cvInitLineIterator 初始化線段迭代器,並返回兩點之間的象素點數目。兩個點必須在圖像內。當迭代器初始化後,連接兩點的光柵線上所有點,都可以連續通過調用 CV_NEXT_LINE_POINT 來得到。線段上的點是使用 4-連通或8-連通利用 Bresenham 演算法逐點計算的。

例子:使用線段迭代器計算彩色線上象素值的和

CvScalar sum_line_pixels( IplImage* image, CvPoint pt1, CvPoint pt2 )
{
    CvLineIterator iterator;
    int blue_sum = 0, green_sum = 0, red_sum = 0;
    int count = cvInitLineIterator( image, pt1, pt2, &iterator, 8 );

    for( int i = 0; i < count; i++ ){
        blue_sum += iterator.ptr[0];
        green_sum += iterator.ptr[1];
        red_sum += iterator.ptr[2];
        CV_NEXT_LINE_POINT(iterator);

        /* print the pixel coordinates: demonstrates how to calculate the coordinates */
        {
        int offset, x, y;
        /* assume that ROI is not set, otherwise need to take it into account. */
        offset = iterator.ptr - (uchar*)(image->imageData);
        y = offset/image->widthStep;
        x = (offset - y*image->widthStep)/(3*sizeof(uchar) /* size of pixel */);
        printf("(%d,%d)\n", x, y );
        }
    }
    return cvScalar( blue_sum, green_sum, red_sum );
}

SampleLine

將圖像上某一光柵線上的像素數據讀入緩衝區

int cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2,
                  void* buffer, int connectivity=8 );
image
輸入圖像
pt1
光柵線段的起點
pt2
光柵線段的終點
buffer
存儲線段點的緩存區,必須有足夠大小來存儲點 max( |pt2.x-pt1.x|+1, |pt2.y-pt1.y|+1 ) :8-連通情況下,或者 |pt2.x-pt1.x|+|pt2.y-pt1.y|+1 : 4-連通情況下.
connectivity
線段的連通方式, 4 or 8.

函數 cvSampleLine 實現了線段迭代器的一個特殊應用。它讀取由 pt1 和 pt2 兩點確定的線段上的所有圖像點,包括終點,並存儲到緩存中。

GetRectSubPix

從圖像中提取象素矩形,使用子象素精度

void cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
src
輸入圖像.
dst
提取的矩形.
center
提取的象素矩形的中心,浮點數坐標。中心必須位於圖像內部.

函數 cvGetRectSubPix 從圖像 src 中提取矩形:

dst(x, y) = src(x + center.x - (width(dst)-1)*0.5, y + center.y - (height(dst)-1)*0.5)

其中非整數象素點坐標採用雙線性插值提取。對多通道圖像,每個通道獨立單獨完成提取。儘管函數要求矩形的中心一定要在輸入圖像之中,但是有可能出現矩形的一部分超出圖像邊界的情況,這時,該函數複製邊界的模識(hunnish:即用於矩形相交的圖像邊界線段的象素來代替矩形超越部分的象素)。

GetQuadrangleSubPix

提取象素四邊形,使用子象素精度

void cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst, const CvMat* map_matrix );
src
輸入圖像.
dst
提取的四邊形.
map_matrix
3 × 2 變換矩陣 [A|b] (見討論).

函數 cvGetQuadrangleSubPix 以子象素精度從圖像 src 中提取四邊形,使用子象素精度,並且將結果存儲於 dst ,計算公式是:

dst(x + width(dst) / 2,y + height(dst) / 2) = src(A11x + A12y + b1,A21x + A22y + b2)

其中 A和 b 均來自映射矩陣(譯者註:A, b為幾何形變參數) ,映射矩陣為:

map\_matrix =  \begin{bmatrix} A_{11} & A_{12} & b_1 \\ A_{21} & A_{22} & b_2 \end{bmatrix}

其中在非整數坐標 A \cdot (x,y)^T+b 的象素點值通過雙線性變換得到。當函數需要圖像邊界外的像素點時,使用重覆邊界模式(replication border mode)恢復出所需的值。多通道圖像的每一個通道都單獨計算。

例子:使用 cvGetQuadrangleSubPix 進行圖像旋轉

#include "cv.h"
#include "highgui.h"
#include "math.h"

int main( int argc, char** argv )
{
    IplImage* src;
    /* the first command line parameter must be image file name */
    if( argc==2 && (src = cvLoadImage(argv[1], -1))!=0)
    {
        IplImage* dst = cvCloneImage( src );
        int delta = 1;
        int angle = 0;

        cvNamedWindow( "src", 1 );
        cvShowImage( "src", src );

        for(;;)
        {
            float m[6];
            double factor = (cos(angle*CV_PI/180.) + 1.1)*3;
            CvMat M = cvMat( 2, 3, CV_32F, m );
            int w = src->width;
            int h = src->height;

            m[0] = (float)(factor*cos(-angle*2*CV_PI/180.));
            m[1] = (float)(factor*sin(-angle*2*CV_PI/180.));
            m[2] = w*0.5f;
            m[3] = -m[1];
            m[4] = m[0];
            m[5] = h*0.5f;

            cvGetQuadrangleSubPix( src, dst, &M, 1, cvScalarAll(0));

            cvNamedWindow( "dst", 1 );
            cvShowImage( "dst", dst );

            if( cvWaitKey(5) == 27 )
                break;

            angle = (angle + delta) % 360;
        }
    }
    return 0;
}

Resize

圖像大小變換

void cvResize( const CvArr* src, CvArr* dst, int interpolation=CV_INTER_LINEAR );
src
輸入圖像.
dst
輸出圖像.
interpolation
插值方法:
  • CV_INTER_NN - 最近鄰插值,
  • CV_INTER_LINEAR - 雙線性插值 (預設使用)
  • CV_INTER_AREA - 使用象素關係重採樣。當圖像縮小時候,該方法可以避免波紋出現。當圖像放大時,類似於 CV_INTER_NN 方法..
  • CV_INTER_CUBIC - 立方插值.

函數 cvResize 將圖像 src 改變尺寸得到與 dst 同樣大小。若設定 ROI,函數將按常規支持 ROI.

WarpAffine

對圖像做仿射變換

void cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
                   int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,
                   CvScalar fillval=cvScalarAll(0) );
src
輸入圖像.
dst
輸出圖像.
map_matrix
2×3 變換矩陣
flags
插值方法和以下開關選項的組合:
  • CV_WARP_FILL_OUTLIERS - 填充所有輸出圖像的象素。如果部分象素落在輸入圖像的邊界外,那麼它們的值設定為 fillval.
  • CV_WARP_INVERSE_MAP - 指定 map_matrix 是輸出圖像到輸入圖像的反變換,因此可以直接用來做象素插值。否則, 函數從 map_matrix 得到反變換。
fillval
用來填充邊界外面的值

函數 cvWarpAffine 利用下麵指定的矩陣變換輸入圖像: dst(x',y') \leftarrow src(x,y)

  • 如果沒有指定 CV_WARP_INVERSE_MAP , (x',y')^T=map\_matrix \cdot (x,y,1)^T ,
  • 否則,(x, y)^T=map\_matrix \cdot (x',y',1)^T

函數與 cvGetQuadrangleSubPix 類似,但是不完全相同。 cvWarpAffine 要求輸入和輸出圖像具有同樣的數據類型,有更大的資源開銷(因此對小圖像不太合適)而且輸出圖像的部分可以保留不變。而 cvGetQuadrangleSubPix 可以精確地從8點陣圖像中提取四邊形到浮點數緩存區中,具有比較小的系統開銷,而且總是全部改變輸出圖像的內容。

要變換稀疏矩陣,使用 cxcore 中的函數 cvTransform 。

GetAffineTransform

由三個不共線點計算仿射變換

CvMat* cvGetAffineTransform( const CvPoint2D32f* src, const CvPoint2D32f* dst, CvMat* map_matrix );
src
輸入圖像的三角形頂點坐標。
dst
輸出圖像的相應的三角形頂點坐標。
map_matrix
指向2×3輸出矩陣的指針。

函數cvGetAffineTransform計算滿足以下關係的仿射變換矩陣:


(x'_i,y'_i,1)^T=map\_matrix\cdot(x_i,y_i,1)^T

這裡,dst(i) = (x'i,y'i),src(i) = (xi,yi),i = 0..2.

2DRotationMatrix

計算二維旋轉的仿射變換矩陣

CvMat* cv2DRotationMatrix( CvPoint2D32f center, double angle,
                           double scale, CvMat* map_matrix );
center
輸入圖像的旋轉中心坐標
angle
旋轉角度(度)。正值表示逆時針旋轉(坐標原點假設在左上角).
scale
各項同性的尺度因數
map_matrix
輸出 2×3 矩陣的指針

函數 cv2DRotationMatrix 計算矩陣:

[  α  β  |  (1-α)*center.x - β*center.y ]
[ -β  α  |  β*center.x + (1-α)*center.y ]

where α=scale*cos(angle), β=scale*sin(angle)

該變換並不改變原始旋轉中心點的坐標,如果這不是操作目的,則可以通過調整平移量改變其坐標(譯者註:通過簡單的推導可知,仿射變換的實現是首先將旋轉中心置為坐標原點,再進行旋轉和尺度變換,最後重新將坐標原點設定為輸入圖像的左上角,這裡的平移量是center.x, center.y).

WarpPerspective

對圖像進行透視變換

void cvWarpPerspective( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
                        int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,
                        CvScalar fillval=cvScalarAll(0) );
src
輸入圖像.
dst
輸出圖像.
map_matrix
3×3 變換矩陣
flags
插值方法和以下開關選項的組合:
  • CV_WARP_FILL_OUTLIERS - 填充所有縮小圖像的象素。如果部分象素落在輸入圖像的邊界外,那麼它們的值設定為 fillval.
  • CV_WARP_INVERSE_MAP - 指定 matrix 是輸出圖像到輸入圖像的反變換,因此可以直接用來做象素插值。否則, 函數從 map_matrix 得到反變換。
fillval
用來填充邊界外面的值

函數 cvWarpPerspective 利用下麵指定矩陣變換輸入圖像: dst(x',y') \leftarrow src(x,y)

  • 如果沒有指定 CV_WARP_INVERSE_MAP , (x',y')^T=map\_matrix \cdot (x,y,1)^T ,
  • 否則,(x, y)^T=map\_matrix \cdot (x',y',1)^T

要變換稀疏矩陣,使用 cxcore 中的函數 cvTransform 。

WarpPerspectiveQMatrix

用4個對應點計算透視變換矩陣

CvMat* cvWarpPerspectiveQMatrix( const CvPoint2D32f* src,
                                 const CvPoint2D32f* dst,
                                 CvMat* map_matrix );
src
輸入圖像的四邊形的4個點坐標
dst
輸出圖像的對應四邊形的4個點坐標
map_matrix
輸出的 3×3 矩陣

函數 cvWarpPerspectiveQMatrix 計算透視變換矩陣,使得:

(tix'i,tiy'i,ti)T=matrix•(xi,yi,1)T

其中 dst(i)=(x'i,y'i), src(i)=(xi,yi), i=0..3.

GetPerspectiveTransform

由四邊形的4個點計算透射變換

CvMat* cvGetPerspectiveTransform( const CvPoint2D32f* src, const CvPoint2D32f* dst,
                                  CvMat* map_matrix );

#define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform
src
輸入圖像的四邊形頂點坐標。
dst
輸出圖像的相應的四邊形頂點坐標。
map_matrix
指向3×3輸出矩陣的指針。

函數cvGetPerspectiveTransform計算滿足以下關係的透射變換矩陣:

(t_ix'_i,t_iy'_i,t_i)^T=map\_matrix\cdot(x_i,y_i,1)^T

這裡,dst(i) = (x'i,y'i),src(i) = (xi,yi),i = 0..3.

Remap

對圖像進行普通幾何變換

void cvRemap( const CvArr* src, CvArr* dst,
              const CvArr* mapx, const CvArr* mapy,
              int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,
              CvScalar fillval=cvScalarAll(0) );
src
輸入圖像.
dst
輸出圖像.
mapx
x坐標的映射 (32fC1 image).
mapy
y坐標的映射 (32fC1 image).
flags
插值方法和以下開關選項的組合:
  • CV_WARP_FILL_OUTLIERS - 填充邊界外的像素. 如果輸出圖像的部分象素落在變換後的邊界外,那麼它們的值設定為 fillval。
fillval
用來填充邊界外面的值.

函數 cvRemap 利用下麵指定的矩陣變換輸入圖像:

dst(x,y)<-src(mapx(x,y),mapy(x,y))

與其它幾何變換類似,可以使用一些插值方法(由用戶指定,譯者註:同cvResize)來計算非整數坐標的像素值。

LogPolar

把圖像映射到極指數空間

void cvLogPolar( const CvArr* src, CvArr* dst,
                 CvPoint2D32f center, double M,
                 int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );
src
輸入圖像。
dst
輸出圖像。
center
變換的中心,輸出圖像在這裡最精確。
M
幅度的尺度參數,見下麵公式。
flags
插值方法和以下選擇標誌的結合
  • CV_WARP_FILL_OUTLIERS -填充輸出圖像所有像素,如果這些點有和外點對應的,則置零。
  • CV_WARP_INVERSE_MAP - 表示矩陣由輸出圖像到輸入圖像的逆變換,並且因此可以直接用於像素插值。否則,函數從map_matrix中尋找逆變換。
fillval
用於填充外點的值。

函數cvLogPolar用以下變換變換輸入圖像:

正變換 (CV_WARP_INVERSE_MAP 未置位):

dst(phi,rho)<-src(x,y)

逆變換 (CV_WARP_INVERSE_MAP 置位):

dst(x,y)<-src(phi,rho),

這裡,

rho=M+log(sqrt(x2+y2))
phi=atan(y/x)

此函數模仿人類視網膜中央凹視力,並且對於目標跟蹤等可用於快速尺度和旋轉變換不變模板匹配。

Example. Log-polar transformation.

#include <cv.h>
#include <highgui.h>

int main(int argc, char** argv)
{
    IplImage* src;

    if(argc == 2 && ((src=cvLoadImage(argv[1],1)) != 0 ))
    {
        IplImage* dst = cvCreateImage( cvSize(256,256), 8, 3 );
        IplImage* src2 = cvCreateImage( cvGetSize(src), 8, 3 );
        cvLogPolar( src, dst, cvPoint2D32f(src->width/2,src->height/2), 40, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );
        cvLogPolar( dst, src2, cvPoint2D32f(src->width/2,src->height/2), 40, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS+CV_WARP_INVERSE_MAP );
        cvNamedWindow( "log-polar", 1 );
        cvShowImage( "log-polar", dst );
        cvNamedWindow( "inverse log-polar", 1 );
        cvShowImage( "inverse log-polar", src2 );
        cvWaitKey();
    }
    return 0;
}

And this is what the program displays when opencv/samples/c/fruits.jpg is passed to itImage:logpolar.jpg Image:inv_logpolar.jpg

形態學操作

CreateStructuringElementEx

創建結構元素

IplConvKernel* cvCreateStructuringElementEx( int cols, int rows, int anchor_x, int anchor_y,
                                             int shape, int* values=NULL );
cols
結構元素的列數目
rows
結構元素的行數目
anchor_x
錨點的相對水平偏移量
anchor_y
錨點的相對垂直偏移量
shape
結構元素的形狀,可以是下列值:
  • CV_SHAPE_RECT, 長方形元素;
  • CV_SHAPE_CROSS, 交錯元素 a cross-shaped element;
  • CV_SHAPE_ELLIPSE, 橢圓元素;
  • CV_SHAPE_CUSTOM, 用戶自定義元素。這種情況下參數 values 定義了 mask,即象素的那個鄰域必須考慮。
values
指向結構元素的指針,它是一個平面數組,表示對元素矩陣逐行掃描。(非零點表示該點屬於結構元)。如果指針為空,則表示平面數組中的所有元素都是非零的,即結構元是一個長方形(該參數僅僅當shape參數是 CV_SHAPE_CUSTOM 時才予以考慮)。

函數 cv CreateStructuringElementEx 分配和填充結構 IplConvKernel, 它可作為形態操作中的結構元素。

ReleaseStructuringElement

刪除結構元素

void cvReleaseStructuringElement( IplConvKernel** element );
element
被刪除的結構元素的指針

函數 cvReleaseStructuringElement 釋放結構 IplConvKernel 。如果 *element 為 NULL, 則函數不作用。

Erode

使用任意結構元素腐蝕圖像

void cvErode( const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1 );
src
輸入圖像.
dst
輸出圖像.
element
用於腐蝕的結構元素。若為 NULL, 則使用 3×3 正方形的結構元素
iterations
腐蝕的次數

函數 cvErode 對輸入圖像使用指定的結構元素進行腐蝕,該結構元素決定每個具有最小值象素點的鄰域形狀:

dst=erode(src,element):  dst(x,y)=min((x',y') in element))src(x+x',y+y')

函數可能是本地操作,不需另外開闢存儲空間的意思。腐蝕可以重覆進行 (iterations) 次. 對彩色圖像,每個彩色通道單獨處理。

Dilate

使用任意結構元素膨脹圖像

void cvDilate( const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1 );
src
輸入圖像.
dst
輸出圖像.
element
用於膨脹的結構元素。若為 NULL, 則使用 3×3 長方形的結構元素
iterations
膨脹的次數

函數 cvDilate 對輸入圖像使用指定的結構元進行膨脹,該結構決定每個具有最小值象素點的鄰域形狀:

dst=dilate(src,element):  dst(x,y)=max((x',y') in element))src(x+x',y+y')

函數支持(in-place)模式。膨脹可以重覆進行 (iterations) 次. 對彩色圖像,每個彩色通道單獨處理。

MorphologyEx

高級形態學變換

void cvMorphologyEx( const CvArr* src, CvArr* dst, CvArr* temp,
                     IplConvKernel* element, int operation, int iterations=1 );
src
輸入圖像.
dst
輸出圖像.
temp
臨時圖像,某些情況下需要
element
結構元素
operation
形態操作的類型:
CV_MOP_OPEN - 開運算
CV_MOP_CLOSE - 閉運算
CV_MOP_GRADIENT - 形態梯度
CV_MOP_TOPHAT - "頂帽"
CV_MOP_BLACKHAT - "黑帽"
iterations
膨脹和腐蝕次數.

函數 cvMorphologyEx 在膨脹和腐蝕基本操作的基礎上,完成一些高級的形態變換:

開運算
dst=open(src,element)=dilate(erode(src,element),element)
閉運算
dst=close(src,element)=erode(dilate(src,element),element)
形態梯度
dst=morph_grad(src,element)=dilate(src,element)-erode(src,element)
"頂帽"
dst=tophat(src,element)=src-open(src,element)
"黑帽"
dst=blackhat(src,element)=close(src,element)-src

臨時圖像 temp 在形態梯度以及對“頂帽”和“黑帽”操作時的 in-place 模式下需要。

濾波器與色彩空間變換

Smooth

各種方法的圖像平滑

void cvSmooth( const CvArr* src, CvArr* dst,
               int smoothtype=CV_GAUSSIAN,
               int param1=3, int param2=0, double param3=0, double param4=0 );
src
輸入圖像.
dst
輸出圖像.
smoothtype
平滑方法:
  • CV_BLUR_NO_SCALE (簡單不帶尺度變換的模糊) - 對每個象素的 param1×param2 領域求和。如果鄰域大小是變化的,可以事先利用函數 cvIntegral 計算積分圖像。
  • CV_BLUR (simple blur) - 對每個象素param1×param2鄰域 求和並做尺度變換 1/(param1•param2).
  • CV_GAUSSIAN (gaussian blur) - 對圖像進行核大小為 param1×param2 的高斯捲積
  • CV_MEDIAN (median blur) - 對圖像進行核大小為param1×param1 的中值濾波 (i.e. 鄰域是方的).
  • CV_BILATERAL (雙向濾波) - 應用雙向 3x3 濾波,彩色 sigma=param1,空間 sigma=param2. 關於雙向濾波,可參考 http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
param1
平滑操作的第一個參數.
param2
平滑操作的第二個參數. 對於簡單/非尺度變換的高斯模糊的情況,如果param2的值 為零,則表示其被設定為param1。
param3
對應高斯參數的 Gaussian sigma (標準差). 如果為零,則標準差由下麵的核尺寸計算:
sigma = (n/2 - 1)*0.3 + 0.8, 其中 n=param1 對應水平核,
                                 n=param2 對應垂直核.

對小的捲積核 (3×3 to 7×7) 使用如上公式所示的標準 sigma 速度會快。如果 param3 不為零,而 param1 和 param2 為零,則核大小有 sigma 計算 (以保證足夠精確的操作).

函數 cvSmooth 可使用上面任何一種方法平滑圖像。每一種方法都有自己的特點以及局限。

沒有縮放的圖像平滑僅支持單通道圖像,並且支持8位到16位的轉換(與cvSobel和cvaplace相似)和32位浮點數到32位浮點數的變換格式。

簡單模糊和高斯模糊支持 1- 或 3-通道, 8-比特 和 32-比特 浮點圖像。這兩種方法可以(in-place)方式處理圖像。

中值和雙向濾波工作於 1- 或 3-通道, 8-點陣圖像,但是不能以 in-place 方式處理圖像.


中值濾波
中值濾波法是一種非線性平滑技術,它將每一象素點的灰度值設置為該點某鄰域視窗內的所有象素點灰度值的中值。實現方法:
  1. 通過從圖像中的某個採樣視窗取出奇數個數據進行排序
  2. 用排序後的中值取代要處理的數據即可

中值濾波法對消除椒鹽噪音非常有效,在光學測量條紋圖象的相位分析處理方法中有特殊作用,但在條紋中心分析方法中作用不大。中值濾波在圖像處理中,常用於用來保護邊緣信息,是經典的平滑雜訊的方法

中值濾波原理

中值濾波是基於排序統計理論的一種能有效抑制雜訊的非線性信號處理技術,中值濾波的基本原理是把數字圖像或數字序列中一點的值用該點的一個拎域中各點值的中值代替,讓周圍的像素值接近的值,從而消除孤立的雜訊點。方法是去某種結構的二維滑動模板,將板內像素按照像素值的大小進行排序,生成單調上升(或下降)的為二維數據序列。二維中值濾波輸出為g(x,y)=med{f(x-k,y-l),(k,l∈W)} ,其中,f(x,y),g(x,y)分別為原始圖像和處理後圖像。W為二維模板,通常為2*2,3*3區域,也可以是不同的的形狀,如線狀,圓形,十字形,圓環形等。

高斯濾波

高斯濾波實質上是一種信號的濾波器,其用途是信號的平滑處理,我們知道數字圖像用於後期應用,其雜訊是最大的問題,由於誤差會累計傳遞等原因,很多圖像處理教材會在很早的時候介紹Gauss濾波器,用於得到信噪比SNR較高的圖像(反應真實信號)。於此相關的有Gauss-Lapplace變換,其實就是為了得到較好的圖像邊緣,先對圖像做Gauss平滑濾波,剔除雜訊,然後求二階導矢,用二階導的過零點確定邊緣,在計算時也是頻域乘積=>空域捲積。

濾波器就是建立的一個數學模型,通過這個模型來將圖像數據進行能量轉化,能量低的就排除掉,雜訊就是屬於低能量部分

其實編程運算的話就是一個模板運算,拿圖像的八連通區域來說,中間點的像素值就等於八連通區的像素值的均值,這樣達到平滑的效果

若使用理想濾波器,會在圖像中產生振鈴現象。採用高斯濾波器的話,系統函數是平滑的,避免了振鈴現象。

Filter2D

對圖像做捲積

void cvFilter2D( const CvArr* src, CvArr* dst,
                 const CvMat* kernel,
                 CvPoint anchor=cvPoint(-1,-1));
src
輸入圖像.
dst
輸出圖像.
kernel
捲積核, 單通道浮點矩陣. 如果想要應用不同的核於不同的通道,先用 cvSplit 函數分解圖像到單個色彩通道上,然後單獨處理。
anchor
核的錨點表示一個被濾波的點在核內的位置。 錨點應該處於核內部。預設值 (-1,-1) 表示錨點在核中心。

函數 cvFilter2D 對圖像進行線性濾波,支持 In-place 操作。當核運算部分超出輸入圖像時,函數從最近鄰的圖像內部象素插值得到邊界外面的象素值。

CopyMakeBorder

複製圖像並且製作邊界。

void cvCopyMakeBorder( const CvArr* src, CvArr* dst, CvPoint offset,
                       int bordertype, CvScalar value=cvScalarAll(0) );
src
輸入圖像。
dst
輸出圖像。
offset
輸入圖像(或者其ROI)欲拷貝到的輸出圖像長方形的左上角坐標(或者左下角坐標,如果以左下角為原點)。長方形的尺寸要和原圖像的尺寸的ROI分之一匹配。
bordertype
已拷貝的原圖像長方形的邊界的類型:
IPL_BORDER_CONSTANT - 填充邊界為固定值,值由函數最後一個參數指定。IPL_BORDER_REPLICATE -邊界用上下行或者左右列來複制填充。(其他兩種IPL邊界類型, IPL_BORDER_REFLECT 和IPL_BORDER_WRAP現已不支持)。
value
如果邊界類型為IPL_BORDER_CONSTANT的話,那麼此為邊界像素的值。

函數cvCopyMakeBorder拷貝輸入2維陣列到輸出陣列的內部並且在拷貝區域的周圍製作一個指定類型的邊界。函數可以用來模擬和嵌入在指定演算法實現中的邊界不同的類型。例如:和opencv中大多數其他濾波函數一樣,一些形態學函數內部使用複製邊界類型,但是用戶可能需要零邊界或者填充為1或255的邊界。

Integral

計算積分圖像

void cvIntegral( const CvArr* image, CvArr* sum, CvArr* sqsum=NULL, CvArr* tilted_sum=NULL );
image
輸入圖像, W×H, 單通道,8位或浮點 (32f 或 64f).
sum
積分圖像, (W+1)×(H+1)(譯者註:原文的公式應該寫成(W+1)×(H+1),避免誤會), 單通道,32位整數或 double 精度的浮點數(64f).
sqsum
對象素值平方的積分圖像,W+1×H+1(譯者註:原文的公式應該寫成(W+1)×(H+1),避免誤會), 單通道,32位整數或 double 精度的浮點數 (64f).
tilted_sum
旋轉45度的積分圖像,單通道,32位整數或 double 精度的浮點數 (64f).

函數 cvIntegral 計算一次或高次積分圖像:

sum(X,Y) = image(x,y)
x < X,y < Y
sqsum(X,Y) = image(x,y)2
x < X,y < Y
tilted_sum(X,Y) = image(x,y)
y < Y, | xX | < y

利用積分圖像,可以計算在某象素的上-右方的或者旋轉的矩形區域中進行求和、求均值以及標準方差的計算,並且保證運算的複雜度為O(1)。例如:

\sum_{x_1 \leq x<x_2,y_1 \leq y<y_2}image(x,y)=sum(x_2,y_2)-sum(x_1,y_2)-sum(x_2,y_1)+sum(x_1,x_1)

因此可以在變化的視窗內做快速平滑或視窗相關等操作。

CvtColor

色彩空間轉換

void cvCvtColor( const CvArr* src, CvArr* dst, int code );
src
輸入的 8-bit , 16-bit 或 32-bit 單倍精度浮點數影像.
dst
輸出的 8-bit , 16-bit 或 32-bit 單倍精度浮點數影像.
code
色彩空間轉換,通過定義 CV_<src_color_space>2<dst_color_space> 常數 (見下麵).

函數 cvCvtColor 將輸入圖像從一個色彩空間轉換為另外一個色彩空間。函數忽略 IplImage 頭中定義的 colorModel 和 channelSeq 域,所以輸入圖像的色彩空間應該正確指定 (包括通道的順序,對RGB空間而言,BGR 意味著佈局為 B0 G0 R0 B1 G1 R1 ... 層疊的 24-位格式,而 RGB 意味著佈局為 R0 G0 B0 R1 G1 B1 ... 層疊的24-位格式. 函數做如下變換:

RGB 空間內部的變換,如增加/刪除 alpha 通道,反相通道順序,到16位 RGB彩色或者15位RGB彩色的正逆轉換(Rx5:Gx6:Rx5),以及到灰度圖像的正逆轉換,使用:

RGB[A]->Gray: Y=0.212671*R + 0.715160*G + 0.072169*B + 0*A
Gray->RGB[A]: R=Y G=Y B=Y A=0

所有可能的圖像色彩空間的相互變換公式列舉如下:

RGB<=>XYZ (CV_BGR2XYZ, CV_RGB2XYZ, CV_XYZ2BGR, CV_XYZ2RGB):

|X|   |0.412411  0.357585  0.180454| |R|
|Y| = |0.212649  0.715169  0.072182|*|G|
|Z|   |0.019332  0.119195  0.950390| |B|

|R|   | 3.240479  -1.53715  -0.498535| |X|
|G| = |-0.969256   1.875991  0.041556|*|Y|
|B|   | 0.055648  -0.204043  1.057311| |Z|

RGB<=>YCrCb (CV_BGR2YCrCb, CV_RGB2YCrCb, CV_YCrCb2BGR, CV_YCrCb2RGB)

Y=0.299*R + 0.587*G + 0.114*B
Cr=(R-Y)*0.713 + 128
Cb=(B-Y)*0.564 + 128

R=Y + 1.403*(Cr - 128)
G=Y - 0.344*(Cr - 128) - 0.714*(Cb - 128)
B=Y + 1.773*(Cb - 128)

RGB=>HSV (CV_BGR2HSV,CV_RGB2HSV)

V=max(R,G,B)
S=(V-min(R,G,B))*255/V   if V!=0, 0 otherwise

       (G - B)*60/S,  if V=R
H= 180+(B - R)*60/S,  if V=G
   240+(R - G)*60/S,  if V=B

if H<0 then H=H+360

使用上面從 0° 到 360° 變化的公式計算色調(hue)值,確保它們被 2 除後能適用於8位。

RGB=>Lab (CV_BGR2Lab, CV_RGB2Lab)

|X|   |0.433910  0.376220  0.189860| |R/255|
|Y| = |0.212649  0.715169  0.072182|*|G/255|
|Z|   |0.017756  0.109478  0.872915| |B/255|

L = 116*Y1/3      for Y>0.008856
L = 903.3*Y      for Y<=0.008856

a = 500*(f(X)-f(Y))
b = 200*(f(Y)-f(Z))
where f(t)=t1/3              for t>0.008856
      f(t)=7.787*t+16/116   for t<=0.008856

上面的公式可以參考 http://www.cica.indiana.edu/cica/faq/color_spaces/color.spaces.html

RGB=>HLS (CV_BGR2HLS, CV_RGB2HLS)

HSL 表示 hue(色相)、saturation(飽和度)、lightness(亮度)。有的地方也稱為HSI,其中I表示intensity(強度)

轉換公式見http://zh.wikipedia.org/wiki/HSL_%E8%89%B2%E5%BD%A9%E7%A9%BA%E9%97%B4


Bayer=>RGB (CV_BayerBG2BGR, CV_BayerGB2BGR, CV_BayerRG2BGR, CV_BayerGR2BGR, CV_BayerBG2RGB, CV_BayerRG2BGR, CV_BayerGB2RGB, CV_BayerGR2BGR, CV_BayerRG2RGB, CV_BayerBG2BGR, CV_BayerGR2RGB, CV_BayerGB2BGR)

Bayer 模式被廣泛應用於 CCD 和 CMOS 攝像頭. 它允許從一個單獨平面中得到彩色圖像,該平面中的 R/G/B 象素點被安排如下:

RGRGR
GBGBG
RGRGR
GBGBG
RGRGR
GBGBG

對像素輸出的RGB份量由該像素的1、2或者4鄰域中具有相同顏色的點插值得到。以上的模式可以通過向左或者向上平移一個像素點來作一些修改。轉換常量CV_BayerC1C22{RGB|RGB}中的兩個字母C1和C2表示特定的模式類型:顏色份量分別來自於第二行,第二和第三列。比如說,上述的模式具有很流行的"BG"類型。

Threshold

對數組元素進行固定閾值操作

void cvThreshold( const CvArr* src, CvArr* dst, double threshold,
                  double max_value, int threshold_type );
src
原始數組 (單通道 , 8-bit of 32-bit 浮點數).
dst
輸出數組,必須與 src 的類型一致,或者為 8-bit.
threshold
閾值
max_value
使用 CV_THRESH_BINARY 和 CV_THRESH_BINARY_INV 的最大值.
threshold_type
閾值類型 (見討論)

函數 cvThreshold 對單通道數組應用固定閾值操作。該函數的典型應用是對灰度圖像進行閾值操作得到二值圖像。(cvCmpS 也可以達到此目的) 或者是去掉噪聲,例如過濾很小或很大象素值的圖像點。本函數支持的對圖像取閾值的方法由 threshold_type 確定:

threshold_type=CV_THRESH_BINARY:
dst(x,y) = max_value, if src(x,y)>threshold
           0, otherwise

threshold_type=CV_THRESH_BINARY_INV:
dst(x,y) = 0, if src(x,y)>threshold
           max_value, otherwise

threshold_type=CV_THRESH_TRUNC:
dst(x,y) = threshold, if src(x,y)>threshold
           src(x,y), otherwise

threshold_type=CV_THRESH_TOZERO:
dst(x,y) = src(x,y), if (x,y)>threshold
           0, otherwise

threshold_type=CV_THRESH_TOZERO_INV:
dst(x,y) = 0, if src(x,y)>threshold
           src(x,y), otherwise

下麵是圖形化的閾值描述:

Image:threshold.png

AdaptiveThreshold

自適應閾值方法

void cvAdaptiveThreshold( const CvArr* src, CvArr* dst, double max_value,
                          int adaptive_method=CV_ADAPTIVE_THRESH_MEAN_C,
                          int threshold_type=CV_THRESH_BINARY,
                          int block_size=3, double param1=5 );
src
輸入圖像.
dst
輸出圖像.
max_value
使用 CV_THRESH_BINARY 和 CV_THRESH_BINARY_INV 的最大值.
adaptive_method
自適應閾值演算法使用:CV_ADAPTIVE_THRESH_MEAN_C 或 CV_ADAPTIVE_THRESH_GAUSSIAN_C (見討論).
threshold_type
取閾值類型:必須是下者之一
  • CV_THRESH_BINARY,
  • CV_THRESH_BINARY_INV
block_size
用來計算閾值的象素鄰域大小: 3, 5, 7, ...
param1
與方法有關的參數。對方法 CV_ADAPTIVE_THRESH_MEAN_C 和 CV_ADAPTIVE_THRESH_GAUSSIAN_C, 它是一個從均值或加權均值提取的常數(見討論), 儘管它可以是負數。

函數 cvAdaptiveThreshold 將灰度圖像變換到二值圖像,採用下麵公式:

threshold_type=CV_THRESH_BINARY:
dst(x,y) = max_value, if src(x,y)>T(x,y)
           0, otherwise

threshold_type=CV_THRESH_BINARY_INV:
dst(x,y) = 0, if src(x,y)>T(x,y)
           max_value, otherwise

其中 TI 是為每一個象素點單獨計算的閾值

對方法 CV_ADAPTIVE_THRESH_MEAN_C,先求出塊中的均值,再減掉param1。

對方法 CV_ADAPTIVE_THRESH_GAUSSIAN_C ,先求出塊中的加權和(gaussian), 再減掉param1。

金字塔及其應用

PyrDown

圖像的下採樣

void cvPyrDown( const CvArr* src, CvArr* dst, int filter=CV_GAUSSIAN_5x5 );
src
輸入圖像.
dst
輸出圖像, 寬度和高度應是輸入圖像的一半 ,傳入前必須已經完成初始化
filter
捲積濾波器的類型,目前僅支持 CV_GAUSSIAN_5x5

函數 cvPyrDown 使用 Gaussian 金字塔分解對輸入圖像向下採樣。首先它對輸入圖像用指定濾波器進行捲積,然後通過拒絕偶數的行與列來下採樣圖像。

PyrUp

圖像的上採樣

void cvPyrUp( const CvArr* src, CvArr* dst, int filter=CV_GAUSSIAN_5x5 );
src
輸入圖像.
dst
輸出圖像, 寬度和高度應是輸入圖像的2倍
filter
捲積濾波器的類型,目前僅支持 CV_GAUSSIAN_5x5

函數 cvPyrUp 使用Gaussian 金字塔分解對輸入圖像向上採樣。首先通過在圖像中插入 0 偶數行和偶數列,然後對得到的圖像用指定的濾波器進行高斯捲積,其中濾波器乘以4做插值。所以輸出圖像是輸入圖像的 4 倍大小。(hunnish: 原理不清楚,尚待探討)


連接部件

CvConnectedComp

連接部件

typedef struct CvConnectedComp
{
    double area; /* 連通域的面積 */
    float value; /* 分割域的灰度縮放值 */
    CvRect rect; /* 分割域的 ROI */
} CvConnectedComp;

FloodFill

用指定顏色填充一個連接域

void cvFloodFill( CvArr* image, CvPoint seed_point, CvScalar new_val,
                  CvScalar lo_diff=cvScalarAll(0), CvScalar up_diff=cvScalarAll(0),
                  CvConnectedComp* comp=NULL, int flags=4, CvArr* mask=NULL );
#define CV_FLOODFILL_FIXED_RANGE (1 << 16)
#define CV_FLOODFILL_MASK_ONLY   (1 << 17)
image
輸入的 1- 或 3-通道, 8-比特或浮點數圖像。輸入的圖像將被函數的操作所改變,除非你選擇 CV_FLOODFILL_MASK_ONLY 選項 (見下麵).
seed_point
開始的種子點.
new_val
新的重新繪製的象素值
lo_diff
當前觀察象素值與其部件領域象素或者待加入該部件的種子象素之負差(Lower difference)的最大值。對 8-比特 彩色圖像,它是一個 packed value.
up_diff
當前觀察象素值與其部件領域象素或者待加入該部件的種子象素之正差(upper difference)的最大值。 對 8-比特 彩色圖像,它是一個 packed value.
comp
指向部件結構體的指針,該結構體的內容由函數用重繪區域的信息填充。
flags
操作選項. 低位比特包含連通值, 4 (預設) 或 8, 在函數執行連通過程中確定使用哪種鄰域方式。高位比特可以是 0 或下麵的開關選項的組合:
  • CV_FLOODFILL_FIXED_RANGE - 如果設置,則考慮當前象素與種子象素之間的差,否則考慮當前象素與其相鄰象素的差。(範圍是浮點數).
  • CV_FLOODFILL_MASK_ONLY - 如果設置,函數不填充原始圖像 (忽略 new_val), 但填充掩模圖像 (這種情況下 MASK 必須是非空的).
mask
運算掩模, 應該是單通道、8-比特圖像, 長和寬上都比輸入圖像 image 大兩個象素點。若非空,則函數使用且更新掩模, 所以使用者需對 mask 內容的初始化負責。填充不會經過 MASK 的非零象素, 例如,一個邊緣檢測子的輸出可以用來作為 MASK 來阻止填充邊緣。或者有可能在多次的函數調用中使用同一個 MASK,以保證填充的區域不會重疊。註意: 因為 MASK 比欲填充圖像大,所以 mask 中與輸入圖像(x,y)像素點相對應的點具有(x+1,y+1)坐標。

函數 cvFloodFill 用指定顏色,從種子點開始填充一個連通域。連通性由象素值的接近程度來衡量。在點 (x, y) 的象素被認為是屬於重新繪製的區域,如果:

src(x',y')-lo_diff<=src(x,y)<=src(x',y')+up_diff, 灰度圖像,浮動範圍
src(seed.x,seed.y)-lo<=src(x,y)<=src(seed.x,seed.y)+up_diff, 灰度圖像,固定範圍
src(x',y')r-lo_diffr<=src(x,y)r<=src(x',y')r+up_diffr 和
src(x',y')g-lo_diffg<=src(x,y)g<=src(x',y')g+up_diffg 和
src(x',y')b-lo_diffb<=src(x,y)b<=src(x',y')b+up_diffb, 彩色圖像,浮動範圍
src(seed.x,seed.y)r-lo_diffr<=src(x,y)r<=src(seed.x,seed.y)r+up_diffr 和
src(seed.x,seed.y)g-lo_diffg<=src(x,y)g<=src(seed.x,seed.y)g+up_diffg 和
src(seed.x,seed.y)b-lo_diffb<=src(x,y)b<=src(seed.x,seed.y)b+up_diffb, 彩色圖像,固定範圍

其中 src(x',y') 是象素鄰域點的值。也就是說,為了被加入到連通域中,一個象素的彩色/亮度應該足夠接近於:

  • 它的鄰域象素的彩色/亮度值,當該鄰域點已經被認為屬於浮動範圍情況下的連通域。
  • 固定範圍情況下的種子點的彩色/亮度值

FindContours

在二值圖像中尋找輪廓

int cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour,
                    int header_size=sizeof(CvContour), int mode=CV_RETR_LIST,
                    int method=CV_CHAIN_APPROX_SIMPLE, CvPoint offset=cvPoint(0,0) );
image
輸入的 8-比特、單通道圖像. 非零元素被當成 1, 0 象素值保留為 0 - 從而圖像被看成二值的。為了從灰度圖像中得到這樣的二值圖像,可以使用 cvThreshold, cvAdaptiveThreshold 或 cvCanny. 本函數改變輸入圖像內容。
storage
得到的輪廓的存儲容器
first_contour
輸出參數:包含第一個輸出輪廓的指針
header_size
如果 method=CV_CHAIN_CODE,則序列頭的大小 >=sizeof(CvChain),否則 >=sizeof(CvContour) .
mode
提取模式.
  • CV_RETR_EXTERNAL - 只提取最外層的輪廓
  • CV_RETR_LIST - 提取所有輪廓,並且放置在 list 中
  • CV_RETR_CCOMP - 提取所有輪廓,並且將其組織為兩層的 hierarchy: 頂層為連通域的外圍邊界,次層為洞的內層邊界。
  • CV_RETR_TREE - 提取所有輪廓,並且重構嵌套輪廓的全部 hierarchy
method
逼近方法 (對所有節點, 不包括使用內部逼近的 CV_RETR_RUNS).
  • CV_CHAIN_CODE - Freeman 鏈碼的輸出輪廓. 其它方法輸出多邊形(定點序列).
  • CV_CHAIN_APPROX_NONE - 將所有點由鏈碼形式翻譯(轉化)為點序列形式
  • CV_CHAIN_APPROX_SIMPLE - 壓縮水平、垂直和對角分割,即函數只保留末端的象素點;
  • CV_CHAIN_APPROX_TC89_L1,
  • CV_CHAIN_APPROX_TC89_KCOS - 應用 Teh-Chin 鏈逼近演算法. CV_LINK_RUNS - 通過連接為 1 的水平碎片使用完全不同的輪廓提取演算法。僅有 CV_RETR_LIST 提取模式可以在本方法中應用.
offset
每一個輪廓點的偏移量. 當輪廓是從圖像 ROI 中提取出來的時候,使用偏移量有用,因為可以從整個圖像上下文來對輪廓做分析.

函數 cvFindContours 從二值圖像中提取輪廓,並且返回提取輪廓的數目。指針 first_contour 的內容由函數填寫。它包含第一個最外層輪廓的指針,如果指針為 NULL,則沒有檢測到輪廓(比如圖像是全黑的)。其它輪廓可以從 first_contour 利用 h_next 和 v_next 鏈接訪問到。 在 cvDrawContours 的樣例顯示如何使用輪廓來進行連通域的檢測。輪廓也可以用來做形狀分析和對象識別 - 見CVPR2001 教程中的 squares 樣例。該教程可以在 SourceForge 網站上找到。

StartFindContours

初始化輪廓的掃描過程

CvContourScanner cvStartFindContours( CvArr* image, CvMemStorage* storage,
                                      int header_size=sizeof(CvContour),
                                      int mode=CV_RETR_LIST,
                                      int method=CV_CHAIN_APPROX_SIMPLE,
                                      CvPoint offset=cvPoint(0,0) );
image
輸入的 8-比特、單通道二值圖像
storage
提取到的輪廓容器
header_size
序列頭的尺寸 >=sizeof(CvChain) 若 method=CV_CHAIN_CODE,否則尺寸 >=sizeof(CvContour) .
mode
提取模式,見 cvFindContours.
method
逼近方法。它與 cvFindContours 里的定義一樣,但是 CV_LINK_RUNS 不能使用。
offset
ROI 偏移量,見 cvFindContours.

函數 cvStartFindContours 初始化並且返回輪廓掃描器的指針。掃描器在 cvFindNextContour 使用以提取其餘的輪廓。

FindNextContour

Finds next contour in the image

CvSeq* cvFindNextContour( CvContourScanner scanner );
scanner
被函數 cvStartFindContours 初始化的輪廓掃描器.

函數 cvFindNextContour 確定和提取圖像的下一個輪廓,並且返回它的指針。若沒有更多的輪廓,則函數返回 NULL.

SubstituteContour

替換提取的輪廓

void cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
scanner
被函數 cvStartFindContours 初始化的輪廓掃描器 ..
new_contour
替換的輪廓

函數 cvSubstituteContour 把用戶自定義的輪廓替換前一次的函數 cvFindNextContour 調用所提取的輪廓,該輪廓以用戶定義的模式存儲在邊緣掃描狀態之中。輪廓,根據提取狀態,被插入到生成的結構,List,二層 hierarchy, 或 tree 中。如果參數 new_contour=NULL, 則提取的輪廓不被包含入生成結構中,它的所有後代以後也不會被加入到介面中。

EndFindContours

結束掃描過程

 CvSeq* cvEndFindContours( CvContourScanner* scanner );
scanner
輪廓掃描的指針.

函數 cvEndFindContours 結束掃描過程,並且返回最高層的第一個輪廓的指針。


PyrSegmentation

用金字塔實現圖像分割

void cvPyrSegmentation( IplImage* src, IplImage* dst,
                        CvMemStorage* storage, CvSeq** comp,
                        int level, double threshold1, double threshold2 );
src
輸入圖像.
dst
輸出圖像.
storage
Storage: 存儲連通部件的序列結果
comp
分割部件的輸出序列指針 components.
level
建立金字塔的最大層數
threshold1
建立連接的錯誤閾值
threshold2
分割簇的錯誤閾值

函數 cvPyrSegmentation 實現了金字塔方法的圖像分割。金字塔建立到 level 指定的最大層數。如果 p(c(a),c(b))<threshold1,則在層 i 的象素點 a 和它的相鄰層的父親象素 b 之間的連接被建立起來,

定義好連接部件後,它們被加入到某些簇中。如果p(c(A),c(B))<threshold2,則任何兩個分割 A 和 B 屬於同一簇。

如果輸入圖像只有一個通道,那麼

p(c¹,c²)=|c¹-c²|. 

如果輸入圖像有單個通道(紅、綠、蘭),那麼

p(c¹,c²)=0,3·(c¹r-c²r)+0,59·(c¹g-c²g)+0,11·(c¹b-c²b) . 

每一個簇可以有多個連接部件。 圖像 src 和 dst 應該是 8-比特、單通道 或 3-通道圖像,且大小一樣

PyrMeanShiftFiltering

Does meanshift image segmentation

void cvPyrMeanShiftFiltering( const CvArr* src, CvArr* dst,
     double sp, double sr, int max_level=1,
     CvTermCriteria termcrit=cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1));
src
輸入的8-比特,3-通道圖象.
dst
和源圖象相同大小,相同格式的輸出圖象.
sp
The spatial window radius.
空間窗的半徑
sr
The color window radius.
色彩窗的半徑
max_level
Maximum level of the pyramid for the segmentation.
termcrit
Termination criteria: when to stop meanshift iterations.

The function cvPyrMeanShiftFiltering implements the filtering stage of meanshift segmentation, that is, the output of the function is the filtered "posterized" image with color gradients and fine-grain texture flattened. At every pixel (X,Y) of the input image (or down-sized input image, see below) the function executes meanshift iterations, that is, the pixel (X,Y) neighborhood in the joint space-color hyperspace is considered:

{(x,y): X-sp≤x≤X+sp && Y-sp≤y≤Y+sp && ||(R,G,B)-(r,g,b)|| ≤ sr},where (R,G,B) and (r,g,b) are the vectors of color components at (X,Y) and (x,y), respectively (though, the algorithm does not depend on the color space used, so any 3-component color space can be used instead). Over the neighborhood the average spatial value (X',Y') and average color vector (R',G',B') are found and they act as the neighborhood center on the next iteration: (X,Y)~(X',Y'), (R,G,B)~(R',G',B').After the iterations over, the color components of the initial pixel (that is, the pixel from where the iterations started) are set to the final value (average color at the last iteration): I(X,Y) <- (R*,G*,B*).Then max_level>0, the gaussian pyramid of max_level+1 levels is built, and the above procedure is run on the smallest layer. After that, the results are propagated to the larger layer and the iterations are run again only on those pixels where the layer colors differ much (>sr) from the lower-resolution layer, that is, the boundaries of the color regions are clarified. Note, that the results will be actually different from the ones obtained by running the meanshift procedure on the whole original image (i.e. when max_level==0).

Watershed

做分水嶺圖像分割

void cvWatershed( const CvArr* image, CvArr* markers );
image
輸入8比特3通道圖像。
markers
輸入或輸出的32比特單通道標記圖像。

函數cvWatershed實現在[Meyer92]描述的變數分水嶺,基於非參數標記的分割演算法中的一種。在把圖像傳給函數之前,用戶需要用正指標大致勾畫出圖像標記的感興趣區域。比如,每一個區域都表示成一個或者多個像素值1,2,3的互聯部分。這些部分將作為將來圖像區域的種子。標記中所有的其他像素,他們和勾畫出的區域關係不明並且應由演算法定義,應當被置0。這個函數的輸出則是標記區域所有像素被置為某個種子部分的值,或者在區域邊界則置-1。

註:每兩個相鄰區域也不是必須有一個分水嶺邊界(-1像素)分開,例如在初始標記圖像里有這樣相切的部分。opencv常式文件夾裡面有函數的視覺效果演示和用戶常式。見watershed.cpp。

圖像與輪廓矩

Moments

計算多邊形和光柵形狀的最高達三階的所有矩

void cvMoments( const CvArr* arr, CvMoments* moments, int binary=0 );
arr
圖像 (1-通道或3-通道,有COI設置) 或多邊形(點的 CvSeq 或一族點的向量).
moments
返回的矩狀態介面的指針
binary
(僅對圖像) 如果標識為非零,則所有零象素點被當成零,其它的被看成 1.

函數 cvMoments 計算最高達三階的空間和中心矩,並且將結果存在結構 moments 中。矩用來計算形狀的重心,面積,主軸和其它的形狀特征,如 7 Hu 不變數等。

GetSpatialMoment

從矩狀態結構中提取空間矩

double cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );
moments
矩狀態,由 cvMoments 計算
x_order
提取的 x 次矩, x_order >= 0.
y_order
提取的 y 次矩, y_order >= 0 並且 x_order + y_order <= 3.

函數 cvGetSpatialMoment 提取空間矩,當圖像矩被定義為:

Mx_order,y_order=sumx,y(I(x,y)•xx_order•yy_order)

其中 I(x,y) 是象素點 (x, y) 的亮度值.

GetCentralMoment

從矩狀態結構中提取中心矩

double cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );
moments
矩狀態結構指針
x_order
提取的 x 階矩, x_order >= 0.
y_order
提取的 y 階矩, y_order >= 0 且 x_order + y_order <= 3.

函數 cvGetCentralMoment 提取中心矩,其中圖像矩的定義是:

μx_order,y_order=sumx,y(I(x,y)•(x-xc)x_order•(y-yc)y_order),

其中 xc=M10/M00, yc=M01/M00 - 重心坐標

GetNormalizedCentralMoment

從矩狀態結構中提取歸一化的中心矩

double cvGetNormalizedCentralMoment( CvMoments* moments, int x_order, int y_order );
moments
矩狀態結構指針
x_order
提取的 x 階矩, x_order >= 0.
y_order
提取的 y 階矩, y_order >= 0 且 x_order + y_order <= 3.

函數 cvGetNormalizedCentralMoment 提取歸一化中心矩:

ηx_order,y_order= μx_order,y_order/M00((y_order+x_order)/2+1)

GetHuMoments

計算 7 Hu 不變數

void cvGetHuMoments( CvMoments* moments, CvHuMoments* hu_moments );
moments
矩狀態結構的指針
hu_moments
Hu 矩結構的指針.

函數 cvGetHuMoments 計算 7 個 Hu 不變數,它們的定義是:

 h1=η20+η02
 h2=(η20-η02)²+4η11²
 h3=(η30-3η12)²+ (3η21-η03)²
 h4=(η30+η12)²+ (η21+η03)²
 h5=(η30-3η12)(η30+η12)[(η30+η12)²-3(η21+η03)²]+(3η21-η03)(η21+η03)[3(η30+η12)²-(η21+η03)²]
 h6=(η20-η02)[(η30+η12)²- (η21+η03)²]+4η11(η30+η12)(η21+η03)
 h7=(3η21-η03)(η21+η03)[3(η30+η12)²-(η21+η03)²]-(η30-3η12)(η21+η03)[3(η30+η12)²-(η21+η03)²]

這些值被證明為對圖像縮放、旋轉和反射的不變數。對反射,第7個除外,因為它的符號會因為反射而改變。

特殊圖像變換

HoughLines

利用 Hough 變換在二值圖像中找到直線

CvSeq* cvHoughLines2( CvArr* image, void* line_storage, int method,
                      double rho, double theta, int threshold,
                      double param1=0, double param2=0 );
image
輸入 8-比特、單通道 (二值) 圖像,當用CV_HOUGH_PROBABILISTIC方法檢測的時候其內容會被函數改變
line_storage
檢測到的線段存儲倉. 可以是記憶體存儲倉 (此種情況下,一個線段序列在存儲倉中被創建,並且由函數返回),或者是包含線段參數的特殊類型(見下麵)的具有單行/單列的矩陣(CvMat*)。矩陣頭為函數所修改,使得它的 cols/rows 將包含一組檢測到的線段。如果 line_storage 是矩陣,而實際線段的數目超過矩陣尺寸,那麼最大可能數目的線段被返回(對於標準hough變換,線段按照長度降序輸出).
method
Hough 變換變數,是下麵變數的其中之一:
  • CV_HOUGH_STANDARD - 傳統或標準 Hough 變換. 每一個線段由兩個浮點數 (ρ, θ) 表示,其中 ρ 是直線與原點 (0,0) 之間的距離,θ 線段與 x-軸之間的夾角。因此,矩陣類型必須是 CV_32FC2 type.
  • CV_HOUGH_PROBABILISTIC - 概率 Hough 變換(如果圖像包含一些長的線性分割,則效率更高). 它返回線段分割而不是整個線段。每個分割用起點和終點來表示,所以矩陣(或創建的序列)類型是 CV_32SC4.
  • CV_HOUGH_MULTI_SCALE - 傳統 Hough 變換的多尺度變種。線段的編碼方式與 CV_HOUGH_STANDARD 的一致。
rho
與象素相關單位的距離精度
theta
弧度測量的角度精度
threshold
閾值參數。如果相應的累計值大於 threshold, 則函數返回的這個線段.
param1
第一個方法相關的參數:
  • 對傳統 Hough 變換,不使用(0).
  • 對概率 Hough 變換,它是最小線段長度.
  • 對多尺度 Hough 變換,它是距離精度 rho 的分母 (大致的距離精度是 rho 而精確的應該是 rho / param1 ).
param2
第二個方法相關參數:
  • 對傳統 Hough 變換,不使用 (0).
  • 對概率 Hough 變換,這個參數表示在同一條直線上進行碎線段連接的最大間隔值(gap), 即當同一條直線上的兩條碎線段之間的間隔小於param2時,將其合二為一。
  • 對多尺度 Hough 變換,它是角度精度 theta 的分母 (大致的角度精度是 theta 而精確的角度應該是 theta / param2).

函數 cvHoughLines2 實現了用於線段檢測的不同 Hough 變換方法. Example. 用 Hough transform 檢測線段

/* This is a standalone program. Pass an image name as a first parameter
   of the program.Switch between standard and probabilistic Hough transform
   by changing "#if 1" to "#if 0" and back */
#include <cv.h>
#include <highgui.h>
#include <math.h>

int main(int argc, char** argv)
{
    IplImage* src;
    //if( argc == 2 && (src=cvLoadImage(argv[1], 0))!= 0)   // if use 0, it will convert src to gray image,then  call cvCvtColor function will throw an exception at opencv2.3
    if( argc == 2 && (src=cvLoadImge(argv[1])) != 0 ) 
    {
        IplImage* dst = cvCreateImage( cvGetSize(src), 8, 1 );
        IplImage* color_dst = cvCreateImage( cvGetSize(src), 8, 3 );
        CvMemStorage* storage = cvCreateMemStorage(0);
        CvSeq* lines = 0;
        int i;
	IplImage* src1=cvCreateImage(cvSize(src->width,src->height),IPL_DEPTH_8U,1);

	cvCvtColor(src, src1, CV_BGR2GRAY);  
        cvCanny( src1, dst, 50, 200, 3 );

        cvCvtColor( dst, color_dst, CV_GRAY2BGR );
#if 1
        lines = cvHoughLines2( dst, storage, CV_HOUGH_STANDARD, 1, CV_PI/180, 150, 0, 0 );

        for( i = 0; i < lines->total; i++ )
        {
            float* line = (float*)cvGetSeqElem(lines,i);
            float rho = line[0];
            float theta = line[1];
            CvPoint pt1, pt2;
            double a = cos(theta), b = sin(theta);
            if( fabs(a) < 0.001 )
            {
                pt1.x = pt2.x = cvRound(rho);
                pt1.y = 0;
                pt2.y = color_dst->height;
            }
            else if( fabs(b) < 0.001 )
            {
                pt1.y = pt2.y = cvRound(rho);
                pt1.x = 0;
                pt2.x = color_dst->width;
            }
            else
            {
                pt1.x = 0;
                pt1.y = cvRound(rho/b);
                pt2.x = cvRound(rho/a);
                pt2.y = 0;
            }
            cvLine( color_dst, pt1, pt2, CV_RGB(255,0,0), 3, 8 );
        }
#else
        lines = cvHoughLines2( dst, storage, CV_HOUGH_PROBABILISTIC, 1, CV_PI/180, 80, 30, 10 );
        for( i = 0; i < lines->total; i++ )
        {
            CvPoint* line = (CvPoint*)cvGetSeqElem(lines,i);
            cvLine( color_dst, line[0], line[1], CV_RGB(255,0,0), 3, 8 );
        }
#endif
        cvNamedWindow( "Source", 1 );
        cvShowImage( "Source", src );

        cvNamedWindow( "Hough", 1 );
        cvShowImage( "Hough", color_dst );

        cvWaitKey(0);
    }
}

這是函數所用的樣本圖像:

Image:Building.jpg

下麵是程式的輸出,採用概率 Hough transform ("#if 0" 的部分):

Image:Houghp.png

HoughCircles

利用 Hough 變換在灰度圖像中找圓

CvSeq* cvHoughCircles( CvArr* image, void* circle_storage,
                       int method, double dp, double min_dist,
                       double param1=100, double param2=100,
                       int min_radius=0, int max_radius=0 );
image
輸入 8-比特、單通道灰度圖像.
circle_storage
檢測到的圓存儲倉. 可以是記憶體存儲倉 (此種情況下,一個線段序列在存儲倉中被創建,並且由函數返回)或者是包含圓參數的特殊類型的具有單行/單列的CV_32FC3型矩陣(CvMat*). 矩陣頭為函數所修改,使得它的 cols/rows 將包含一組檢測到的圓。如果 circle_storage 是矩陣,而實際圓的數目超過矩陣尺寸,那麼最大可能數目的圓被返回

. 每個圓由三個浮點數表示:圓心坐標(x,y)和半徑.

method
Hough 變換方式,目前只支持CV_HOUGH_GRADIENT, which is basically 21HT, described in [Yuen03].
dp
累加器圖像的解析度。這個參數允許創建一個比輸入圖像解析度低的累加器。(這樣做是因為有理由認為圖像中存在的圓會自然降低到與圖像寬高相同數量的範疇)。如果dp設置為1,則解析度是相同的;如果設置為更大的值(比如2),累加器的解析度受此影響會變小(此情況下為一半)。dp的值不能比1小。

Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc.

min_dist
該參數是讓演算法能明顯區分的兩個不同圓之間的最小距離。

Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed.

param1
用於Canny的邊緣閥值上限,下限被置為上限的一半。

The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller).

param2
累加器的閥值。

The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first.

min_radius
最小圓半徑。

Minimal radius of the circles to search for.

max_radius
最大圓半徑。

Maximal radius of the circles to search for. By default the maximal radius is set to max(image_width, image_height).

The function cvHoughCircles finds circles in grayscale image using some modification of Hough transform.

Example. Detecting circles with Hough transform.

#include <cv.h>
#include <highgui.h>
#include <math.h>

int main(int argc, char** argv)
{
    IplImage* img;
    if( argc == 2 && (img=cvLoadImage(argv[1], 1))!= 0)
    {
        IplImage* gray = cvCreateImage( cvGetSize(img), 8, 1 );
        CvMemStorage* storage = cvCreateMemStorage(0);
        cvCvtColor( img, gray, CV_BGR2GRAY );
        cvSmooth( gray, gray, CV_GAUSSIAN, 9, 9 ); // smooth it, otherwise a lot of false circles may be detected
        CvSeq* circles = cvHoughCircles( gray, storage, CV_HOUGH_GRADIENT, 2, gray->height/4, 200, 100 );
        int i;
        for( i = 0; i < circles->total; i++ )
        {
             float* p = (float*)cvGetSeqElem( circles, i );
             cvCircle( img, cvPoint(cvRound(p[0]),cvRound(p[1])), 3, CV_RGB(0,255,0), -1, 8, 0 );
             cvCircle( img, cvPoint(cvRound(p[0]),cvRound(p[1])), cvRound(p[2]), CV_RGB(255,0,0), 3, 8, 0 );
        }
        cvNamedWindow( "circles", 1 );
        cvShowImage( "circles", img );
    }
    return 0;
}

DistTransform

計算輸入圖像的所有非零元素對其最近零元素的距離

void cvDistTransform( const CvArr* src, CvArr* dst, int distance_type=CV_DIST_L2,
                      int mask_size=3, const float* mask=NULL );
src
輸入 8-比特、單通道 (二值) 圖像.
dst
含計算出的距離的輸出圖像(32-比特、浮點數、單通道).
distance_type
距離類型; 可以是 CV_DIST_L1, CV_DIST_L2, CV_DIST_C 或 CV_DIST_USER.
mask_size
距離變換掩模的大小,可以是 3 或 5. 對 CV_DIST_L1 或 CV_DIST_C 的情況,參數值被強制設定為 3, 因為 3×3 mask 給出 5×5 mask 一樣的結果,而且速度還更快。
mask
用戶自定義距離情況下的 mask。 在 3×3 mask 下它由兩個數(水平/垂直位量,對角線位移量)組成, 5×5 mask 下由三個數組成(水平/垂直位移量,對角位移和 國際象棋里的馬步(馬走日))

函數 cvDistTransform 二值圖像每一個象素點到它最鄰近零象素點的距離。對零象素,函數設置 0 距離,對其它象素,它尋找由基本位移(水平、垂直、對角線或knight's move,最後一項對 5×5 mask 有用)構成的最短路徑。 全部的距離被認為是基本距離的和。由於距離函數是對稱的,所有水平和垂直位移具有同樣的代價 (表示為 a ), 所有的對角位移具有同樣的代價 (表示為 b), 所有的 knight's 移動具有同樣的代價 (表示為 c). 對類型 CV_DIST_C 和 CV_DIST_L1,距離的計算是精確的,而類型 CV_DIST_L2 (歐式距離) 距離的計算有某些相對誤差 (5×5 mask 給出更精確的結果), OpenCV 使用 [Borgefors86] 推薦的值:

CV_DIST_C (3×3):
a=1, b=1
CV_DIST_L1 (3×3):
a=1, b=2
CV_DIST_L2 (3×3):
a=0.955, b=1.3693
CV_DIST_L2 (5×5):
a=1, b=1.4, c=2.1969

下麵用戶自定義距離的的距離域示例 (黑點 (0) 在白色方塊中間): 用戶自定義 3×3 mask (a=1, b=1.5)

4.5 4 3.5 3 3.5 4 4.5
4 3 2.5 2 2.5 3 4
3.5 2.5 1.5 1 1.5 2.5 3.5
3 2 1 0 1 2 3
3.5 2.5 1.5 1 1.5 2.5 3.5
4 3 2.5 2 2.5 3 4
4.5 4 3.5 3 3.5 4 4.5

用戶自定義 5×5 mask (a=1, b=1.5, c=2)

4.5 3.5 3 3 3 3.5 4.5
3.5 3 2 2 2 3 3.5
3 2 1.5 1 1.5 2 3
3 2 1 0 1 2 3
3 2 1.5 1 1.5 2 3
3.5 3 2 2 2 3 3.5
4 3.5 3 3 3 3.5 4

典型的使用快速粗略距離估計 CV_DIST_L2, 3×3 mask , 如果要更精確的距離估計,使用 CV_DIST_L2, 5×5 mask。

When the output parameter labels is not NULL, for every non-zero pixel the function also finds the nearest connected component consisting of zero pixels. The connected components themselves are found as contours in the beginning of the function.

In this mode the processing time is still O(N), where N is the number of pixels. Thus, the function provides a very fast way to compute approximate Voronoi diagram for the binary image.

Inpaint

修複圖像中選擇區域。

void cvInpaint( const CvArr* src, const CvArr* mask, CvArr* dst,
                int flags, double inpaintRadius );
src
輸入8比特單通道或者三通道圖像。
mask
修複圖像的掩飾,8比特單通道圖像。非零像素表示該區域需要修複。
dst
輸出圖像,和輸入圖像相同格式相同大小。
flags
修複方法,以下之一:
CV_INPAINT_NS - 基於Navier-Stokes的方法。
CV_INPAINT_TELEA - Alexandru Telea[Telea04]的方法。
inpaintRadius
演算法考慮的每個修複點的圓形領域的半徑。

函數cvInpaint從選擇圖像區域邊界的像素重建該區域。函數可以用來去除掃描相片的灰塵或者刮傷,或者從靜態圖像或者視頻中去除不需要的物體。

直方圖

CvHistogram

多維直方圖

typedef struct CvHistogram
{
    int     type;
    CvArr*  bins;
    float   thresh[CV_MAX_DIM][2]; /* for uniform histograms */
    float** thresh2; /* for non-uniform histograms */
    CvMatND mat; /* embedded matrix header for array histograms */
}
CvHistogram;

bins : 用於存放直方圖每個灰度級數目的數組指針,數組在cvCreateHist 的時候創建,其維數由cvCreateHist 確定(一般以一維比較常見)

CreateHist

創建直方圖

CvHistogram* cvCreateHist( int dims, int* sizes, int type,
                           float** ranges=NULL, int uniform=1 );
dims
直方圖維數的數目
sizes
直方圖維數尺寸的數組
type
直方圖的表示格式: CV_HIST_ARRAY 意味著直方圖數據表示為多維密集數組 CvMatND; CV_HIST_TREE 意味著直方圖數據表示為多維稀疏數組 CvSparseMat.
ranges
圖中方塊範圍的數組. 它的內容取決於參數 uniform 的值。這個範圍的用處是確定何時計算直方圖或決定反向映射(backprojected ),每個方塊對應於輸入圖像的哪個/哪組值。
uniform
歸一化標識。 如果不為0,則ranges[i](0<=i<cDims,譯者註:cDims為直方圖的維數,對於灰度圖為1,彩色圖為3)是包含兩個元素的範圍數組,包括直方圖第i維的上界和下界。在第i維上的整個區域 [lower,upper]被分割成 dims[i] 個相等的塊(譯者註:dims[i]表示直方圖第i維的塊數),這些塊用來確定輸入象素的第 i 個值(譯者註:對於彩色圖像,i確定R, G,或者B)的對應的塊;如果為0,則ranges[i]是包含dims[i]+1個元素的範圍數組,包括lower0, upper0, lower1, upper1 == lower2, ..., upperdims[i]-1, 其中lowerj 和upperj分別是直方圖第i維上第 j 個方塊的上下界(針對輸入象素的第 i 個值)。任何情況下,輸入值如果超出了一個直方塊所指定的範圍外,都不會被 cvCalcHist 計數,而且會被函數 cvCalcBackProject 置零。

函數 cvCreateHist 創建一個指定尺寸的直方圖,並且返回創建的直方圖的指針。 如果數組的 ranges 是 0, 則直方塊的範圍必須由函數 cvSetHistBinRanges 稍後指定。雖然 cvCalcHist 和 cvCalcBackProject 可以處理 8-比特圖像而無需設置任何直方塊的範圍,但它們都被假設等分 0..255 之間的空間。

SetHistBinRanges

設置直方塊的區間

void cvSetHistBinRanges( CvHistogram* hist, float** ranges, int uniform=1 );

hist

直方圖.

ranges

直方塊範圍數組的數組,見 cvCreateHist.

uniform

歸一化標識,見 cvCreateHist.

函數 cvSetHistBinRanges 是一個獨立的函數,完成直方塊的區間設置。更多詳細的關於參數 ranges 和 uniform 的描述,請參考函數 cvCalcHist , 該函數也可以初始化區間。直方塊的區間的設置必須在計算直方圖之前,或 在計算直方圖的反射圖之前。

ReleaseHist

釋放直方圖結構

void cvReleaseHist( CvHistogram** hist );
hist
被釋放的直方圖結構的雙指針.

函數 cvReleaseHist 釋放直方圖 (頭和數據). 指向直方圖的指針被函數所清空。如果 *hist 指針已經為 NULL, 則函數不做任何事情。

ClearHist

清除直方圖

void cvClearHist( CvHistogram* hist );
hist
直方圖.

函數 cvClearHist 當直方圖是稠密數組時將所有直方塊設置為 0,當直方圖是稀疏數組時,除去所有的直方塊。

MakeHistHeaderForArray

從數組中創建直方圖

CvHistogram*  cvMakeHistHeaderForArray( int dims, int* sizes, CvHistogram* hist,
                                        float* data, float** ranges=NULL, int uniform=1 );
dims
直方圖維數.
sizes
直方圖維數尺寸的數組
hist
為函數所初始化的直方圖頭
data
用來存儲直方塊的數組
ranges
直方塊範圍,見 cvCreateHist.
uniform
歸一化標識,見 cvCreateHist.

函數 cvMakeHistHeaderForArray 初始化直方圖,其中頭和直方塊為用戶所分配。以後不需要調用 cvReleaseHist 只有稠密直方圖可以採用這種方法,函數返回 hist.

QueryHistValue_1D

查詢直方塊的值

#define cvQueryHistValue_1D( hist, idx0 ) \
    cvGetReal1D( (hist)->bins, (idx0) )
#define cvQueryHistValue_2D( hist, idx0, idx1 ) \
    cvGetReal2D( (hist)->bins, (idx0), (idx1) )
#define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
    cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2) )
#define cvQueryHistValue_nD( hist, idx ) \
    cvGetRealND( (hist)->bins, (idx) )
hist
直方圖
idx0, idx1, idx2, idx3
直方塊的下標索引
idx
下標數組

巨集 cvQueryHistValue_*D 返回 1D, 2D, 3D 或 N-D 直方圖的指定直方塊的值。對稀疏直方圖,如果方塊在直方圖中不存在,函數返回 0, 而且不創建新的直方塊。

GetHistValue_1D

返回直方塊的指針

#define cvGetHistValue_1D( hist, idx0 ) \
    ((float*)(cvPtr1D( (hist)->bins, (idx0), 0 ))
#define cvGetHistValue_2D( hist, idx0, idx1 ) \
    ((float*)(cvPtr2D( (hist)->bins, (idx0), (idx1), 0 ))
#define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
    ((float*)(cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0 ))
#define cvGetHistValue_nD( hist, idx ) \
    ((float*)(cvPtrND( (hist)->bins, (idx), 0 ))
hist
直方圖.
idx0, idx1, idx2, idx3
直方塊的下標索引.
idx
下標數組

巨集 cvGetHistValue_*D 返回 1D, 2D, 3D 或 N-D 直方圖的指定直方塊的指針。對稀疏直方圖,函數創建一個新的直方塊,且設置其為 0,除非它已經存在。

GetMinMaxHistValue

發現最大和最小直方塊

void cvGetMinMaxHistValue( const CvHistogram* hist,
                           float* min_value, float* max_value,
                           int* min_idx=NULL, int* max_idx=NULL );
hist
直方圖
min_value
直方圖最小值的指針
max_value
直方圖最大值的指針
min_idx
數組中最小坐標的指針
max_idx
數組中最大坐標的指針

函數 cvGetMinMaxHistValue 發現最大和最小直方塊以及它們的位置。任何輸出變數都是可選的。在具有同樣值幾個極值中,返回具有最小下標索引(以字母排列順序定)的那一個。

NormalizeHist

歸一化直方圖

void cvNormalizeHist( CvHistogram* hist, double factor );
hist
直方圖的指針.
factor
歸一化因數

函數 cvNormalizeHist 通過縮放來歸一化直方塊,使得所有塊的和等於 factor.

ThreshHist

對直方圖取閾值

void cvThreshHist( CvHistogram* hist, double threshold );
hist
直方圖的指針.
threshold
閾值大小

函數 cvThreshHist 清除那些小於指定閾值得直方塊

CompareHist

比較兩個稠密直方圖

double cvCompareHist( const CvHistogram* hist1, const CvHistogram* hist2, int method );
hist1
第一個稠密直方圖
hist2
第二個稠密直方圖
method
比較方法,採用其中之一:
  • CV_COMP_CORREL
  • CV_COMP_CHISQR
  • CV_COMP_INTERSECT
  • CV_COMP_BHATTACHARYYA
函數 cvCompareHist 採用下麵指定的方法比較兩個稠密直方圖(H1 表示第一個, H2表示第二個):
  • Correlation (method=CV_COMP_CORREL):
d(H1,H2)=\frac{\sum_i {H'_1(i) \cdot H'_2(i)}} {\sqrt{ (\sum_j H'_1(j)^2) \cdot (\sum_j H'_2(j)^2)} }
其中
H'_k(i)=H_k(i)- \frac{1}{N} \sum_j H_k(j) (N 是number of histogram bins)
  • Chi-square(method=CV_COMP_CHISQR):
d(H_1,H_2)=\sum_i \frac{H_1(i)-H_2(i)}{H_1(i)+H_2(i)}
  • 交叉 (method=CV_COMP_INTERSECT):
d(H1,H2) = min(H1(i),H2(i))
i
  • Bhattacharyya 距離 (method=CV_COMP_BHATTACHARYYA):
d(H_1,H_2) =  \sqrt{1 - \frac{1}{\sqrt{\bar{H_1} \bar{H_2} N^2}} \sum_I \sqrt{H_1(I) \cdot H_2(I)}}

函數返回 d(H1,H2) 的值。

註意:Bhattacharyya 距離只能應用到規一化後的直方圖。

為了比較稀疏直方圖或更一般的加權稀疏點集(譯者註:直方圖匹配是圖像檢索中的常用方法),考慮使用函數 cvCalcEMD 。

CopyHist

拷貝直方圖

void cvCopyHist( const CvHistogram* src, CvHistogram** dst );
src
輸入的直方圖
dst
輸出的直方圖指針

函數 cvCopyHist 對直方圖作拷貝。如果第二個直方圖指針 *dst 是 NULL, 則創建一個與 src 同樣大小的直方圖。否則,兩個直方圖必須大小和類型一致。然後函數將輸入的直方塊的值複製到輸出的直方圖中,並且設置取值範圍與 src 的一致。

CalcHist

計算圖像image(s) 的直方圖

void cvCalcHist( IplImage** image, CvHistogram* hist,
                 int accumulate=0, const CvArr* mask=NULL );
image
輸入圖像s (雖然也可以使用 CvMat** ).
hist
直方圖指針
accumulate
累計標識。如果設置,則直方圖在開始時不被清零。這個特征保證可以為多個圖像計算一個單獨的直方圖,或者線上更新直方圖。
mask
操作 mask, 確定輸入圖像的哪個象素被計數

函數 cvCalcHist 計算一張或多張單通道圖像的直方圖(譯者註:若要計算多通道,可像以下例子那樣用多個單通道圖來表示)。 用來增加直方塊的數組元素可從相應輸入圖像的同樣位置提取。 Sample. 計算和顯示彩色圖像的 2D 色調-飽和度圖像

#include <cv.h>
#include <highgui.h>

int main( int argc, char** argv )
{
    IplImage* src;
    if( argc == 2 && (src=cvLoadImage(argv[1], 1))!= 0)
    {
        IplImage* h_plane = cvCreateImage( cvGetSize(src), 8, 1 );
        IplImage* s_plane = cvCreateImage( cvGetSize(src), 8, 1 );
        IplImage* v_plane = cvCreateImage( cvGetSize(src), 8, 1 );
        IplImage* planes[] = { h_plane, s_plane };
        IplImage* hsv = cvCreateImage( cvGetSize(src), 8, 3 );
        int h_bins = 30, s_bins = 32;
        int hist_size[] = {h_bins, s_bins};
        /* hue varies from 0 (~0°red) to 180 (~360°red again) */
        float h_ranges[] = { 0, 180 }; 
        /* saturation varies from 0 (black-gray-white) to 255 (pure spectrum color) */
        float s_ranges[] = { 0, 255 };
        float* ranges[] = { h_ranges, s_ranges };
        int scale = 10;
        IplImage* hist_img = cvCreateImage( cvSize(h_bins*scale,s_bins*scale), 8, 3 );
        CvHistogram* hist;
        float max_value = 0;
        int h, s;

        cvCvtColor( src, hsv, CV_BGR2HSV );
        cvCvtPixToPlane( hsv, h_plane, s_plane, v_plane, 0 );
        hist = cvCreateHist( 2, hist_size, CV_HIST_ARRAY, ranges, 1 );
        cvCalcHist( planes, hist, 0, 0 );
        cvGetMinMaxHistValue( hist, 0, &max_value, 0, 0 );
        cvZero( hist_img );

        for( h = 0; h < h_bins; h++ )
        {
            for( s = 0; s < s_bins; s++ )
            {
                float bin_val = cvQueryHistValue_2D( hist, h, s );
                int intensity = cvRound(bin_val*255/max_value);
                cvRectangle( hist_img, cvPoint( h*scale, s*scale ),
                             cvPoint( (h+1)*scale - 1, (s+1)*scale - 1),
                             CV_RGB(intensity,intensity,intensity), /* graw a grayscale histogram.
                                                                       if you have idea how to do it
                                                                       nicer let us know */
                             CV_FILLED );
            }
        }

        cvNamedWindow( "Source", 1 );
        cvShowImage( "Source", src );

        cvNamedWindow( "H-S Histogram", 1 );
        cvShowImage( "H-S Histogram", hist_img );

        cvWaitKey(0);
    }
}

CalcBackProject

計算反向投影

void cvCalcBackProject( IplImage** image, CvArr* back_project, const CvHistogram* hist );
image
輸入圖像 (也可以傳遞 CvMat** ).
back_project
反向投影圖像,與輸入圖像具有同樣類型.
hist
直方圖

函數 cvCalcBackProject 計算直方圖的反向投影. 對於所有輸入的單通道圖像同一位置的象素數組,該函數根據相應的象素數組(RGB),放置其對應的直方塊的值到輸出圖像中。用統計學術語,輸出圖像象素點的值是觀測數組在某個分佈(直方圖)下的概率。 例如,為了發現圖像中的紅色目標,可以這麼做:

  1. 對紅色物體計算色調直方圖,假設圖像僅僅包含該物體。則直方圖有可能有極值,對應著紅顏色。
  2. 對將要搜索目標的輸入圖像,使用直方圖計算其色調平面的反向投影,然後對圖像做閾值操作。
  3. 在產生的圖像中發現連通部分,然後使用某種附加準則選擇正確的部分,比如最大的連通部分。

這是 Camshift 彩色目標跟蹤器中的一個逼進演算法,除了第三步,CAMSHIFT 演算法使用了上一次目標位置來定位反向投影中的目標。

CalcBackProjectPatch

用直方圖比較來定點陣圖像中的模板

void cvCalcBackProjectPatch( IplImage** image, CvArr* dst,
                             CvSize patch_size, CvHistogram* hist,
                             int method, double factor );
image
輸入圖像 (可以傳遞 CvMat** )
dst
輸出圖像.
patch_size
掃描輸入圖像的補丁尺寸
hist
直方圖
method
比較方法,傳遞給 cvCompareHist (見該函數的描述).
factor
直方圖的歸一化因數,將影響輸出圖像的歸一化縮放。如果為 1,則不定。 /*歸一化因數的類型實際上是double,而非float*/

函數 cvCalcBackProjectPatch 通過輸入圖像補丁的直方圖和給定直方圖的比較,來計算反向投影。提取圖像在 ROI 中每一個位置的某種測量結果產生了數組 image. 這些結果可以是色調, x 差分, y 差分, Laplacian 濾波器, 有方向 Gabor 濾波器等中 的一個或多個。每種測量輸出都被劃歸為它自己的單獨圖像。 image 圖像數組是這些測量圖像的集合。一個多維直方圖 hist 從這些圖像數組中被採樣創建。最後直方圖被歸一化。直方圖 hist 的維數通常很大等於圖像數組 image 的元素個數。

在選擇的 ROI 中,每一個新的圖像被測量並且轉換為一個圖像數組。在以錨點為“補丁”中心的圖像 image 區域中計算直方圖 (如下圖所示)。用參數 norm_factor 來歸一化直方圖,使得它可以與 hist 互相比較。計算出的直方圖與直方圖模型互相比較, (hist 使用函數 cvCompareHist ,比較方法是 method=method). 輸出結果被放置到概率圖像 dst 補丁錨點的對應位置上。這個過程隨著補丁滑過整個 ROI 而重覆進行。迭代直方圖的更新可以通過在原直方圖中減除“補丁”已覆蓋的尾象素點或者加上新覆蓋的象素點來實現,這種更新方式可以節省大量的操作,儘管目前在函數體中還沒有實現。

Back Project Calculation by Patches

Image:Backprojectpatch.png

CalcProbDensity

兩個直方圖相除

void  cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2,
                         CvHistogram* dst_hist, double scale=255 );
hist1
第一個直方圖(分母).
hist2
第二個直方圖
dst_hist
輸出的直方圖
scale
輸出直方圖的尺度因數

函數 cvCalcProbDensity 從兩個直方圖中計算目標概率密度:

dist_hist(I)=0      if hist1(I)==0
             scale  if hist1(I)!=0 && hist2(I)>hist1(I)
             hist2(I)*scale/hist1(I) if hist1(I)!=0 && hist2(I)<=hist1(I)

所以輸出的直方塊小於尺度因數。

EqualizeHist

灰度圖象直方圖均衡化

void cvEqualizeHist( const CvArr* src, CvArr* dst );
src
輸入的 8-比特 單通道圖像
dst
輸出的圖像與輸入圖像大小與數據類型相同

函數 cvEqualizeHist 採用如下法則對輸入圖像進行直方圖均衡化:

  1. 計算輸入圖像的直方圖 H
  2. 直方圖歸一化,因此直方塊和為255
  3. 計算直方圖積分:H'(i) = \sum_{0 \leq j \leq i}H(j)
  4. 採用H'作為查詢表:dst(x,y)=H'(src(x,y))進行圖像變換。

該方法歸一化圖像亮度和增強對比度。

例:彩色圖像的直方圖均衡化

int i;
IplImage *pImageChannel[4] = { 0, 0, 0, 0 };
pSrcImage = cvLoadImage( "test.jpg", 1 ) ; 
IplImage *pImage = cvCreateImage(cvGetSize(pSrcImage), pSrcImage->depth, pSrcImage->nChannels);
if( pSrcImage )
{
	for( i = 0; i < pSrcImage->nChannels; i++ )
	{
		pImageChannel[i] = cvCreateImage( cvGetSize(pSrcImage), pSrcImage->depth, 1 );
	}
	// 通道分離
	cvSplit( pSrcImage, pImageChannel[0], pImageChannel[1],
		pImageChannel[2], pImageChannel[3] );
	for( i = 0; i < pImage->nChannels; i++ )
	{
		// 直方圖均衡化
		cvEqualizeHist( pImageChannel[i], pImageChannel[i] );
	}
	// 通道組合
	cvMerge( pImageChannel[0], pImageChannel[1], pImageChannel[2],
		pImageChannel[3], pImage );
	// ……圖像顯示代碼(略)
	// 釋放資源
	for( i = 0; i < pSrcImage->nChannels; i++ )
	{
		if ( pImageChannel[i] )
		{
			cvReleaseImage( &pImageChannel[i] );
			pImageChannel[i] = 0;
		}
	}
	cvReleaseImage( &pImage );
	pImage = 0;
}

匹配

MatchTemplate

在輸入的源圖像中與模板圖像作重疊比較

void cvMatchTemplate( const CvArr* image, const CvArr* templ,
                      CvArr* result, int method );
image
被搜索的輸入圖像。它應該是單通道、8-比特或32-比特 浮點數圖像
templ
搜索模板,不能大於輸入圖像,且與輸入圖像具有一樣的數據類型
result
比較結果的映射圖像。單通道、32-比特浮點數. 如果圖像是 W×H 而 templ 是 w×h ,則 result 一定是 (W-w+1)×(H-h+1).
method
指定匹配方法:

函數 cvMatchTemplate 與函數 cvCalcBackProjectPatch 類似。它滑動過整個圖像 image, 用指定方法比較 templ 與圖像尺寸為 w×h 的重疊區域,並且將比較結果存到 result 中。 下麵是不同的比較方法,可以使用其中的一種 (I 表示圖像,T - 模板, R - 結果. 模板與圖像重疊區域 x'=0..w-1, y'=0..h-1 之間求和):

method=CV_TM_SQDIFF(平方差):
R(x,y) = [T(x',y') − I(x + x',y + y')]2
x',y'
method=CV_TM_SQDIFF_NORMED:
R(x,y)=\sum_{x',y'}[T(x',y')-I(x+x',y+y')]^2/\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'}I(x+x',y+y')^2}
method=CV_TM_CCORR(互相關):
R(x,y)=\sum_{x',y'}[T(x',y') \cdot I(x+x',y+y')]
method=CV_TM_CCORR_NORMED:
R(x,y)=\sum_{x',y'}[T(x',y') \cdot I(x+x',y+y')]/ \sqrt{\sum_{x',y'}T(x',y')^2  \cdot \sum_{x',y'}I(x+x',y+y')^2}
method=CV_TM_CCOEFF(歸零化互相關):
R(x,y)=\sum_{x',y'}[T'(x',y') \cdot I'(x+x',y+y')],
其中
T'(x',y')=T(x',y') - \frac{1}{w \cdot h} \sum_{x'',y''}T(x'',y'') (mean template brightness=>0)
I'(x+x',y+y')=I(x+x',y+y') - \frac{1}{w\cdot h} \sum_{x'',y''}I(x+x'',y+y'') (mean patch brightness=>0)
method=CV_TM_CCOEFF_NORMED:
R(x,y)=\sum_{x',y'}[T'(x',y')\cdot I'(x+x',y+y')] / \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'}I'(x+x',y+y')^2}

函數完成比較後,通過使用cvMinMaxLoc找全局最小值CV_TM_SQDIFF*) 或者最大值 (CV_TM_CCORR* and CV_TM_CCOEFF*)。

MatchShapes

比較兩個形狀

double cvMatchShapes( const void* object1, const void* object2,
                      int method, double parameter=0 );
object1
第一個輪廓或灰度圖像
object2
第二個輪廓或灰度圖像
method
比較方法,其中之一 CV_CONTOURS_MATCH_I1, CV_CONTOURS_MATCH_I2 or CV_CONTOURS_MATCH_I3.
parameter
比較方法的參數 (目前不用).

函數 cvMatchShapes 比較兩個形狀。 三個實現方法全部使用 Hu 矩 (見 cvGetHuMoments) (A ~ object1, B - object2):

method=CV_CONTOUR_MATCH_I1:
I_1(A,B)=\sum_{i=1}^7 |\frac{1}{m^{A_i}} - \frac{1}{m^{B_i}}|
method=CV_CONTOUR_MATCH_I2:
I_2(A,B)=\sum_{i=1}^7 | m^{A_i} - m^{B_i}|
method=CV_CONTOUR_MATCH_I3:
I_3(A,B)=\sum_{i=1}^7 \frac{|m^{A_i} - m^{B_i}|}{|m^{A_i}|}

其中

m^{A_i}=sign(h^{A_i}) \cdot \log(h^{A_i}),
m^{B_i}=sign(h^{B_i}) \cdot \log(h^{B_i}),
h^{A_i},h^{B_i} 是A 和 B的Hu矩.

CalcEMD2

兩個加權點集之間計算最小工作距離

float cvCalcEMD2( const CvArr* signature1, const CvArr* signature2, int distance_type,
                  CvDistanceFunction distance_func=NULL, const CvArr* cost_matrix=NULL,
                  CvArr* flow=NULL, float* lower_bound=NULL, void* userdata=NULL );
typedef float (*CvDistanceFunction)(const float* f1, const float* f2, void* userdata);
signature1
第一個簽名,大小為 size1×(dims+1) 的浮點數矩陣,每一行依次存儲點的權重和點的坐標。矩陣允許只有一列(即僅有權重),如果使用用戶自定義的代價矩陣。
signature2
第二個簽名,與 signature1 的格式一樣size2×(dims+1),儘管行數可以不同(列數要相同)。當一個額外的虛擬點加入 signature1 或 signature2 中的時候,權重也可不同。
distance_type
使用的準則, CV_DIST_L1, CV_DIST_L2, 和 CV_DIST_C 分別為標準的準則。 CV_DIST_USER 意味著使用用戶自定義函數 distance_func 或預先計算好的代價矩陣 cost_matrix 。
distance_func
用戶自定義的距離函數。用兩個點的坐標計算兩點之間的距離。
cost_matrix
自定義大小為 size1×size2 的代價矩陣。 cost_matrix 和 distance_func 兩者至少有一個必須為 NULL. 而且,如果使用代價函數,下邊界無法計算,因為它需要準則函數。
flow
產生的大小為 size1×size2 流矩陣(flow matrix): flowij 是從 signature1 的第 i 個點到 signature2 的第 j 個點的流(flow)。
lower_bound
可選的輸入/輸出參數:兩個簽名之間的距離下邊界,是兩個質心之間的距離。如果使用自定義代價矩陣,點集的所有權重不等,或者有簽名只包含權重(即該簽名矩陣只有單獨一列),則下邊界也許不會計算。用戶必須初始化 *lower_bound. 如果質心之間的距離大於獲等於 *lower_bound (這意味著簽名之間足夠遠), 函數則不計算 EMD. 任何情況下,函數返回時 *lower_bound 都被設置為計算出來的質心距離。因此如果用戶想同時計算質心距離和T EMD, *lower_bound 應該被設置為 0.
userdata
傳輸到自定義距離函數的可選數據指針

函數 cvCalcEMD2 計算兩個加權點集之間的移動距離或距離下界。在 [RubnerSept98] 中所描述的其中一個應用就是圖像提取得多維直方圖比較。 EMD 是一個使用某種單純形演算法(simplex algorithm)來解決的交通問題。其計算複雜度在最壞情況下是指數形式的,但是平均而言它的速度相當快。對實的準則,下邊界的計算可以更快(使用線性時間演算法),且它可用來粗略確定兩個點集是否足夠遠以至無法聯繫到同一個目標上。

Views
個人工具