Базовые операции обработки изображений

2.2. Сглаживание изображений

Сглаживание или размытие изображения – это одна из самых простых и часто используемых операций обработки изображений. Как правило, размытие применяется, чтобы уменьшить шум или артефакты, которые обусловлены выбором камеры. Также сглаживание играет важную роль при необходимости уменьшить разрешение изображения и получить пирамиду изображений разного масштаба (image pyramids) [1]. Разработчики OpenCV реализовали несколько функций размытия изображения. Далее остановимся на некоторых из них, а именно рассмотрим функции blur, boxFilter, GaussianBlur и medianBlur [7]:

void blur(const Mat src, Mat dst, Size ksize,  
       Point anchor=Point(-1, -1),  
       int borderType=BORDER_DEFAULT) 
 
void boxFilter(const Mat src, Mat dst, int ddepth,  
        Size ksize, Point anchor=Point(-1, -1),  
        bool normalize=true,  
        int borderType=BORDER_DEFAULT) 
 
void GaussianBlur(const Mat src, Mat dst, Size ksize,  
       double sigmaX, double sigmaY=0,  
       int borderType=BORDER_DEFAULT) 
 
void medianBlur(const Mat src, Mat dst, int ksize) 

Приведем назначение общих параметров указанных функций:

Функция boxFilter использует ядро более общего вида:

Параметр normalize по существу представляет флаг, который указывает, является ли ядро нормализованным или нет. Вызов функции blur эквивалентен вызову boxFilter(src, dst, src.type(), anchor, true, borderType).

Функция GaussianBlur осуществляет размытия с помощью вычисления свертки изображения с дискретным ядром Гаусса со стандартными отклонениями, равными sigmaX и sigmaY по осям Ox и Oy соответственно. Заметим, что при вызове данной функции накладывается ограничение на параметр kSize. Ширина и высота ядра должны быть положительными и нечетными, либо нулевыми, если размер ядра определяется из стандартных отклонений.

Функция medianBlur обеспечивает размытие посредством применения медианного фильтра. Медианный фильтр строится подобно линейному фильтру. Выбирается некоторый шаблон, который накладывается на все пиксели изображения. Набор интенсивностей пикселей, которые накрыты шаблоном, сортируются, и выбирается интенсивность, находящаяся в середине отсортированного множества. По сути, определяется медиана в отсортированном наборе данных. Исходное изображение src может представляться 1-, 3-, либо 4-канальной матрицей. В случае нескольких каналов медианный фильтр применяется независимо к каждому из них. Размер апертуры определяется параметром kSize. Если размер шаблона составляет 3 или 5, то глубина изображения должна иметь тип CV_8U, CV_16U или CV_32F. Для большей величины kSize поддерживается только CV_8U.

Далее показан пример использования функции blur и результат выполнения приведенной программы (рис.9.2).

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
const char helper[] =  
    "Sample_blur.exe  <img_file>\n\ 
    \t<img_file> - image file name\n"; 
 
