Сравнение производительности некоторых алгоритмов в библиотеках OpenCV и IPP

2.4. Функция main

Перейдем теперь к разработке функции main(). Прежде всего необходимо подключить заголовочные файлы. Кроме функций из библиотек OpenCV и IPP нам потребуется также вывод сообщений на консоль с помощью printf() и замеры времени с использованием функции clock().

#include <stdio.h> 
#include <time.h> 
#include <opencv2/opencv.hpp> 
#include <ippi.h> 
#include <ippcc.h>   
    

Для более удобной работы с OpenCV подключим пространство имен cv.

using namespace cv;   
    

Имя файла с изображением будем передавать через командную строку.

Выбор алгоритма обработки изображения также будем выполнять через аргумент командной строки.

Далее представлен начальный вариант функции main(), содержащий, кроме указанного выше, также вызовы функций, в которых необходимо будет разместить код, реализующий соответствующие алгоритмы.

char helper[] =   
  "01_OpenCVvsIPP.exe <img_name> <mode> <num_of_exp>\n\ 
  \t<img_name> - image filename\n\ 
  \t<mode>:\n\ 
  \t\t1 - median filtering\n\ 
  \t\t2 - erode\n\ 
  \t\t3 - dilate\n\ 
  \t\t4 - calc histogram\n\ 
  \t<num_of_exp> - number of experiments\n"; 
 
int main(int argc, char *argv[]) 
{ 
  Mat srcImgOCV, srcImgIPP, dstImgOCV, dstImgIPP; 
  int mode, i; 
  double ocv_time, ipp_time; 
 
  if (argc < 4) 
  { 
    printf("%s", helper); 
    return 1; 
  } 
 
  // загрузить изображение 
  srcImgOCV = imread(argv[1]); 
  if (srcImgOCV.data == 0) 
  { 
    printf("ERROR!!! imread(...)"); 
    return 1; 
  } 
  srcImgOCV.copyTo(srcImgIPP); 
 
  mode = atoi(argv[2]); 
  switch (mode) 
  { 
  case 1: 
    // отфильтровать с помощью OpenCV 
    ocv_time = median_opencv(srcImgOCV, dstImgOCV); 
    // отфильтровать с помощью IPP 
    ipp_time = median_ipp(srcImgIPP, dstImgIPP); 
    break; 
  case 2: 
    // выполнить эрозию с помощью OpenCV 
    ocv_time = erode_opencv(srcImgOCV, dstImgOCV); 
    // выполнить эрозию с помощью IPP 
    ipp_time = erode_ipp(srcImgIPP, dstImgIPP); 
    break; 
  case 3: 
    // выполнить дилатацию с помощью OpenCV 
    ocv_time = dilate_opencv(srcImgOCV, dstImgOCV); 
    // выполнить дилатацию с помощью IPP 
    ipp_time = dilate_ipp(srcImgIPP, dstImgIPP); 
    break; 
  case 4: 
    // вычислить гистограмму с помощью OpenCV 
    ocv_time = hist_opencv(srcImgOCV, dstImgOCV); 
    // вычислить гистограмму с помощью IPP 
    ipp_time = hist_ipp(srcImgIPP, dstImgIPP); 
    break; 
  } 
 
  printf("ocv time is %.3f\nipp time is %.3f", ocv_time, 
    ipp_time); 
 
  // освободить память 
  srcImgOCV.release(); 
  srcImgIPP.release(); 
  dstImgOCV.release(); 
  dstImgIPP.release(); 
 
  return 0; 
} 
    

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

2.5. Реализация операций с использованием функционала библиотеки OpenCV

Первые три задачи из выбранных нами средствами OpenCV решаются очень просто. Рассмотрим их подробнее.

2.5.1. Функция медианной фильтрации

Медианная фильтрация в библиотеке OpenCV реализуется с помощью функции medianBlur(). Ее подробное описание может быть найдено в лабораторной работе "Базовые операции обработки изображений" настоящего курса. Здесь же лишь отметим, что в экспериментах мы будем использовать размер ядра, равный 3, но предусмотрим возможность его изменения.

