OpenCv如何检测黑点？

Mat src = imread(...图片路径)

Mat src_gray// 保存灰度图

Mat src_binary// 保存二值图

int Threshold1 = 100// 阀值

int Threshold2 = 255

cvtColor(src, src_gray, CV_BGR2GRAY)

threshold(src_gray, src_binary, Threshold1, Threshold2, CV_THRESH_BINARY)

// 反色(黑模盯慧色背景)

//旦答 bitwise_not(src_binary, src_binary)

// 查找图像的所有轮廓

vector<vector<Point>>contours_temp

findContours(src_binary, contours_temp, RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0))

// 筛选的面积限则历定值

double min_area = 100

// 筛选轮廓

for (int i = 0i <contours_temp.size()i++)

{

// 第i个轮廓的面积，

// false：表示某一个方向上轮廓的的面积值，顺时针或者逆时针，一般选择默认false

double contour_area = contourArea(contours_temp[i], false)

// 如果该轮廓的面积小于限定值，那么就判定为黑点

if (contour_area <min_area)

{

...

}

}

可以参考下面的做氏坦程序，其中bitCount!=8 &&bitCount!=24指的就是8位与24位

//BMP与IplImage相互转换

///////////////////////////////头文件bmp2ipl.h

//bmp2ipl.h

#ifndef BMP2IPL_H

#define BMP2IPL_H

class BMP {

public:

BMP():bmpData(NULL) {

memset(&biHeader, 0, sizeof(biHeader))

}

BMP(const BMP &img)

BMP(const IplImage &img)

BMP(int width, int height, int bitCount)

~BMP(){ delete [] bmpData}

bool CreateImage(const BITMAPINFOHEADER &biHeader)

//Export

IplImage * BMP2Ipl()

//void Show(HWND hWnd, int nID)

//void Show(CDC *pDC, CRect &rect)

//void Show(HWND hWnd)

void ReSize(int newW, int newH)

private:

void CopyData(char *dest, const char *src, int dataByteSize,

bool isConvert, int height)

// isConvert=true 进行顶左和底左之间的转纯桐换(顶左到底左或底左到顶左)，否则不转换

// biSizeImage may be set to zero for BI_RGB bitmaps, so calculate it.

int ImgSize() {

return ( biHeader.biHeight * ((biHeader.biWidth * biHeader.biBitCount / 8 + 3) &(-4)))

}

public:

void Clear()

BITMAPINFOHEADER biHeader

unsigned char * bmpData

}

#endif

////////////////////////////////核卜/////////////////////////////////////实现文件bmp2ipl.cpp

#include "bmp2ipl.h"

/**************************************************************************************************

* *

* NOTE: *

*Only use the "8 bit, 1 or 3 channels" image, the BitMap use LowerLeft （底左）, *

*the IplImage use TopLeft （顶左）*

* IplImage: *

*nChannels = 1 or 3 number of channels *

*depth = IPL_DEPTH_8U pixel depth (8 bit), IPL_DEPTH_8U=8 *

*dataOrder = 0交叉存取颜色通道*

*origin = IPL_ORIGIN_TL 图像数据保存形式，IPL_ORIGIN_BL底左结构, IPL_ORIGIN_TL顶左结构 *

*align = 4行数据对齐方式，保证下一行数据从整4字节位置开始 *

*width*

*height *

*widthStep图像数据行大小，单位字节*

*imageSize图像数据大小(=height*widthStep)，单位字节 *

*imageData指向图像数据区，char * *

* BITMAPINFOHEADER: *

*biSize Specifies the number of bytes required by the structure *

*biWidth *

*biHeight(>0) biHeight>0底左结构；biHeight<0顶左结构 *

*biPlanes = 1 Specifies the number of planes for the target device. This value*

* must be set to 1. *

*biBitCount =8 or 24 bits-per-pixel,8-(pixelDepth=8,channels=1), *

* 24-(pixelDepth=8,channels=3)*

*biCompression = BI_RGB An uncompressed format *

*biSizeImage Specifies the size, in bytes, of the image.This may be set to zero *

* for BI_RGB bitmaps. *

*biXPelsPerMeter = 0 *

*biYPelsPerMeter = 0 *

*biClrUsed = 0*

*biClrImportant = 0 *

* *

***************************************************************************************************/

BMP::BMP(const BMP &img)

{

if(!IsSupport(img)) {

BMP()

return

}

//biHeader = img.biHeader

PBITMAPINFOHEADER pBmpH = (PBITMAPINFOHEADER)&img.biHeader

memcpy(&biHeader, pBmpH, sizeof(BITMAPINFOHEADER))

biHeader.biSizeImage = ImgSize()

bool isLowerLeft = biHeader.biHeight>0

//int rowSize=0

if(!isLowerLeft) biHeader.biHeight=-biHeader.biHeight

if(bmpData!=NULL) delete[] bmpData

bmpData = new unsigned char [biHeader.biSizeImage]

//memcpy(bmpData, img.bmpData, img.biHeader.biSizeImage)

CopyData((char *)bmpData, (char*)img.bmpData, biHeader.biSizeImage,

!isLowerLeft, biHeader.biHeight)

}