int main(int argc, char* argv[]) 
{ 
    const char *initialWinName = "Initial Image",  
               *blurWinName = "blur"; 
    Mat img, blurImg; 
    if (argc < 2) 
    { 
        printf("%s", helper); 
        return 1; 
    } 
         // загрузка изображения 
    img = imread(argv[1], 1); 
    // сглаживание 
    blur(img, blurImg, Size(5, 5)); 
 
    // отображение исходного изображения  
    // и результата размытия 
    namedWindow(initialWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(blurWinName, CV_WINDOW_AUTOSIZE); 
    imshow(initialWinName, img); 
    imshow(blurWinName, blurImg); 
    waitKey(); 
 
    // закрытие окон 
    destroyAllWindows(); 
    // освобождение ресурсов 
    img.release(); 
    blurImg.release(); 
    return 0; 
} 

2.3. Морфологические преобразования

2.3.1. Дилатация и эрозия

Дилатация (морфологическое расширение) – свертка изображения или выделенной области изображения с некоторым ядром. Ядро может иметь произвольную форму и размер [1, 2]. При этом в ядре выделяется единственная ведущая позиция (anchor), которая совмещается с текущим пикселем при вычислении свертки. Во многих случаях в качестве ядра выбирается квадрат или круг с ведущей позицией в центре. Ядро можно рассматривать как шаблон или маску. Применение дилатации сводится к проходу шаблоном по всему изображению и применению оператора поиска локального максимума к интенсивностям пикселей изображения, которые накрываются шаблоном. Такая операция вызывает рост светлых областей на изображении (рис.9.3, c). На рисунке серым цветом отмечены пиксели, которые в результате применения дилатации будут белыми.

Эрозия (морфологическое сужение) – обратная операция. Действие эрозии подобно дилатации, разница лишь в том, что используется оператор поиска локального минимума (рис.9.3, d), серым цветом залиты пиксели, которые станут черными в результате эрозии.

Рассмотрим прототипы соответствующих функций эрозии и дилатации, реализованных в OpenCV [7].

void dilate(const Mat src, Mat dst, const Mat element, 
     Point anchor=Point(-1, -1), int iterations=1,      int borderType=BORDER_CONSTANT,  
   const Scalar borderValue =  
     morphologyDefaultBorderValue()) 
 
void erode(const Mat src, Mat dst, const Mat element,  
     Point anchor=Point(-1, -1), int iterations=1, 
     int borderType=BORDER_CONSTANT,  
     const Scalar borderValue =  
     morphologyDefaultBorderValue()) 
     

Параметры:

Далее приведен пример использования указанных функций. Сначала в программе выполняется чтение исходного изображения, название которого передается через аргументы командной строки. Затем применяются рассматриваемые операции. По окончании выполнения программы выполняется отображение результата применения эрозии и дилатации.

#include <stdio.h> 
#include <opencv2/opencv.hpp>  
using namespace cv; 
 
const char helper[] =  
    "Sample_erode_dilate.exe  <img_file>\n\ 
    \t<img_file> - image file name\n"; 
 
int main(int argc, char* argv[]) 
{ 
    const char *initialWinName = "Initial Image",  
               *erodeWinName = "erode",  
        *dilateWinName = "dilate"; 
    Mat img, erodeImg, dilateImg, element; 
    if (argc < 2) 
    { 
        printf("%s", helper); 
        return 1; 
    } 
    // загрузка черно-белого изображения 
    img = imread(argv[1], 1); 
    // вычисление эрозии и дилатации 
    element = Mat(); 
    erode(img, erodeImg, element); 
    dilate(img, dilateImg, element); 
 
    // отображение исходного изображения и результата 
    // применения морфологических операций "эрозия"  
    // и "дилатация" 
    namedWindow(initialWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(erodeWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(dilateWinName, CV_WINDOW_AUTOSIZE); 
    imshow(initialWinName, img); 
    imshow(erodeWinName, erodeImg); 
    imshow(dilateWinName, dilateImg); 
    waitKey(); 
 
    // освобождение ресурсов 
    img.release(); 
    erodeImg.release(); 
    dilateImg.release(); 
    return 0; 
} 

Результат выполнения данной программы показан на примере некоторого черно-белого изображения (рис.9.4). Как видно из рисунков, применение эрозии привело к сужению белых областей, дилатации – расширению (рис.9.5).

2.3.2. Дополнительные морфологические операции

При обработке бинарных изображений, как правило, базовых операций эрозии и дилатации достаточно. В процессе работы с цветными изображениями или изображениями в оттенках серого могут быть полезными более сложные морфологические операции. Библиотека OpenCV поддерживает ряд дополнительных морфологических операций, которые реализуется в функции morphologyEx [7].

void morphologyEx(const Mat src, Mat dst, int op,  
      const Mat element,  
     Point anchor=Point(-1, -1),  
     int iterations=1,       int borderType=BORDER_CONSTANT,  
     const Scalar borderValue =  
       morphologyDefaultBorderValue()) 
       

Рассмотрим параметры функции morphologyEx.

Данная функция обеспечивает выполнение следующих морфологических операций:

Ниже представлен пример использования функции morphologyEx, показывающий применение всех перечисленных продвинутых операций. Приложение обеспечивает загрузку изображения и последовательное применение описанных морфологических преобразований.

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
const char helper[] =  
    "Sample_morphologyEx.exe  <img_file>\n\ 
    \t<img_file> - image file name\n"; 
 
int main(int argc, char* argv[]) 
{ 
    const char *initialWinName = "Initial Image",  
            *morphologyOpenWinName = "MORPH_OPEN", 
            *morphologyCloseWinName = "MORPH_CLOSE", 
            *morphologyGradientWinName = "MORPH_GRADIENT", 
            *morphologyTopHatWinName = "MORPH_TOPHAT", 
            *morphologyBlackHatWinName = "MORPH_BLACKHAT"; 
    Mat img, morphologyOpenImg, morphologyCloseImg,  
        morphologyGradientImg, morphologyTopHatImg, 
        morphologyBlackHatImg, element; 
    if (argc < 2) 
    { 
        printf("%s", helper); 
        return 1; 
    } 
     
    // загрузка изображения 
    img = imread(argv[1], 1); 
 
    // применение морфологических операций 
    element = Mat(); 
    morphologyEx(img, morphologyOpenImg,  
                 MORPH_OPEN, element); 
    morphologyEx(img, morphologyCloseImg,  
                 MORPH_CLOSE, element); 
    morphologyEx(img, morphologyGradientImg, 
                 MORPH_GRADIENT, element); 
    morphologyEx(img, morphologyTopHatImg,  
                 MORPH_TOPHAT, element); 
    morphologyEx(img, morphologyBlackHatImg,                  MORPH_BLACKHAT, element); 
 
    // отображение исходного изображения  
    //и результата выполнения операций 
    namedWindow(initialWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(morphologyOpenWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(morphologyCloseWinName,  
                               CV_WINDOW_AUTOSIZE); 
    namedWindow(morphologyGradientWinName,  
                               CV_WINDOW_AUTOSIZE); 
    namedWindow(morphologyTopHatWinName,  
                               CV_WINDOW_AUTOSIZE); 
    namedWindow(morphologyBlackHatWinName, 
                               CV_WINDOW_AUTOSIZE); 
    imshow(initialWinName, img); 
    imshow(morphologyOpenWinName, morphologyOpenImg); 
    imshow(morphologyCloseWinName, morphologyCloseImg); 
    imshow(morphologyGradientWinName,  
                               morphologyGradientImg); 
    imshow(morphologyTopHatWinName, morphologyTopHatImg); 
    imshow(morphologyBlackHatWinName,  
                               morphologyBlackHatImg); 
    waitKey(); 
    // закрытие окон 
    destroyAllWindows(); 
    // осовобождение памяти 
    img.release(); 
    morphologyOpenImg.release(); 
    morphologyCloseImg.release(); 
    morphologyGradientImg.release(); 
    morphologyTopHatImg.release(); 
    morphologyBlackHatImg.release(); 
    return 0; 
} 

Далее на рисунке (рис.9.6) показаны результаты выполнения данной программы.

2.4. Оператор Собеля

Оператор Собеля – дискретный дифференциальный оператор, вычисляющий приближенные значения производных разного порядка для функции яркости пикселей [1]. Наиболее распространенным примером практического использования является определение границ (ребер) объектов на изображении, т.е. точек резкого изменения яркости.

Данный оператор основан на свертке изображения с целочисленными фильтрами. В простейшем случае оператор построен на вычислении сверток исходного изображения с ядрами $$G_x$$ и $$G_y$$, обеспечивающими вычисление первых производных по направлениям:

Данный оператор используется для приближенного вычисления градиента функции интенсивности пикселей. Применение оператора $$G_x$$ позволяет определить приближенное значение первой частной производной изменения интенсивности в горизонтальном направлении, $$G_y$$ – в вертикальном. На основании данной информации можно вычислить магнитуду градиента для пикселя с координатами (i,j) согласно формуле $$\lvert G^{ij} \rvert = \sqrt {(G^{ij}_x)^2+(G^{ij}_y)^2}$$. Также используя полученные данные, можно определить направление градиента как $$\theta^{ij}=arctan(\frac {G_x} {G_y} )$$.

В библиотеке OpenCV поддерживается вычисление первых, вторых, третьих и смешанных производных функции интенсивности пикселей с использованием расширенного оператора Собеля [7]. Ниже приведен прототип соответствующей программной функции.

void Sobel(const Matsrc, Matdst, int ddepth,  
        int xorder, int yorder, int ksize=3,  
        double scale=1, double delta=0,  
        int borderType=BORDER_DEFAULT) 

Перечислим входные параметры функции Sobel:

Далее приведен пример выделения ребер на изображении посредством применения горизонтального и вертикального операторов Собеля и усреднения полученных градиентов по направлениям. Заметим, что предварительно применяется фильтр Гаусса (GaussianBlur) для удаления шумов на исходном изображении и выполняется преобразование полученного изображения в оттенки серого (cvtColor). В результате применения оператора Собеля получаются изображения, глубина которых отличается от глубины исходного изображения, поэтому перед дальнейшими операциями выполняется преобразование указанных матриц в 8-битные целочисленные (convertScaleAbs).

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
const char helper[] =  
    "Sample_Sobel.exe  <img_file>\n\ 
    \t<img_file> - image file name\n"; 
 
int main(int argc, char* argv[]) 
{ 
    const char *initialWinName = "Initial Image",  
            *xGradWinName = "Gradient in the direction Ox", 
            *yGradWinName = "Gradient in the direction Oy", 
            *gradWinName = "Gradient"; 
    int ddepth = CV_16S; 
    double alpha = 0.5, beta = 0.5; 
    Mat img, grayImg, xGrad, yGrad,  
        xGradAbs, yGradAbs, grad; 
    if (argc < 2) 
    { 
        printf("%s", helper); 
        return 1; 
    }     
    // загрузка изображения 
    img = imread(argv[1], 1); 
    // сглаживание помощью фильтра Гаусса 
    GaussianBlur(img, img, Size(3,3),  
                 0, 0, BORDER_DEFAULT); 
    // преобразование в оттенки серого 
    cvtColor(img, grayImg, CV_RGB2GRAY); 
    // вычисление производных по двум направлениям 
    Sobel(grayImg, xGrad, ddepth, 1, 0); // по Ox 
    Sobel(grayImg, yGrad, ddepth, 0, 1); // по Oy 
    // преобразование градиентов в 8-битные 
    convertScaleAbs(xGrad, xGradAbs); 
    convertScaleAbs(yGrad, yGradAbs); 
    // поэлементное вычисление взвешенной  
    // суммы двух массивов 
    addWeighted(xGradAbs, alpha, yGradAbs, beta, 0, grad); 
 
    // отображение результата 
    namedWindow(initialWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(xGradWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(yGradWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(gradWinName, CV_WINDOW_AUTOSIZE);     imshow(initialWinName, img); 
    imshow(xGradWinName, xGradAbs); 
    imshow(yGradWinName, yGradAbs); 
    imshow(gradWinName, grad); 
    waitKey(); 
     // закрытие окон 
    destroyAllWindows(); 
    // осовобождение памяти 
    img.release(); 
    grayImg.release(); 
    xGrad.release(); 
    yGrad.release(); 
    xGradAbs.release(); 
    yGradAbs.release(); 
    return 0; 
} 

Ниже на рисунке (рис.9.7) показан результат выполнения приведенной программы на тестовом изображении (рис.9.2, слева).

Очевидно, что применение горизонтального оператора Собеля позволяет отчетливо выделить вертикальные ребра, а вертикального – горизонтальные ребра. Смесь указанных градиентов с весовыми коэффициентами, равными 0.5 обеспечивает вычисление приближенного значения градиента. Для этого используется вызов функции addWeighted.

Отметим, что библиотека OpenCV содержит функцию getDerivKernels, которая позволяет получить ядро для вычисления конкретной частной производной с определенной апертурой. Подробное описание параметров данной функции можно найти в документации [7].

2.5. Оператор Лапласа

Математически оператор Лапласа представляет сумму квадратов вторых частных производных функции $$\Delta f=\frac {\delta^2f} {\delta x^2} + \frac {\delta^2f} {\delta y^2}$$ . Дискретный аналог оператора Лапласа используется при обработке изображений, в частности, для определения ребер объектов на изображении. Ребра формируются из множества пикселей, в которых оператор Лапласа принимает нулевые значения, т.к. нули вторых производных функции соответствуют экстремальным перепадам интенсивности.

Библиотека OpenCV содержит функцию Laplacian, обеспечивающую вычисление оператора Лапласа [7].

void Laplacian(const Matsrc, Matdst, int ddepth,  
        int ksize=1, double scale=1, double delta=0,  
        int borderType=BORDER_DEFAULT) 
        

Параметры функции:

Приведем пример программы, которая обеспечивает поиск ребер объектов на изображения с помощью оператора Лапласа. Перед непосредственным применением оператора выполняется сглаживание с использованием фильтра Гаусса (GaussianBlur) и преобразование исходного изображения в оттенки серого (cvtColor). Заметим, что результирующие значения оператора Лапласа записываются в матрицу, глубина которой аналогично примеру с фильтром Собеля отличается от глубины исходного изображения, поэтому перед отображением выполняется преобразование полученной матрицы в 8-битную целочисленную посредством вызова функции convertScaleAbs.

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
const char helper[] =  
    "Sample_Laplacian.exe  <img_file>\n\     \t<img_file> - image file name\n"; 
 
int main(int argc, char* argv[]) 
{ 
    const char *initialWinName = "Initial Image", 
               *laplacianWinName = "Laplacian"; 
    Mat img, grayImg, laplacianImg, laplacianImgAbs; 
    int ddepth = CV_16S; 
    if (argc < 2) 
    { 
        printf("%s", helper); 
        return 1; 
    }     
    // загрузка изображения 
    img = imread(argv[1], 1); 
    // сглаживание с помощью фильтра Гаусса 
    GaussianBlur(img, img, Size(3,3),  
                 0, 0, BORDER_DEFAULT); 
    // преобразование в оттенки серого 
    cvtColor(img, grayImg, CV_RGB2GRAY); 
    // применение оператора Лапласа 
    Laplacian(grayImg, laplacianImg, ddepth); 
    convertScaleAbs(laplacianImg, laplacianImgAbs); 
     
    // отображение результата 
    namedWindow(initialWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(laplacianWinName, CV_WINDOW_AUTOSIZE); 
    imshow(initialWinName, img); 
    imshow(laplacianWinName, laplacianImgAbs); 
    waitKey(); 
 
     // закрытие окон 
    destroyAllWindows(); 
    // осовобождение памяти 
    img.release(); 
    grayImg.release(); 
    laplacianImg.release(); 
    laplacianImgAbs.release(); 
    return 0; 
} 

Далее показан результат выделения ребер с использованием оператора Лапласа (рис.9.8) на тестовом изображении, показанном ранее (рис.9.2, слева).

2.6. Детектор ребер Канни

Детектор ребер Канни [4, 8, 9] предназначен для поиска границ объектов на изображении. Детектор строится на основании оператора Собеля и включает несколько этапов:

Детектор Канни реализован в библиотеке OpenCV [7] в виде отдельной функции, прототип которой приведен далее.

void Canny(const Matimage, Matedges, double threshold1,  
        double threshold2, int apertureSize=3,  
        bool L2gradient=false) 
        

Функция принимает на вход следующие параметры:

Приведем пример использования детектора Канни. Отметим, что перед непосредственным применением детектора выполняется размытие изображения (blur) и преобразование в оттенки серого (cvtColor).

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
const char helper[] =  
    "Sample_Canny.exe  <img_file>\n\ 
    \t<img_file> - image file name\n"; 
 
int main(int argc, char* argv[]) 
{     const char *cannyWinName = "Canny detector"; 
    Mat img, grayImg, edgesImg; 
    double lowThreshold = 70, uppThreshold = 260; 
    if (argc < 2) 
    { 
        printf("%s", helper); 
        return 1; 
    }     
 
    // загрузка изображения 
    img = imread(argv[1], 1); 
    // удаление шумов 
    blur(img, img, Size(3,3)); 
    // преобразование в оттенки серого 
    cvtColor(img, grayImg, CV_RGB2GRAY); 
    // применение детектора Канни 
    Canny(grayImg, edgesImg, lowThreshold, uppThreshold); 
     
    // отображение результата 
    namedWindow(cannyWinName, CV_WINDOW_AUTOSIZE); 
    imshow(cannyWinName, edgesImg); 
    waitKey(); 
 
     // закрытие окон 
    destroyAllWindows(); 
 
    // осовобождение памяти 
    img.release(); 
    grayImg.release(); 
    edgesImg.release(); 
    return 0; 
} 

На рисунке (рис.9.9) показан результат применения детектора Канни к тестовому изображению (рис.9.2, слева).

2.7. Вычисление гистограмм

Один из наиболее распространенных дефектов фотографических, сканерных и телевизионных изображений – слабый контраст. Дефект во многом обусловлен ограниченностью диапазона воспроизводимых яркостей. Под контрастом понимается разность максимального и минимального значений яркости. Контрастность изображения можно повысить за счет изменения яркости каждого элемента изображения и увеличения диапазона яркостей. Существует несколько методов, основанных на вычислении гистограммы.

Допустим, что имеется изображение в оттенках серого, интенсивность пикселей которого изменяется в пределах значений от a до b , где $$a \geqslant 0$$ и $$b \leqslant 255$$. Для изображения можно построить гистограмму со столбцами, отвечающими количеству пикселей определенной интенсивности. Такого рода гистограмма позволяет представить распределение оттенков на изображении. В общем случае под гистограммой понимается коллекция целочисленных значений, каждое из которых определяет количество точек, обладающих некоторым свойством или принадлежащих определенному бину. На практике гистограммы применяются, чтобы получить статистическую картину о распределении каких-либо данных (пикселей, векторов признаков, направлений градиента во всех точках изображения и т.п.).

В данном разделе остановимся на рассмотрении структур данных и функций OpenCV, обеспечивающих вычисление гистограмм. Ниже приведены прототипы доступных функций.

void calcHist(const Mat* arrays, int narrays,         const int* channels, const Matmask,  
       MatND hist, int dims, const int* histSize, 
     const float** ranges, bool uniform=true,  
     bool accumulate=false) 
 
void calcHist(const Mat* arrays, int narrays,  
       const int* channels, const Matmask, 
       SparseMathist, int dims,  
       const int* histSize, const float** ranges, 
       bool uniform=true, bool accumulate=false) 
       

Параметры:

Рассмотрим пример программы, которая осуществляет построение и отображение гистограмм по каждому каналу цветного изображения. Программа получает в качестве аргументов командной строки название изображения, расщепляет полученную матрицу по каналам (split) и вычисляет гистограмму для каждого канала изображения (calcHist). Заметим, что в OpenCV каналы изображения хранятся в порядке BGR, а не в RGB. Далее выполняется нормализация гистограмм (normalize) для приемлемого отображения в виде ломаных.

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
const char helper[] =  
    "Sample_calcHist.exe  <img_file>\n\ 
    \t<img_file> - image file name\n"; 
 
int main(int argc, char* argv[]) 
{ 
    const char *initialWinName = "Initial Image", 
               *histWinName = "Histogram"; 
    Mat img, bgrChannels[3], bHist, gHist, rHist, histImg; 
    int kBins = 256; // количество бинов гистограммы 
    // интервал изменения значений бинов 
    float range[] = {0.0f, 256.0f};  
    const float* histRange = { range }; 
    // равномерное распределение интервала по бинам 
    bool uniform = true;  
    // запрет очищения перед вычислением гистограммы 
    bool accumulate = false;  
    // размеры для отображения гистограммы 
    int histWidth = 512, histHeight = 400;  
    // количество пикселей на бин 
    int binWidth = cvRound((double)histWidth / kBins);  
    int i, kChannels = 3; 
    Scalar colors[] = {Scalar(255, 0, 0),  
                 Scalar(0, 255, 0), Scalar(0, 0, 255)}; 
    if (argc < 2) 
    {         printf("%s", helper); 
        return 1; 
    }     
    // загрузка изображения 
    img = imread(argv[1], 1); 
    // выделение каналов изображения 
    split(img, bgrChannels); 
    // вычисление гистограммы для каждого канала 
    calcHist(bgrChannels[0], 1, 0, Mat(), bHist, 1,  
             kBins, histRange, uniform, accumulate); 
    calcHist(bgrChannels[1], 1, 0, Mat(), gHist, 1,  
             kBins, histRange, uniform, accumulate); 
    calcHist(bgrChannels[2], 1, 0, Mat(), rHist, 1,  
             kBins, histRange, uniform, accumulate); 
 
    // построение гистограммы 
    histImg = Mat(histHeight, histWidth, CV_8UC3,  
                  Scalar(0, 0, 0)); 
    // нормализация гистограмм в соответствии с размерами  
    // окна для отображения 
    normalize(bHist, bHist, 0, histImg.rows,  
        NORM_MINMAX, -1, Mat()); 
    normalize(gHist, gHist, 0, histImg.rows,  
        NORM_MINMAX, -1, Mat()); 
    normalize(rHist, rHist, 0, histImg.rows,  
        NORM_MINMAX, -1, Mat()); 
    // отрисовка ломаных 
    for (i = 1; i < kBins; i++) 
    { 
        line(histImg, Point(binWidth * (i-1),  
          histHeight-cvRound(bHist.at<float>(i-1))) , 
             Point(binWidth * i,  
                histHeight-cvRound(bHist.at<float>(i)) ), 
            colors[0], 2, 8, 0); 
        line(histImg, Point(binWidth * (i-1),  
                histHeight-cvRound(gHist.at<float>(i-1))) , 
            Point(binWidth * i,  
                histHeight-cvRound(gHist.at<float>(i)) ), 
            colors[1], 2, 8, 0); 
        line(histImg, Point(binWidth * (i-1),  
               histHeight-cvRound(rHist.at<float>(i-1))) , 
            Point(binWidth * i,  
               histHeight-cvRound(rHist.at<float>(i)) ), 
            colors[2], 2, 8, 0); 
    } 
    // отображение исходного изображения и гистограмм 
    namedWindow(initialWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(histWinName, CV_WINDOW_AUTOSIZE); 
    imshow(initialWinName, img); 
    imshow(histWinName, histImg);     waitKey(); 
     
    // закрытие окон 
    destroyAllWindows(); 
    // осовобождение памяти 
    img.release(); 
    for (i = 0; i < kChannels; i++) 
    { 
        bgrChannels[i].release(); 
    } 
    bHist.release(); 
    gHist.release(); 
    rHist.release(); 
    histImg.release(); 
    return 0; 
} 

Результат запуска программы на тестовом изображении из набора PASCAL VOC 2007 показан на рисунке (рис.9.10) ниже.

2.8. Выравнивание гистограмм

Существует три основных метода повышения контраста изображения:

Линейная растяжка сводится к присваиванию новых значений интенсивности каждому пикселю изображения. Если интенсивности исходного изображения изменялись в диапазоне от $$i_1$$ до $$i_2$$, тогда необходимо линейно "растянуть" указанный диапазон так, чтобы значения изменялись от 0 до 255. Для этого достаточно пересчитать старые значения интенсивности $$f_{xy}$$ для всех пикселей (x,y) согласно формуле $$g_{xy}=a \cdot f_{xy} +b$$ , где коэффициенты a,b просто вычисляются, исходя из того, что граница $$i_1$$ должна перейти в 0, а $$i_2$$ – в 255.

Нормализация гистограммы в отличие от предыдущего метода обеспечивает растяжку не всего диапазона изменения интенсивностей, а только его наиболее информативной части. Под информативной частью понимается набор пиков гистограммы, т.е. интенсивности, которые чаще остальных встречаются на изображении. Бины, соответствующие редко встречающимся интенсивностям, в процессе нормализации отбрасываются, далее выполняется обычная линейная растяжка получившейся гистограммы.

Выравнивание гистограмм – это один из наиболее распространенных способов. Цель выравнивания состоит в том, чтобы все уровни яркости имели бы одинаковую частоту, а гистограмма соответствовала равномерному закону распределения. Допустим, что задано изображение в оттенках серого, которое имеет разрешение $$N \times M$$ пикселей. Количество уровней квантования яркости пикселей (число бинов) составляет . Тогда в среднем на каждый уровень яркости должно выпадать $$n_{aver}=\frac {NM} {J}$$ пикселей. Базовая математика лежит в сопоставлении двух распределений. Пусть x,y – случайные величины, описывающие изменение интенсивности пикселей на изображениях, $$w_x(x)$$ – плотность распределения интенсивности на исходном изображении, $$w_y(y)$$ – желаемая плотность распределения. Необходимо найти преобразование плотностей распределения $$y=f(x)$$ , которое позволило бы получить желаемую плотность:

Обозначим через $$F_x(x)$$ и $$F_y(y)$$ интегральные законы распределения случайных величин x и y. Из условия вероятностной эквивалентности следует, что $$F_x(x)=F_y(y)$$. Распишем интегральный закон распределения по определению:

Отсюда получаем, что

Осталось выяснить, как оценить интегральный закон распределения $$F_x(x)$$. Для этого необходимо сначала построить гистограмму исходного изображения, затем нормализовать полученную гистограмму, разделив величину каждого бина на общее количество пикселей $$N \cdot M$$. Значения бинов можно рассматривать как приближенное значение функции плотности распределения $$w^*_x(x),0\leqslant x \leqslant 255$$. Таким образом, значение интегральной функции распределения можно представить как сумму следующего вида:

Построенную оценку можно использовать для вычисления новых значений интенсивности. Заметим, что перечисленные преобразования гистограмм можно применять не только ко всему изображению, но и к отдельным его частям.

В библиотеке OpenCV реализована функция equalizeHist, которая обеспечивает повышение контрастности изображения посредством выравнивания гистограммы [1, 7]. Прототип функции показан ниже.

void equalizeHist(const Matsrc, Matdst) 

Функция работает в четыре этапа:

Далее приведем пример программы, обеспечивающей выравнивание гистограммы. Приложение принимает в качестве аргумента командной строки название исходного изображения. После выполнения операции выравнивания гистограммы выполняется отображение исходного изображения Использовано изображение, входящее в состав базы PASACL VOC 2007. , переведенного в оттенки серого (рис.9.11, слева), и изображения с выровненной гистограммой (рис.9.11, справа).

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
const char helper[] =  
    "Sample_equalizeHist.exe  <img_file>\n\ 
    \t<img_file> - image file name\n"; 
                                                       
1
  
int main(int argc, char* argv[]) 
{ 
    const char *initialWinName = "Initial Image", 
               *equalizedWinName = "Equalized Image"; 
    Mat img, grayImg, equalizedImg; 
    if (argc < 2) 
    { 
        printf("%s", helper); 
        return 1; 
    }     
    // загрузка изображения 
    img = imread(argv[1], 1); 
    // преобразование в оттенки серого 
    cvtColor(img, grayImg, CV_RGB2GRAY); 
    // выравнивание гистограммы 
    equalizeHist(grayImg, equalizedImg); 
 
    // отображение исходного изображения и гистограмм 
    namedWindow(initialWinName, CV_WINDOW_AUTOSIZE); 
    namedWindow(equalizedWinName, CV_WINDOW_AUTOSIZE); 
    imshow(initialWinName, grayImg); 
    imshow(equalizedWinName, equalizedImg); 
    waitKey(); 
     
    // закрытие окон 
    destroyAllWindows(); 
    // осовобождение памяти 
    img.release(); 
    grayImg.release(); 
    equalizedImg.release(); 
    return 0; 
}    

3. Программная реализация

3.1. Разработка консольного редактора изображений

3.1.1. Требования к приложению

На данном этапе предлагается разработать простейший консольный редактор изображений, предусматривающий возможность применения всех операций, перечисленных в разделе 2. К приложению предъявляются следующие требования:

3.1.2. Структура консольного приложения

Сначала необходимо создать и настроить проект в среде Mcrosoft Visual Studio. Процедура подробно была описана ранее в работе "Сборка и установка библиотеки OpenCV. Использование библиотеки в среде Microsoft Visual Studio", поэтому в данном разделе остановимся на разработке структуры приложения. Консольное приложение будет состоять из модуля, содержащего вызов функций OpenCV для обработки изображений, и файла исходного кода основной функции.

Для упрощения разработки введем несколько констант:

const int kMenuTabs = 12; 

const char* menu[] =  
{ 
    "0 - Read image",  
    "1 - Apply linear filter",  
    "2 - Apply blur(...)", 
    "3 - Apply medianBlur(...)", 
    "4 - Apply GaussianBlur(...)", 
    "5 - Apply erode(...)", 
    "6 - Apply dilate(...)", 
    "7 - Apply Sobel(...)", 
    "8 - Apply Laplacian(...)", 
    "9 - Apply Canny(...)", 
    "10 - Apply calcHist(...)", 
    "11 - Apply equalizeHist(...)" 
}; 

const char* winNames[] =  
{ 
    "Initial image",  
    "filter2d",  
    "blur", 
    "medianBlur", 
    "GaussianBlur", 
    "erode", 
    "dilate", 
    "Sobel", 
    "Laplacian", 
    "Canny", 
    "calcHist", 
    "equalizeHist" 
}; 

const int maxFileNameLen = 1000; 

const int escCode = 27; 

Рассмотрим структуру основной функции. По сути, данная функция содержит цикл опроса пользователя до момента необходимости выхода из программы. Выход из программы организован посредством нажатия клавиши ESC. Цикл включает в себя выполнение нескольких операций:

void printMenu(); 
void chooseMenuTab(int activeMenuTab, Mat srcImg); 
void loadImage(Mat srcImg); 
 
int main(int argc, char** argv) 
{ 
    Mat srcImg; // исходное изображение 
    char ans; 
    int activeMenuTab = -1; 
    do 
    { 
        // вызов функции выбора пункта меню 
        chooseMenuTab(activeMenuTab, srcImg); 
        // применение операций 
        applyOperation(srcImg, activeMenuTab); 
        // вопрос о необходимости продолжения 
        printf("Do you want to continue? ESC - exit\n"); 
        // ожидание нажатия клавиши 
        ans = waitKey(); 
    } 
    while (ans != escCode); 
    destroyAllWindows(); // закрытие всех окон 
    srcImg.release(); // освобожение памяти 
    return 0; } 
    

Перейдем к реализации необходимых функций.

void printMenu() 
{ 
    int i = 0; 
    printf("Menu items:\n"); 
    for (i; i < kMenuTabs; i++) 
    { 
        printf("\t%s\n", menu[i]); 
    } 
    printf("\n"); 
} 

void chooseMenuTab(int activeMenuTab, Mat srcImg) 
{ 
    int tabIdx; 
    while (true) 
    { 
        // print menu items 
        printMenu(); 
        // get menu item identifier to apply operation 
        printf("Input item identifier to apply \ 
                operation: "); 
        scanf("%d", tabIdx); 
        if (tabIdx == 0) 
        { 
            // read image 
            loadImage(srcImg);             
        } 
        else if (tabIdx >=1  tabIdx < kMenuTabs 
                 srcImg.data == 0) 
        { 
            // read image 
            printf("The image should be read to apply\ 
                    operation!\n"); 
            loadImage(srcImg); 
        } 
        else if (tabIdx >=1  tabIdx < kMenuTabs)         { 
            activeMenuTab = tabIdx; 
            break; 
        } 
    } 
} 

void loadImage(Mat srcImg) 
{ 
    char fileName[maxFileNameLen]; 
    do  
    { 
        printf("Input full file name: "); 
        scanf("%s", fileName); 
        srcImg = imread(fileName, 1); 
    } 
    while (srcImg.data == 0);     
    printf("The image was succesfully read\n\n"); 
} 

int applyOperation(const Mat src, const int operationIdx) 
{ 
    char key = -1; 
    Mat dst; 
    switch (operationIdx) 
    { 
    case 1: 
        { 
            // TODO: "1 - Apply linear filter" 
            break; 
        } 
    // TODO: Apply another operations (from 2 to 11) 
    } 
    // show initial image 
    namedWindow(winNames[0], 1);     imshow(winNames[0], src); 
 
    // show processed image 
    namedWindow(winNames[operationIdx]); 
    imshow(winNames[operationIdx], dst); 
 
    return 0; 
} 

Реализацию функций операций обработки изображений с организацией ввода необходимых параметров предоставляем читателю в качестве самостоятельной работы. Пример организации диалога с пользователем показан ниже (рис.9.12).

3.2. *Разработка редактора изображений с графическим интерфейсом с использованием функций OpenCV, реализованных на базе Qt

Разработка редактора изображений с графическим интерфейсом на базе Qt требует выполнения ряда предварительных действий:

После предварительной подготовки инфраструктуры необходимо выполнить создание и настройку проекта в Visual Studio по схеме, описанной ранее. Далее можно использовать все доступные функции библиотеки OpenCV, реализованные на базе Qt [12]. Количество доступных функций ограничено, тем не менее, для создания минимального графического интерфейса предоставляемого набора вполне достаточно: создание окон с базовым набором операций просмотра (сохранение, масштабирование изображения и т.п., рис.9.13), создание кнопочных элементов, полос прокрутки и др.

Читателю предлагается самостоятельно продумать структуру приложения и разработать его программную реализацию.

4. Контрольные вопросы

5. Дополнительные задания

7. Приложения

7.1. Приложение А. Исходный код основной функции консольного редактора изображений

#include <stdio.h> 
#include <opencv2/opencv.hpp> 
#include "functions.h" 
 
using namespace cv; 
 
const int kMenuTabs = 12; 
const char* menu[] =  
{ 
    "0 - Read image",  
    "1 - Apply linear filter",  
    "2 - Apply blur(...)",     "3 - Apply medianBlur(...)", 
    "4 - Apply GaussianBlur(...)", 
    "5 - Apply erode(...)", 
    "6 - Apply dilate(...)", 
    "7 - Apply Sobel(...)", 
    "8 - Apply Laplacian(...)", 
    "9 - Apply Canny(...)", 
    "10 - Apply calcHist(...)", 
    "11 - Apply equalizeHist(...)" 
}; 
const char* winNames[] =  
{ 
    "Initial image",  
    "filter2d",  
    "blur", 
    "medianBlur", 
    "GaussianBlur", 
    "erode", 
    "dilate", 
    "Sobel", 
    "Laplacian", 
    "Canny", 
    "calcHist", 
    "equalizeHist" 
}; 
const int maxFileNameLen = 1000; 
const int escCode = 27; 
 
void printMenu(); 
void chooseMenuTab(int activeMenuTab, Mat srcImg); 
void loadImage(Mat srcImg); 
 
int main(int argc, char** argv) 
{ 
    Mat srcImg; // исходное изображение 
    char ans; 
    int activeMenuTab = -1; 
    do 
    { 
        // choose menu item 
        chooseMenuTab(activeMenuTab, srcImg); 
        // apply operation 
        applyOperation(srcImg, activeMenuTab); 
        // ask a question 
        printf("Do you want to continue? ESC - exit\n"); 
        // waiting for key will be pressed 
        ans = waitKey(); 
    } 
    while (ans != escCode); 
    destroyAllWindows(); // destroy all windows     // release memory allocated for storing image 
    srcImg.release(); 
    return 0; 
} 
 
void printMenu() 
{ 
    int i = 0; 
    printf("Menu items:\n"); 
    for (i; i < kMenuTabs; i++) 
    { 
        printf("\t%s\n", menu[i]); 
    } 
    printf("\n"); 
} 
 
void loadImage(Mat srcImg) 
{ 
    char fileName[maxFileNameLen]; 
    do  
    { 
        printf("Input full file name: "); 
        scanf("%s", fileName); 
        srcImg = imread(fileName, 1); 
    } 
    while (srcImg.data == 0);     
    printf("The image was succesfully read\n\n"); 
} 
 
void chooseMenuTab(int activeMenuTab, Mat srcImg) 
{ 
    int tabIdx; 
    while (true) 
    { 
        // print menu items 
        printMenu(); 
        // get menu item identifier to apply operation 
        printf( 
           "Input item identifier to apply operation: "); 
        scanf("%d", tabIdx); 
        if (tabIdx == 0) 
        { 
            // read image 
            loadImage(srcImg);             
        } 
        else if (tabIdx >=1  tabIdx < kMenuTabs   
                 srcImg.data == 0) 
        { 
            // read image 
            printf("The image should be read\                  to apply operation!\n"); 
            loadImage(srcImg); 
        } 
        else if (tabIdx >=1  tabIdx < kMenuTabs) 
        { 
            activeMenuTab = tabIdx; 
            break; 
        } 
    } 
} 

7.2. Приложение Б. Исходный код заголовочного файла функционального модуля консольного редактора изображений

#ifndef __FUNCTIONS_H__ 
#define __FUNCTIONS_H__ 
 
#include <opencv2/opencv.hpp> 
 
using namespace cv; 
 
extern const int kMenuTabs; 
extern const char* winNames[]; 
 
// TODO: добавить прототипы функций, реализующих  
//       другие операции 
int applyMedianBlur(const Mat src, Mat dst); 
 
int applyOperation(const Mat src, const int operationIdx); 
 
#endif 

7.3. Приложение В. Исходный код функционального модуля консольного редактора изображений

#include "functions.h" 
 
int applyMedianBlur(const Mat src, Mat dst) 
{ 
    int kSize = 3, minDim = -1; 
    minDim = min(src.size().height, src.size().width); 
    do 
    { 
        printf("Set kernel size (odd, > 3, \ 
               < min(img.width, img.height)): "); 
        scanf("%d", kSize); 
    } 
    while (kSize < 3  kSize > minDim  kSize %2 == 0);     medianBlur(src, dst, kSize); 
    return 0; 
} 
 
int applyOperation(const Mat src, const int operationIdx) 
{ 
    char key = -1; 
    Mat dst; 
    switch (operationIdx) 
    { 
    case 1: 
        { 
            // TODO: "1 - Apply linear filter" 
            break; 
        } 
    case 2: 
        { 
            // TODO: "2 - Apply blur(...)" 
            break; 
        } 
    case 3: 
        { 
            // "3 - Apply medianBlur(...)" 
            applyMedianBlur(src, dst); 
            break; 
        } 
    case 4: 
        { 
            // TODO: "4 - Apply GaussianBlur(...)" 
            break; 
        } 
    case 5: 
        { 
            // TODO: "5 - Apply erode(...)" 
            break; 
        } 
    case 6: 
        { 
            // TODO: "6 - Apply dilate(...)" 
            break; 
        } 
    case 7: 
        { 
            // TODO: "7 - Apply Sobel(...)" 
            break; 
        } 
    case 8: 
        { 
            // TODO: "8 - Apply Laplacian(...)" 
            break;         } 
    case 9: 
        { 
            // TODO: "9 - Apply Canny(...)" 
            break; 
        } 
    case 10: 
        { 
            // TODO: "10 - Apply calcHist(...)" 
            break; 
        } 
    case 11: 
        { 
            // TODO: "11 - Apply equalizeHist(...)" 
            break; 
        } 
    } 
    // show initial image 
    namedWindow(winNames[0], 1); 
    imshow(winNames[0], src); 
 
    // show processed image 
    namedWindow(winNames[operationIdx]); 
    imshow(winNames[operationIdx], dst); 
    return 0; 
}