2. 程式人生 > >兩種連通區域標記演算法

兩種連通區域標記演算法

阿新 • • 發佈：2019-01-08

一、 One-Pass對應的標記演算法（Label.h）
使用：
unsigned char label = (unsigned char )fspace_2d(imgMask2.row,imgMask2.col,sizeof(unsigned char));
std::vector shapecenterpoint;
int ll = Label::CutAndLable(pTemp,label,imgMask2.row,imgMask2.col,shapecenterpoint);

512X512影象，耗時60ms
256X256影象，耗時20ms。
程式碼分析：
1. 輸入待標記影象bitmap，初始化一個與輸入影象同樣尺寸的標記矩陣labelmap，一個佇列queue以及標記計數labelIndex；
2. 按從左至右、從上至下的順序掃描bitmap，當掃描到一個未被標記的前景畫素p時，labelIndex加1，並在labelmap中標記p（相應點的值賦為labelIndex），同時，掃描p的八鄰域點，若存在未被標記的前景畫素，則在labelmap中進行標記，並放入queue中，作為區域生長的種子；
3. 當queue不為空時，從queue中取出一個生長種子點p1，掃描p1的八鄰域點，若存在未被標記過的前景畫素，則在labelmap中進行標記，並放入queue中；
4. 重複3直至queue為空，一個連通區標記完成；
5. 轉到2，直至整幅影象被掃描完畢，得到標記矩陣labelmap和連通區的個數labelIndex。

// Label.h: interface for the Label class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_LABEL_H__BD38D587_97F3_4B51_9BB6_C0F044167FBA__INCLUDED_)
#define AFX_LABEL_H__BD38D587_97F3_4B51_9BB6_C0F044167FBA__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <vector>



#ifndef _POINT4D_
#define _POINT4D_
 

struct Point4D 
{
    int r;      //目標點區域的質心位置
    int c;
    double dr;  //目標點區域的質心位置的精確值
    double dc;
    int s;      //目標點區域的大小
    double   g; //目標點區域中最大灰度值
    Point4D& operator=(const Point4D &other)
    {
        if (&other==this)
            return *this;   
        r = other.r;
        c = other.c;
        dr = other.dr;
        dc = other.dc;
        s = other.s;
        g = other.g;
        return
 
 *this;

    };
};
#endif

class Label  
{
public:
    Label();
    virtual ~Label();  
    static int CutAndLable(unsigned char **inImg, unsigned char **outImg,int nRow, int nCol, std::vector<Point4D>& points);
    static void labelNeighborPoint(unsigned char **pImg,int nRow,int nCol,int i,int j,Point4D &pPStart);

};





#endif // !defined(AFX_LABEL_H__BD38D587_97F3_4B51_9BB6_C0F044167FBA__INCLUDED_)

// Label.cpp: implementation of the Label class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Label.h"
#include "Comlib.h"
#include <vector>
using namespace std;

Label::Label()
{

}

Label::~Label()
{

}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

/************************ label ************************************/
//種子填充標記
//
// 引數：
//1. inImg       - 輸入影象
//2. outImg      - 輸入影象
//2. nRow, nCol  - 影象高和寬
//3. points      - 標記點容器
//
// 返回值:      - 標記點的個數
/*********************************************************************/
int Label::CutAndLable(unsigned char **inImg, unsigned char **outImg,int nRow, int nCol, std::vector<Point4D>& points)
{
    for (int iii=0;iii<nRow;iii++)
        for (int jjj=0;jjj<nCol;jjj++)
        {
            outImg[iii][jjj] = 0;
        }
    unsigned char **pImg = (unsigned char**)fspace_2d(nRow,nCol,sizeof(unsigned char));
    for (int ii=0;ii<nRow;ii++)
        for (int jj=0;jj<nRow;jj++)
        {
            pImg[ii][jj] = inImg[ii][jj];
        }
    points.clear();
    Point4D temp;

    int nBlock =1;
    for (int i=0;i<nRow;i++)
        for (int j=0;j<nCol;j++)
        {
             if (pImg[i][j] != 0)
             {
                 labelNeighborPoint(pImg,nRow,nCol,i,j,temp);
                 points.push_back(temp);
                 //outImg[temp.r][temp.c] = (unsigned char)temp.g;
                 if (nBlock <=255)
                 {
                     outImg[temp.r][temp.c] = nBlock;
                 }
                 else
                     outImg[temp.r][temp.c] = 0;

                 nBlock++;
             }
        }


    return points.size();
}