BMP::BMP(const IplImage &img) {

if(!IsSupport(img)) {

BMP()

return

}

bool isTopLeft = (img.origin == IPL_ORIGIN_TL)

biHeader.biSize = sizeof(BITMAPINFOHEADER)

biHeader.biWidth = img.width

biHeader.biHeight = img.height

biHeader.biPlanes = 1

biHeader.biBitCount = img.depth * img.nChannels

biHeader.biCompression = BI_RGB

biHeader.biSizeImage = img.imageSize

biHeader.biXPelsPerMeter = 0

biHeader.biYPelsPerMeter = 0

biHeader.biClrUsed = 0

biHeader.biClrImportant = 0

if(bmpData!=NULL) delete[] bmpData

bmpData = new unsigned char [img.imageSize]

//memcpy(bmpData, img.ImageData, img.imageSize)

CopyData((char*)bmpData, (char*)img.imageData, img.imageSize,

isTopLeft, img.height)

/*int i,j

CvScalar s

for(i=0i<img.widthi++)

for(j=0j<img.heightj++){

s=cvGet2D(&img,i,j)

}

*/

}

BMP::BMP(int width, int height, int bitCount) {

if(bitCount!=8 &&bitCount!=24) return

biHeader.biSize = sizeof(BITMAPINFOHEADER)

biHeader.biWidth = width

biHeader.biHeight = height

biHeader.biPlanes = 1

biHeader.biBitCount = bitCount

biHeader.biCompression = BI_RGB

biHeader.biSizeImage = ImgSize()

biHeader.biXPelsPerMeter = 0

biHeader.biYPelsPerMeter = 0

biHeader.biClrUsed = 0

biHeader.biClrImportant = 0

if(bmpData!=NULL) delete[] bmpData

bmpData = new unsigned char [biHeader.biSizeImage]

Clear()

}

// dest: the destination image

// dataByteSize: the Source image

// height: source image height

void BMP::CopyData(char *dest, const char *src, int dataByteSize,

bool isConvert, int height) {

char * p = dest

if(!isConvert) {

memcpy(dest, src, dataByteSize)

return

}

if(height<=0) return

//int height = dataByteSize/rowByteSize

int rowByteSize = dataByteSize / height

src = src + dataByteSize - rowByteSize

for(int i=0i<heighti++) {

memcpy(dest, src, rowByteSize)

dest += rowByteSize

src -= rowByteSize

}

}

IplImage * BMP::BMP2Ipl() {

if(!IsSupport(*this)) return NULL

IplImage *iplImg

int height

bool isLowerLeft = biHeader.biHeight>0

height = (biHeader.biHeight>0) ? biHeader.biHeight : -biHeader.biHeight

iplImg = cvCreateImage( cvSize(biHeader.biWidth, height), IPL_DEPTH_8U, biHeader.biBitCount / 8)

//iplImg = cvCreateImageHeader( cvSize(biHeader.biWidth, height), IPL_DEPTH_8U, biHeader.biBitCount / 8)

//cvSetData(iplImg,(char*)bmpData,biHeader.biSizeImage/height)

CopyData( iplImg->imageData, (char*)bmpData, biHeader.biSizeImage,

isLowerLeft, height)

/*int i,j

CvScalar s

int channels=biHeader.biBitCount / 8

int step=(biHeader.biWidth*channels+3) &-4

int loc=0

for(i=0i<iplImg->heighti++){

for(j=0j<iplImg->widthj++){

loc=i*step + j*channels

s.val[0]=bmpData[loc]

if(channels==3){

s.val[1]=bmpData[loc+1]

s.val[2]=bmpData[loc+2]

}

cvSet2D(iplImg,i,j,s)

}

}*/

return iplImg

}

void BMP::Clear() {

if(bmpData == NULL) return

memset(bmpData, 0, ImgSize())

}

void BMP::ReSize(int newW, int newH) {

biHeader.biWidth = newW

biHeader.biHeight = newH

biHeader.biSizeImage = ImgSize()

if(bmpData!=NULL) delete[] bmpData

bmpData = new unsigned char [biHeader.biSizeImage]

Clear()

}

bool BMP::CreateImage(const BITMAPINFOHEADER &bih) {

memset(&biHeader,0,sizeof(BITMAPINFOHEADER))

delete[] bmpData

bmpData = NULL

memcpy(&biHeader, &bih, sizeof(BITMAPINFOHEADER))

biHeader.biSizeImage = ImgSize()

bmpData = new unsigned char [ biHeader.biSizeImage ]

if(bmpData == NULL) return false

else{

Clear()

return true

}

}

---