double median_opencv(const Mat srcImg, Mat dstImg, 
  const int kSize = 3); 
 
double median_opencv(const Mat srcImg, Mat dstImg, 
  const int kSize) 
{ 
  clock_t start, finish; 
   
  start = clock(); 
  medianBlur(srcImg, dstImg, kSize); 
  finish = clock(); 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
} 
      

2.5.2. Функция вычисления эрозии

Эрозия изображения выполняется в OpenCV с помощью функции erode(). Используем простейший вариант ее вызова с тремя параметрами, при котором применяется квадратный шаблон $$3 \times 3$$.

double erode_opencv(const Mat srcImg, Mat dstImg) 
{ 
  clock_t start, finish; 
 
  start = clock(); 
  Mat element = Mat(); 
  erode(srcImg, dstImg, element); 
  finish = clock(); 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
}   
      

2.5.3. Функция вычисления дилатации

Полностью аналогично обстоит дело с функцией дилатации.

double dilate_opencv(const Mat srcImg, Mat dstImg) 
{ 
  clock_t start, finish; 
 
  start = clock(); 
  Mat element = Mat(); 
  dilate(srcImg, dstImg, element); 
  finish = clock(); 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
}   
      

За описанием функций erode() и dilate() также отсылаем к лабораторной работе "Базовые операции обработки изображений".

2.5.4. Функция вычисления гистограммы

Для вычисления гистограммы используем часть кода, приведенного в соответствующем разделе лабораторной работы "Базовые операции обработки изображений". Будем строить гистограмму по каждому каналу цветного изображения, предварительно расщепляя его по каналам с помощью функции split().

double hist_opencv(const Mat srcImg, Mat dstImg) 
{ 
  Mat bgrChannels[3], bHist, gHist, rHist; 
  // количество бинов гистограммы 
  int kBins = 256; 
  // интервал изменения значений бинов 
  float range[] = {0.0f, 256.0f}; 
  const float* histRange = { range }; 
  // равномерное распределение интервала по бинам 
  bool uniform = true; 
  // запрет очищения перед вычислением гистограммы 
  bool accumulate = false; 
  clock_t start, finish; 
 
  start = clock(); 
  split(srcImg, 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); 
  finish = clock(); 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
}   
      

2.6. Реализация операций с использованием функционала библиотеки Intel IPP

2.6.1. Функция медианной фильтрации

Медианная фильтрация в IPP выполняется при помощи одной из функций вида ippiFilterMedian_<mod>. В случае цветного изображения mod – 3uC3R. Кроме того, в документации к IPP указано, что если мы хотим применить фильтр с шаблоном размера msk, необходимо расширить матрицу изображения на msk / 2 пикселов с каждой стороны. Для расширения используем функцию ippiCopyReplicateBorder_8u_C3R(). Наконец, после получения "расширенного" отфильтрованного изображения, необходимо выполнить обратную операцию – выделить изображение исходного размера. Это можно сделать, просто скопировав внутреннюю часть расширенной матрицы пикселей с помощью функции ippiCopy_8u_C3R().

Получим следующий код.

double median_ipp(const Mat srcImg, Mat dstImg, 
  const int msk = 3); 
 