void Label::labelNeighborPoint(unsigned char **pImg,int nRow,int nCol,int i,int j,Point4D &pPStart)
{   
    static int ttt = 1;
    int tMark = i * nCol +j;
    int endMark = nRow * nCol;
    int tTemp;
    int maxR=-1, maxC=-1;
    double sumR = 0, sumC = 0, sumG = 0, maxG = 0;
    int nCount = 0;
    int top=nRow,down=0,left=nCol,right=0;
    vector<int> pBuffD;
    pBuffD.push_back(tMark);
    while( pBuffD.size()!=0 )
    {
        tMark = pBuffD.back();
        pBuffD.pop_back();

        ++nCount;
        sumR += tMark/nCol * pImg[tMark/nCol][tMark%nCol];//灰度加權
        sumC += tMark%nCol * pImg[tMark/nCol][tMark%nCol];
        sumG += pImg[tMark/nCol][tMark%nCol];
        if (maxG < pImg[tMark/nCol][tMark%nCol])
        {
            maxR = tMark/nCol;
            maxC = tMark%nCol;
            maxG = pImg[tMark/nCol][tMark%nCol];
        }
        pImg[tMark/nCol][tMark%nCol] = 0;
        if (tMark/nCol > down)  down = tMark/nCol;
        if (tMark%nCol > right) right = tMark%nCol;
        if (tMark/nCol < top)   top = tMark/nCol;
        if (tMark%nCol < left)  left = tMark%nCol;

        tTemp = tMark-nCol-1;       // (i-1,j-1)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0 )
            pBuffD.push_back(tTemp);
        tTemp = tMark-nCol  ;       // (i-1,j)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0  )
            pBuffD.push_back(tTemp);
        tTemp = tMark-nCol+1;       // (i-1,j+1)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0  )
            pBuffD.push_back(tTemp);

        tTemp = tMark       -1;     // (i,j-1)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0 )
            pBuffD.push_back(tTemp);
        tTemp = tMark       +1;     // (i,j+1)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0  )
            pBuffD.push_back(tTemp);

        tTemp = tMark+nCol-1;       // (i+1,j-1)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0  )
            pBuffD.push_back(tTemp);
        tTemp = tMark+nCol  ;       // (i+1,j)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0  )
            pBuffD.push_back(tTemp);
        tTemp = tMark+nCol+1;       // (i+1,j+1)
        if( tTemp>=0 && tTemp<endMark && pImg[tTemp/nCol][tTemp%nCol] != 0  )
            pBuffD.push_back(tTemp);
    }

    if( nCount!=0 )
    {
        int w = right - left;
        int h = down - top;
        pPStart.s = w>h ? w+1 : h+1;
        pPStart.c = sumC/sumG+0.5;
        pPStart.r = sumR/sumG+0.5;
        pPStart.dc = nCount;
        pPStart.dr = nCount;
        //      pPStart.c = maxC;
        //      pPStart.r = maxR;
        pPStart.g = ttt;
        ttt ++;
    }
}

二、 Two_Pass演算法
使用：
// 二值影象標記演算法並獲得聯通區域資訊
int LabelBiImgAndMsg(unsigned char *inBiImg,unsigned char *outLabelImg, int *numCandTarget,
int row, int col, std::vector& points)

其中：

ifndef POINT4D

define POINT4D

