image-processing/image_processor.cc at master · jgonik/image-processing · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include "image_processor.h"
#include <string>
#include <iostream>

using ::std::string;

//==========================================================================
ImageProcessor::ImageProcessor(std::string fileName)
    : img_(fileName)
{
}

//==========================================================================
ImageProcessor::~ImageProcessor()
{
}

//==========================================================================
bool ImageProcessor::convertToGrayscale()
{
  png::image< png::gray_pixel > newImage(img_.get_width(), img_.get_height());
  for (size_t x = 0; x < img_.get_width(); ++x)
  {
    std::vector<int> temp;
    for (size_t y = 0; y < img_.get_height(); ++y)
    {
      png::rgb_pixel pixel = img_.get_pixel(x, y);
      int newValue = (pixel.red + pixel.green + pixel.blue) / 3;
      temp.push_back(newValue);
      png::gray_pixel newPixel(newValue);
      newImage.set_pixel(x, y, newPixel);
    }
    imgVector_.push_back(temp);
  }
  newImage.write("grayscale.png");
  grayImg_ = newImage;
  return true;
}

//==========================================================================
std::vector< std::vector<int> > ImageProcessor::applyConvolution(std::vector< std::vector<int> > imageVector, std::vector<float> kernel, int kernelWidth, int kernelHeight, std::string fileName)
{
  png::image< png::gray_pixel > newImage(grayImg_.get_width(), grayImg_.get_height());
  std::vector< std::vector<int> > resultImage;
  for (int x = 0; x < imageVector.size(); x++)
  {
    std::vector<int> row = imageVector.at(x);
    std::vector<int> temp;
    for (int y = 0; y < row.size(); y++)
    {
      int accumulator = 0;
      int kernelIndex = 0;
      for (int kernelRow = -((kernelWidth-1)/2); kernelRow <= (kernelWidth-1)/2; kernelRow++)
      {
        for (int kernelCol = -((kernelHeight-1)/2); kernelCol <= (kernelHeight-1)/2; kernelCol++)
        {
          int pixel;
          try
          {
            pixel = imageVector.at(x+kernelRow).at(y+kernelCol);
          }
          catch (...)
          {
            pixel = 0;
          }
          accumulator = accumulator + (pixel * kernel.at(kernelIndex));
          kernelIndex++;
        }
      }
      png::gray_pixel newPixel(accumulator);
      newImage.set_pixel(x, y, newPixel);
      temp.push_back(accumulator);
    }
    resultImage.push_back(temp);
  }
  newImage.write(fileName);
  return resultImage;
}

//==========================================================================
std::vector< std::vector<int> > ImageProcessor::applyGaussianFilter()
{
  std::vector<float> flatKernel{0.00390625, 0.015625, 0.0234375, 0.015625, 0.00390625,
                                0.015625, 0.0625, 0.09375, 0.0625, 0.015625,
                                0.0234375, 0.09375, 0.140625, 0.09375, 0.0234375,
                                0.015625, 0.0625, 0.09375, 0.0625, 0.015625,
                                0.00390625, 0.015625, 0.0234375, 0.015625, 0.00390625};
  int kernelWidth = 5;
  int kernelHeight = 5;
  blurredImgVector_ = applyConvolution(imgVector_, flatKernel, kernelWidth, kernelHeight, "blur.png");
  return blurredImgVector_;
}

//==========================================================================
std::vector< std::vector<int> > ImageProcessor::applyEdgeDetector()
{
  std::vector<float> flatKernel{-1, -2, -1, 0, 0, 0, 1, 2, 1};
  int kernelWidth = 3;
  int kernelHeight = 3;
  return applyConvolution(blurredImgVector_, flatKernel, kernelWidth, kernelHeight, "edge.png");
}