double median_ipp(const Mat srcImg, Mat dstImg, 
  const int msk) 
{ 
  const int borderSize = msk / 2; 
  IppiSize mskSize = { msk , msk }; 
  IppiPoint anchor = { msk / 2, msk / 2 }; 
  Mat ippSrcImg, ippDstImg; 
  Size ippImgSize; 
  IppiSize ippSrcSize, ippDstSize; 
  Ipp8u *pSrcData, *pDstData; 
  clock_t start, finish; 
 
  ippImgSize.width = 
    srcImg.size().width + 2 * borderSize; 
  ippImgSize.height = 
    srcImg.size().height + 2 * borderSize; 
  ippSrcImg.create(ippImgSize, srcImg.type()); 
  ippDstImg.create(ippImgSize, srcImg.type()); 
  pSrcData = (Ipp8u *)ippSrcImg.data; 
  pDstData = (Ipp8u *)ippDstImg.data; 
 
  start = clock(); 
  ippSrcSize.width = srcImg.size().width; 
  ippSrcSize.height = srcImg.size().height; 
  ippDstSize.width = 
    srcImg.size().width + 2 * borderSize; 
  ippDstSize.height = 
    srcImg.size().height + 2 * borderSize; 
  ippiCopyReplicateBorder_8u_C3R(srcImg.data, 
    srcImg.step1(), ippSrcSize, 
    pSrcData, srcImg.step1() + 3 * 2 * borderSize, 
    ippDstSize, borderSize, borderSize); 
 
  ippiFilterMedian_8u_C3R(pSrcData + 
    ippImgSize.width * 3 * borderSize + 3 * borderSize, 
    srcImg.step1() + 3 * 2 * borderSize, pDstData + 
    ippImgSize.width * 3 * borderSize + 3 * borderSize, 
    srcImg.step1() + 3 * 2 * borderSize, ippSrcSize, 
    mskSize, anchor); 
  finish = clock(); 
 
  dstImg.create(srcImg.size(), srcImg.type()); 
  pSrcData = pDstData; 
  pDstData = (Ipp8u *)dstImg.data; 
  ippiCopy_8u_C3R(pSrcData + 
    ippImgSize.width * 3 * borderSize + 3 * borderSize, 
    srcImg.step1() + 3 * 2 * borderSize, pDstData, 
  dstImg.step1(), ippSrcSize); 
 
  ippSrcImg.release(); 
  ippDstImg.release(); 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
} 
      

Отметим, что для построения "расширенной" матрицы изображения мы использовали функции OpenCV для работы c типом Mat.

  ippImgSize.width = 
    srcImg.size().width + 2 * borderSize; 
  ippImgSize.height = 
    srcImg.size().height + 2 * borderSize; 
  ippSrcImg.create(ippImgSize, srcImg.type()); 
  ippDstImg.create(ippImgSize, srcImg.type()); 
  pSrcData = (Ipp8u *)ippSrcImg.data; 
  pDstData = (Ipp8u *)ippDstImg.data;   
      

Конечно, то же самое можно проделать только средствами IPP. Внести соответствующие изменения предлагаем читателю самостоятельно.

Также отметим, что, как и в OpenCV-версии, здесь мы предусмотрели возможность задания ядра произвольного размера, но в экспериментах далее будем использовать значение msk по умолчанию.

2.6.2. Функция вычисления эрозии

Реализацию функций для вычисления эрозии и дилатации средствами IPP мы выполним несколько по-другому. Дело в том, что представленные выше варианты вызовов функций erode() и dilate() из OpenCV выполняют обработку только внутренних пикселей исходного изображения. Таким образом, и в IPP-версии нам нет необходимости расширять матрицу изображения. Вместо этого мы можем соответствующим образом определить область интереса (ROI).

double erode_ipp(const Mat srcImg, Mat dstImg) 
{ 
  IppiMaskSize msk; 
  Ipp8u *pSrcData, *pDstData; 
  IppiSize srcSize, dstRoiSize; 
  clock_t start, finish; 
 
  srcImg.copyTo(dstImg); 
 
  start = clock(); 
  pSrcData = (Ipp8u *)srcImg.data; 
  pDstData = (Ipp8u *)dstImg.data; 
  srcSize.width = srcImg.size().width; 
  srcSize.height = srcImg.size().height; 
 
  msk = ippMskSize3x3; 
  dstRoiSize.width = srcImg.size().width - 2; 
  dstRoiSize.height = srcImg.size().height - 2; 
  ippiErode3x3_8u_C3R(pSrcData + 
    srcSize.width * 3 * 1 + 3 * 1, srcImg.step1(), 
    pDstData + srcSize.width * 3 * 1 + 3 * 1, 
    srcImg.step1(), dstRoiSize); 
 
  finish = clock(); 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
} 
      

2.6.3. Функция вычисления дилатации

Реализация функции вычисления дилатации средствами IPP совпадает с таковой для функции эрозии за исключением вызова функции ippiDilate3x3_8u_C3R() вместо ippiErode3x3_8u_C3R().