struct Point4D
{
int r; //目標點區域的質心位置
int c;
double dr; //目標點區域的質心位置的精確值
double dc;
int s; //目標點區域的大小
double g; //目標點區域中最大灰度值
Point4D& operator=(const Point4D &other)
{
if (&other==this)
return *this;
r = other.r;
c = other.c;
dr = other.dr;
dc = other.dc;
s = other.s;
g = other.g;
return *this;

};

};

endif

原始影象 標記影象
512X512影象，耗時10ms
256X256影象，耗時4ms。
程式碼分析：
1. 生成鄰接表：當前行與相鄰的上一行進行鄰接標記；
2. 由鄰接表生成影象對映表，合併鄰接表生成連通區域；
3. 有對映表生成標記影象，並獲取標記資訊。

#include "StdAfx.h"
#include "subfuction.h"
#include "dibapi.h" 
#include "QFileIO.h"
#include "method.h"

//////////////////////////////////////////////////////////////////////////
//lable 2
//標記引數


// 生成鄰接表
int GenerateNeighborTable(unsigned char *inBiImg, unsigned char outNbTab[2 * MAXLINK]
                               , int *outNbLen, unsigned char *outLabelImg
                               , int outRegionArea[MAXSUBBLOCK + 1], int *outLabelNum, int row, int col)
{
    // 對二值影象亮畫素區域進行初掃描，初步標記，獲取初步標記區域之間的鄰接表
    // 返回值，非0 表成功，0 表失敗

    // 輸入：二值影象及其行列數

    // 輸出：鄰接表outNbTab，它的每一列，第一行和第二行存放連通的兩個區域的初步標記號
    // outNbLen，鄰接表的有效長度

    // outLabelImg，初步標記影象

    // 區域面積陣列outRegionArea，第i個元素表示初步標記號為i的區域的面積，第0個元素無效
    // outLabelNum，初步標記的區域數，也是outRegionArea的有效長度

    int startPos, endPos, grayNum;
    int i, j, k;
    static int  grayLastLine[MAXSINGLELINK]; // 上一行與當前區域相鄰的區域
    for (i = 0; i < MAXSINGLELINK; i++)
    {
        grayLastLine[i] = 0;
    }

    // 初步標記影象初始化  ***可以省略***
    /*
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            outLabelImg[i*col + j] = 0;
        }
    }
    */

    // 鄰接表初始化
    for (i = 0; i < 2 * MAXLINK; i++)
    {
        outNbTab[i] = 0;
    }

    // 區域面積初始化
    for (i = 0; i < MAXSUBBLOCK; i++)
    {
        outRegionArea[i] = 0;
    }

    *outLabelNum  = 0; // 初步標記號
    *outNbLen = 0; // 鄰接表有效長度

    i=0, j=0;
    for (i=0; i<row; i++)
    {
        for (j=0; j<col; j++)
        {
            if (inBiImg[i*col+j]!=0)
            {
                // 當前區域，為處於當前行的一線段
                startPos = j;
                do
                {
                    j++;
                    if (j==col)  break;
                } while (inBiImg[i*col+j]!=0); //查詢該行第一個不為0的畫素位置
                endPos = j-1;

                grayNum = 0;
                for (k=startPos-1; k<=endPos+1; k++)
                {
                    if (i-1<0)  break; // 影象首行無需察看其上一行
                    if ((k<0)||(k>=col))  continue;
                    if (outLabelImg[(i-1)*col+k] != 0) // 檢視上一行與當前區域的相鄰區域
                    {
                        if (grayNum>=MAXSINGLELINK)
                        {
                            *outNbLen = 0;
                            *outLabelNum = 0;
                            return 0;
                        }
                        grayLastLine[grayNum] = outLabelImg[(i-1)*col+k];
                        grayNum++;
                        while (outLabelImg[(i-1)*col+k]!=0) k++;
                    }
                }

                if (grayNum == 0) // 當前區域的上一行不存在其它區域與之相鄰
                {
                    (*outLabelNum)++; // 初步標記號遞增
                    if (*outLabelNum > MAXSUBBLOCK)
                    {
                        *outNbLen = 0;
                        *outLabelNum = 0;
                        return 0;
                    }
                    if (*outNbLen>=MAXLINK)
                    {
                        *outNbLen = 0;
                        *outLabelNum = 0;
                        return 0;
                    }

                    // 鄰接表中增加新區域對應的項
                    outNbTab[*outNbLen] = *outLabelNum;
                    outNbTab[*outNbLen+MAXLINK] = *outLabelNum;
                    (*outNbLen)++;
                    // 區域面積陣列中，增加新區域對應的項
                    outRegionArea[*outLabelNum] = endPos - startPos + 1;
                    for (k=startPos; k<=endPos; k++)
                        outLabelImg[i*col+k] = *outLabelNum;
                }
                else
                {
                    // 當前區域的標記號，與上一行與之相鄰的第一個標記號相同
                    for (k=startPos; k<=endPos; k++)
                        outLabelImg[i*col+k] = grayLastLine[0];
                    outRegionArea[grayLastLine[0]] += endPos - startPos + 1;
                    // 當前區域和上一行與之相鄰的標記號建立鄰接關係
                    for (k=1; k<grayNum; k++)
                    {
                        if (*outNbLen>=MAXLINK)
                        {
                            *outNbLen = 0;
                            *outLabelNum = 0;
                            return 0;
                        }
                        outNbTab[*outNbLen] = grayLastLine[0];
                        outNbTab[*outNbLen+MAXLINK] = grayLastLine[k];
                        (*outNbLen)++;
                    }
                }
            }
        }
    }

    return 1;

}

