AFAIK, vous devez le convertir en échelle de gris et ensuite le seuil en binaire.

1. Lire l'image comme une image en échelle de gris Si vous lisez l'image RGB à partir du disque, alors vous pouvez directement la lire comme une image en niveaux de gris, comme ceci:

// C
IplImage* im_gray = cvLoadImage("image.jpg",CV_LOAD_IMAGE_GRAYSCALE);

// C++ (OpenCV 2.0)
Mat im_gray = imread("image.jpg",CV_LOAD_IMAGE_GRAYSCALE);

2. Convertissez une image RGB im_rgb en une image en échelle de gris : autrement, vous devrez convertir l'image RGB obtenue précédemment en une image en niveaux de gris

// C
IplImage *im_rgb  = cvLoadImage("image.jpg");
IplImage *im_gray = cvCreateImage(cvGetSize(im_rgb),IPL_DEPTH_8U,1);
cvCvtColor(im_rgb,im_gray,CV_RGB2GRAY);

// C++
Mat im_rgb  = imread("image.jpg");
Mat im_gray;
cvtColor(im_rgb,im_gray,CV_RGB2GRAY);

3. Convertir en binaire Vous pouvez utiliser adaptatif ou fixe le niveau de seuillage pour convertir votre image en niveaux de gris d'une image binaire.

E. G. en C vous pouvez faire ce qui suit (vous pouvez aussi faire la même chose en C++ avec Mat et les fonctions correspondantes):

// C
IplImage* im_bw = cvCreateImage(cvGetSize(im_gray),IPL_DEPTH_8U,1);
cvThreshold(im_gray, im_bw, 128, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);

// C++
Mat img_bw = im_gray > 128;

Dans l'exemple ci-dessus, 128 est le seuil.

4. Enregistrer sur le disque

// C
cvSaveImage("image_bw.jpg",img_bw);

// C++
imwrite("image_bw.jpg", img_bw);

utiliser cv2 et Python:

1 - Niveaux De Gris De L'Image

import cv2
im_gray = cv2.imread('grayscale_image.png', cv2.CV_LOAD_IMAGE_GRAYSCALE)

2 - convertir l'image en binaire

(thresh, im_bw) = cv2.threshold(im_gray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

3 - Magasin de Disck

cv2.imwrite('bw_image.png', im_bw)

Cela semble avoir fonctionné pour moi!

Mat a_image = imread(argv[1]);

cvtColor(a_image, a_image, CV_BGR2GRAY);
GaussianBlur(a_image, a_image, Size(7,7), 1.5, 1.5);
threshold(a_image, a_image, 100, 255, CV_THRESH_BINARY);

je fais quelque chose de similaire dans un de mes blog . Un exemple simple de c++ est affiché.

l'objectif était d'utiliser la bibliothèque open source cvBlobsLib pour la détection des échantillons ponctuels imprimé puces diapositives, mais les images doivent être converti à partir de la couleur - > grayscale - > noir + blanc comme vous l'avez mentionné, afin d'atteindre cet objectif.

Un moyen simple de "binariser une image est à comparer à un seuil: Par exemple, vous pouvez comparer tous les éléments d'une matrice avec une valeur opencv en c++

cv::Mat img = cv::imread("image.jpg", CV_LOAD_IMAGE_GRAYSCALE); 
cv::Mat bw = img > 128;

De cette façon, tous les pixels de la matrice supérieure à 128 maintenant sont blancs, et ces moins de 128 ou égal noir

optionnellement, et pour moi a donné de bons résultats est d'appliquer flou

cv::blur( bw, bw, cv::Size(3,3) );

plus tard, vous pouvez le sauver comme dit avant avec:

cv::imwrite("image_bw.jpg", bw);

est suffisante.

inclure

#include <string>
#include "opencv/highgui.h"
#include "opencv2/imgproc/imgproc.hpp"

using namespace std;
using namespace cv;

int main()
{
    Mat img = imread("./img.jpg",0);//loading gray scale image
    threshold(img, img, 128, 255, CV_THRESH_BINARY);//threshold binary, you can change threshold 128 to your convenient threshold
    imwrite("./black-white.jpg",img);
    return 0;
}

vous pouvez utiliser GaussianBlur pour obtenir une image en noir et blanc lisse.