double erode_ipp(const Mat srcImg, Mat dstImg) 
{ 
  IppiMaskSize msk; 
  Ipp8u *pSrcData, *pDstData; 
  IppiSize srcSize, dstRoiSize; 
  clock_t start, finish; 
 
  srcImg.copyTo(dstImg); 
 
  start = clock(); 
  pSrcData = (Ipp8u *)srcImg.data; 
  pDstData = (Ipp8u *)dstImg.data; 
  srcSize.width = srcImg.size().width; 
  srcSize.height = srcImg.size().height; 
 
  msk = ippMskSize3x3; 
  dstRoiSize.width = srcImg.size().width - 2; 
  dstRoiSize.height = srcImg.size().height - 2; 
  ippiDilate3x3_8u_C3R(pSrcData + 
    srcSize.width * 3 * 1 + 3 * 1, srcImg.step1(), 
    pDstData + srcSize.width * 3 * 1 + 3 * 1, 
    srcImg.step1(), dstRoiSize); 
 
  finish = clock(); 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
}     
      

2.6.4. Функция вычисления гистограммы

Вычислить гистограмму для многоканального изображения, можно используя функции IPP вида ippiHistogramRange_<mod>. Как и ранее в нашем случае mod – 8u_C3R. Для вызова этой функции необходимо предварительно подготовить:

  Ipp32s *pHisto[3]; 
  pHisto[0] = new Ipp32s[kBins + 1]; 
  pHisto[1] = new Ipp32s[kBins + 1]; 
  pHisto[2] = new Ipp32s[kBins + 1];   
          

  Ipp32s level1[kBins + 1], level2[kBins + 1], 
    level3[kBins + 1]; 
  const Ipp32s *pLevels[3] = { level1, level2, level3 };   
          

  for (i = 0; i < kBins + 1; i++) 
    level1[i] = level2[i] = level3[i] = i;   
          

  int nLevels[3] = {kBins + 1, kBins + 1, kBins + 1};   
          

Смысл параметров pHisto и pLevels для выбранного канала можно проиллюстрировать так: pHisto[k] – это число пикселей изображения, таких что pLevels[k] <= pHisto[k] < pLevels[k+1].

Получим следующий код.

double hist_ipp(const Mat srcImg, Mat dstImg) 
{ 
  // количество бинов гистограммы 
  const int kBins = 256; 
  Ipp8u *pSrcData; 
  IppiSize srcSize; 
  int i; 
  Ipp32s level1[kBins + 1], level2[kBins + 1], 
    level3[kBins + 1]; 
  Ipp32s *pHisto[3]; 
  const Ipp32s *pLevels[3] = { level1, level2, level3 }; 
  int nLevels[3] = {kBins + 1, kBins + 1, kBins + 1}; 
  clock_t start, finish; 
 
  pHisto[0] = new Ipp32s[kBins + 1]; 
  pHisto[1] = new Ipp32s[kBins + 1]; 
  pHisto[2] = new Ipp32s[kBins + 1]; 
 
  for (i = 0; i < kBins + 1; i++) 
    level1[i] = level2[i] = level3[i] = i; 
 
  pSrcData = (Ipp8u *)srcImg.data; 
  srcSize.width = srcImg.size().width; 
  srcSize.height = srcImg.size().height; 
 
  start = clock(); 
  ippiHistogramRange_8u_C3R(pSrcData, srcImg.step1(), 
    srcSize, pHisto, pLevels, nLevels); 
  finish = clock(); 
 
  delete [] pHisto[0]; 
  delete [] pHisto[1]; 
  delete [] pHisto[2]; 
 
  return double(finish - start) / CLOCKS_PER_SEC; 
} 
 
      

2.7. Анализ корректности

Для медианного фильтра, эрозии и дилатации результирующие изображения, полученные средствами OpenCV и IPP, можно сравнить попиксельно. Для этого напишем следующую функцию, возвращающую число точек в двух изображениях с несовпадающими значениями.