// 生成對映表
void GenerateMap(unsigned char inNbTab[2 * MAXLINK], int nbTabLen
                     , unsigned char outMap[MAXSUBBLOCK+1], int *outNumTrueObj)
{
    // 根據鄰接表生成初步標記號與其真實標記號的對映關係
    // 輸入：鄰接表inNbTab 及其有效長度nbTabLen

    // 輸出：對映表outMap，第i個元素表示初步標記號為i的區域的真實標記號
    // outNumTrueObj，真實目標數，也是真實標記號的最大值

    static  unsigned char  stack[MAXSINGLELINK];
    int   i, j, StackPtr, TmpValue;
    unsigned char *pneighbor0,*pneighbor1,*pneighbor2,*pneighbor3;

    for (i = 0; i < MAXSINGLELINK; i++)
    {
        stack[i] = 0;
    }

    *outNumTrueObj  = 0;
    StackPtr = 0;

    pneighbor0 = &(inNbTab[0]);
    pneighbor1 = &(inNbTab[MAXLINK]);

    for (i=0; i<nbTabLen; i++,pneighbor0++,pneighbor1++)
    {
        if (*pneighbor0!=0) // 鄰接表中新的一項
        {
            stack[StackPtr] = *pneighbor0;
            StackPtr++;
            (*outNumTrueObj)++;
            *pneighbor0 = 0;
            *pneighbor1 = 0;
        }

        while (StackPtr != 0)
        {
            // 當前存在於棧中的所有區域，其真實標記號相同
            StackPtr--;
            TmpValue = stack[StackPtr];
            // 初步標記號為TmpValue的區域的真實標記號
            outMap[TmpValue] = (*outNumTrueObj);

            pneighbor2 = pneighbor0;
            pneighbor3 = pneighbor1;

            for (j=i; j<nbTabLen; j++, pneighbor2++, pneighbor3++)
            {
                if ((*pneighbor2 == TmpValue) || (*pneighbor3 == TmpValue))
                {
                    if (*pneighbor2!=*pneighbor3)
                    {
                        // 與TmpValue相鄰的其它區域其真實標記號與TmpValue相同，故進棧
                        stack[StackPtr] = (*pneighbor2!=TmpValue)? *pneighbor2
                            : *pneighbor3;
                        StackPtr++;
                    }
                    *pneighbor2 = 0;
                    *pneighbor3 = 0;
                }
            }
        }
    }

}



void Map2LabelImg(unsigned char *inoutLabelImg,unsigned char inMap[MAXSUBBLOCK], int row ,int col)
{
    // 由對映表生成標記影象
    int i = 0;
    int j = 0;

    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (inoutLabelImg[i* col + j] > 0)
            {
                inoutLabelImg[i* col + j] = 255-inMap[inoutLabelImg[i * col + j]];
            }
        }
    }

}


// 二值影象標記演算法
int LabelBiImg(unsigned char *inBiImg,unsigned char *outLabelImg, int *numCandTarget, int row, int col)
{
    // 對二值影象進行標記
    // 輸出標記後圖像和連通區域數
    static unsigned char map[MAXSUBBLOCK+1], neighbor[2*MAXLINK];
    static int tmpArea[MAXSUBBLOCK+1];

    int tabLen, labelNum; // 鄰接表長度與初步標記區域數
    int i;

    for (i = 0; i < MAXSUBBLOCK + 1; i++) // 對映表與面積陣列初始化
    {
        map[i] = 0;
        tmpArea[i] = 0;
    }
    for (i = 0; i < 2 * MAXLINK; i++) // 鄰接表初始化
    {
        neighbor[i] = 0;
    }

    for (i = 0; i < row * col; i++) // 標記影象初始化
    {
        outLabelImg[i] = 0;
    }

    // 生成鄰接表
    i = GenerateNeighborTable(inBiImg,neighbor, &tabLen
        , outLabelImg, tmpArea, &labelNum, row, col);
    if (i != 0)
    {
        // 由鄰接表生成對映表
        GenerateMap(neighbor, tabLen, map, numCandTarget);
        // 由對映表生成標記後圖像
        Map2LabelImg(outLabelImg, map, row, col);
        if (i == 255)
        {
            return 255;
        }

        return 1;
    }
    else
    {
        for (i = 0; i < row * col; i++)
        {
            outLabelImg[i] = 0;
        }
        *numCandTarget = 0;
            return 0;
    }

}

void GetImgConnectMsg(unsigned char * LabelImg, int row, int col, int numCandTarget,  std::vector<Point4D>& points)
{
    if (!points.empty())
    {
        points.clear();
    }
    int i,j,nowNum;
    Point4D temp;
    temp.r = 0;
    temp.c = 0;
    temp.s = 0;
    for (i=0;i<numCandTarget;i++)
    {
        points.push_back(temp);
    }
    for (i=0;i<row;i++)
    {
        for (j=0;j<col;j++)
        {
            nowNum = LabelImg[i*col + j]-1;
            if (nowNum>=0)
            {
                points[nowNum].r = points[nowNum].r + i;
                points[nowNum].c = points[nowNum].c + j;
                points[nowNum].s = points[nowNum].s + 1;
            }

        }
    }
    for (i=0;i<numCandTarget;i++)
    {
        points[i].r = points[i].r / points[i].s;
        points[i].c = points[i].c / points[i].s;
    }

}

// 二值影象標記演算法並獲得聯通區域資訊
int LabelBiImgAndMsg(unsigned char *inBiImg,unsigned char *outLabelImg, int *numCandTarget, 
                     int row, int col, std::vector<Point4D>& points)
{
    // 對二值影象進行標記
    // 輸出標記後圖像和連通區域數
    static unsigned char map[MAXSUBBLOCK+1], neighbor[2*MAXLINK];
    static int tmpArea[MAXSUBBLOCK+1];

    int tabLen, labelNum; // 鄰接表長度與初步標記區域數
    int i;

    for (i = 0; i < MAXSUBBLOCK + 1; i++) // 對映表與面積陣列初始化
    {
        map[i] = 0;
        tmpArea[i] = 0;
    }
    for (i = 0; i < 2 * MAXLINK; i++) // 鄰接表初始化
    {
        neighbor[i] = 0;
    }

    for (i = 0; i < row * col; i++) // 標記影象初始化
    {
        outLabelImg[i] = 0;
    }

    // 生成鄰接表
    i = GenerateNeighborTable(inBiImg,neighbor, &tabLen
        , outLabelImg, tmpArea, &labelNum, row, col);
    if (i != 0)
    {
        // 由鄰接表生成對映表
        GenerateMap(neighbor, tabLen, map, numCandTarget);
        //由標記的影象獲取標記資訊
        GetImgConnectMsg(outLabelImg, row, col, *numCandTarget,  points);
        // 由對映表生成標記後圖像
        Map2LabelImg(outLabelImg, map, row, col);
        if (i == 255)
        {
            return 255;
        }

        return 1;
    }
    else
    {
        for (i = 0; i < row * col; i++)
        {
            outLabelImg[i] = 0;
        }
        *numCandTarget = 0;
        return 0;
    }

}