int compare(const Mat srcImgOCV, const Mat srcImgIPP) 
{ 
  int kPoints = 0; 
  int w, h, i, j, idx; 
  w = srcImgOCV.size().width; 
  h = srcImgOCV.size().height; 
  for (i = 0; i < h; i++) 
  { 
    idx = 3 * i * w; 
    for (j = 0; j < w; j++, idx += 3) 
      if (((srcImgOCV.data[idx]-srcImgIPP.data[idx])!=0) 
        ||((srcImgOCV.data[idx+1]- 
          srcImgIPP.data[idx+1])!=0) 
        ||((srcImgOCV.data[idx+2]- 
          srcImgIPP.data[idx+2])!=0)) 
    { 
      kPoints++; 
    } 
  } 
 
  return kPoints; 
}   
    

Осталось добавить в функцию main() фрагмент для проверки корректности.

  int kDiffPoints = 0; 
... 
  // сравнить результаты 
  if (mode < 4) 
  { 
    kDiffPoints = compare(dstImgOCV, dstImgIPP); 
    if (kDiffPoints == 0) 
      printf("OpenCV and IPP give the same result.\n"); 
    else 
      printf("OpenCV and IPP give different results in %d\ 
        points.\n", kDiffPoints); 
  } 
    

Сравнение результатов построения гистограммы средствами OpenCV и IPP предоставляем провести читателю самостоятельно.

2.8. Запуск приложения

С учетом использованных нами функций OpenCV для запуска программы потребуются следующие динамические библиотеки: opencv_core242.dll, opencv_highgui242.dll, opencv_imgproc242.dll, tbb.dll.

Первые три располагаются в папке build\x86\vc10\bin\. Последняя – в build\common\tbb\ia32\vc10\.

Использование функций IPP предполагает, что следующий путь должен быть известен операционной системе "C:\Program Files (x86)\Intel\Composer XE 2013\redist\ia32\ipp\".

Собственно запуск можно выполнить, используя командную строку вида

OpenCVvsIPP.exe Desert.jpg 1

3. Сравнение производительности операций над изображениями, реализованных на базе OpenCV и Intel IPP

3.1. Тестовые данные

Все рассматриваемые в данной лабораторной работе алгоритмы имеют квадратичную сложность. Чтобы подготовленные нами реализации показывали времена, на которых имеет смысл проводить сравнение, необходимо использовать или подготовить изображение достаточно большого размера. Используем файл Desert.jpg из состава операционной системы Windows 7, расположенный в папке C:\Users\Public\Pictures\Sample Pictures. Этот файл имеет размер 1024?768 пикселей. Создадим из него изображение размера 8192?6144 пиксела, скопировав исходную картинку нужное число раз в любом графическом редакторе.

На указанном изображении авторами были получены следующие времена.

3.2. Проведение вычислительных экспериментов

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

Таким образом, необходимо изменить следующие фрагменты.

Дополнить описание запуска.

char helper[] = 
  "01_OpenCVvsIPP.exe <img_name> <mode> <num_of_exp>\n\ 
  \t<img_name> - image filename\n\ 
  \t<mode>:\n\ 
  \t\t1 - median filtering\n\ 
  \t\t2 - erode\n\ 
  \t\t3 - dilate\n\ 
  \t\t4 - calc histogram\n\ 
  \t<num_of_exp> - number of experiments\n"; 
   
    

Исправить проверку на число параметров командной строки

  if (argc < 4) 
  { 
    printf("%s", helper); 
    return 1; 
  }   
    

Считать значение параметра.

  int numOfExp; 
... 
  numOfExp = atoi(argv[3]);   
    

Изменить вызовы функций

  ocv_time = ipp_time = 0; 
  switch (mode) 
  { 
  case 1: 
    for (i = 0; i < numOfExp; i++) 
    { 
      // отфильтровать с помощью OpenCV 
      ocv_time += median_opencv(srcImgOCV, dstImgOCV); 
      // отфильтровать с помощью IPP 
      ipp_time += median_ipp(srcImgIPP, dstImgIPP); 
    } 
...   
    

Выполните указанные изменения и проведите эксперименты с разными значениями параметра numOfExp.

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