//////////////////////////////////////////////////////////////////////////

三、 DSP上處理：
採用Two_Pass演算法
耗時：1.8ms

相關推薦

兩種連通區域標記演算法

一、 One-Pass對應的標記演算法（Label.h） 使用： unsigned char label = (unsigned char )fspace_2d(imgMask2.row,imgMask2.col,sizeof(unsigned char

最小生成樹的兩種方法（Kruskal演算法和Prim演算法）

關於圖的幾個概念定義： 連通圖：在無向圖中，若任意兩個頂點vivi與vjvj都有路徑相通，則稱該無向圖為連通圖。 強連通圖：在有向圖中，若任意兩個頂點vivi與vjvj都有路徑相通，則稱該有向圖為強連通圖。 連通網：在連通圖中，若圖的邊具有一定的意義，每一條邊都對應著一個數，稱

實現基於C語言的二值影象連通域標記演算法

實現基於C語言的二值影象連通域標記演算法 1 #include <stdio.h> 2 #include <stdarg.h> 3 #include <stddef.h> 4 #include <stdlib.h> 5 #includ

影象連通區域標記

由於最近做實驗用到二值影象連通區域（八連通）標記，剛開始的時候為了驗證演算法有效性，用了遞迴的方法（太慢了，而且影象一大就容易棧溢位），最後查看了opencv和MATLAB的實現，做個記錄。（為了簡單說明，以下說明已四連通為例） 掃描法連通區域標記： 例：對於二值影象、四

記錄兩種搜尋遍歷演算法——BFS和DFS

        “ 你所有流過的淚，是一條渡你的河， 你所有受過的苦，將照亮你前方的路；歲月從沒有放過我們，我們也不能辜負歲月。”   最近過的不好~ 被虐 自信全無 各種害怕、自卑~ 唯有努力前行，安慰自

兩種改進的LPB演算法，CLBP和ELBP

最近看了兩篇關於CLBP和ELBP的文章。現在對文中提到的LBP相關知識做一個小小的總結一、LBP簡介1.傳統LBP其中是中心畫素的灰度值，是其鄰域畫素的灰度值。通過比較中心畫素周圍鄰域畫素與中心畫素的大小，大於中心畫素為1，小於中心 畫素為0，最後按一定順序進行二進位制編碼

js實現兩種實用的排序演算法——冒泡、快速排序

零：資料準備，給定陣列arr=[2,5,4,1,7,3,8,6,9,0]; 一：冒牌排序 1思想：氣泡排序思想：每一次對比相鄰兩個資料的大小，小的排在前面，如果前面的資料比後面的大就交換這兩個數的位置       要實現上述規則需要用到兩層for迴圈，外層從第一個數到倒數第

連通域標記演算法（二） 基於深度優先搜尋的連通域標記演算法（opencv C++實現）

        上一篇我們講到了MATLAB中的bwlabel連通域標記演算法的C++實現https://blog.csdn.net/Dhane/article/details/81633723，今天我來講一講另一種相對比較容易想到的連通域標記演算法。簡單點說

最長遞增子序列(兩種時間複雜度演算法及其區別)+最長遞減子序列(reverse)

O(n*n)//LIS+路徑回溯 O(n*n) #include <iostream> #include<cstdio> #include<stack> #i

兩種edge-preserving濾波演算法 導向濾波 和 雙邊濾波 個人理解

1.導向濾波 1.1. 直觀解釋 導向濾波演算法的核心就是,區分出哪裡是平坦區,哪裡是邊緣部分。 如何區分:計算視窗內的方差，方差大的可以認為是邊緣。 1.2. 數學推導 對於qi,它的ai和bi等於所有包括他的視窗的ai和bi的均值。

兩種公鑰加密演算法——Merkle-Hellman揹包、RSA

今天看了一些加密體制，很厲害，佩服之餘順便總結下公鑰（對稱金鑰很多啊，歷史比較有名的有DES、AES、RC系列...水平不夠說不清楚，所以不寫了）。自己以後也要看，所以儘量通俗易懂（其實是不怎

最小生成樹的兩種最基本的演算法

prim /** @Cain*/ #include <bits/stdc++.h> using namespace std; const int maxn=2005; const int inf=1e9+5; int edge[maxn][ma

C程式碼二值影象連通區域標記

之前寫過一個C++版本的二值影象連通區域標記函式，當時的直觀結果沒有問題，我也使用了很久，後來才發現其結果是錯的，I'm so sorry! 這裡貼出的是一個經過改進的二值影象連通區域標記函式，目前只支援4連通區域標記，要想做到8連通標記的話，最簡單的方法是先用[1 1 1

[演算法]用兩種求質數的演算法(窮舉法，篩選法)，C語言實現

今天考試的題目是記不得了，等題目公開了再給大家分析，今天講點經典的演算法，求質數，相信很多人還是記得當年的窮舉法了吧，就是不斷的讓每一個數除以一個小於他的數最大到sqrt(N)，然後得出結果,演算法時間複雜度O(N^2)，優化過的演算法O(N * sqrt(N))，經典的演算法我就不講了，初學者如果不懂的話，

Java中兩種基本的查詢演算法之順序查詢

Java中兩種基本的查詢演算法：順序查詢和二分查詢(折半查詢)。 第一種查詢演算法：順序查詢： /** * 1. 順序查詢 * 基本思想： * 從陣列的一端向另一端逐個將元素與給定

圖的兩種最小生成樹演算法之C++封裝

最小生成樹定義：     給定一無向帶權圖，頂點數是n，要使圖連通只需n-1條邊，若這n-1條邊的權值和最小，則稱有這n個頂點和n-1條邊構成了圖的最小生成樹(minimum-cost spanning tree)MST。 兩種最小生成樹演算法： 一、prim演算法

兩種影象骨架提取演算法的研究(2)實現程式碼

1 K3M #include <opencv2/imgproc/imgproc.hpp> #include <opencv2/objdetect/objdetect.hpp> #include <opencv2/highgui/hig

二值影象連通域標記演算法優化

文章概要   　　非常感謝☆Ronny丶博主在其博文《影象分析：二值影象連通域標記》中對二值影象連通域的介紹和演算法闡述，讓我這個毫無資料結構演算法底子的小白能夠理解和復現程式碼。本文的目的是基於我自己的理解，對該博文中Two-Pass演算法的一些優化和補充，同時也希望幫助更多像我一樣的人較快地掌握

連通區域快速標記的two-pass演算法及其實現

1）         當該畫素的左鄰畫素和上鄰畫素為無效值時，給該畫素置一個新的label值，label ++; 2）         當該畫素的左鄰畫素或者上鄰畫素有一個為有效值時，將有效值畫素的label賦給該畫素的label值； 3）         當該畫素的左鄰畫素和上鄰畫素都為有效值時，選取其中

GC演算法精解（複製演算法與標記/整理演算法） 目前的兩種主流演算法，基於標記清除演算法而來

refer to  http://www.cnblogs.com/zuoxiaolong/p/jvm5.html 在說以下兩種演算法前，說說他們的進化源——標記清除  有什麼問題。  第二點尤甚 1、首先，它的缺點就是效率比較低（遞迴與全堆物件遍歷），而且在進行GC的時候