#include <cmath>
#include <opencv2/opencv.hpp>
using namespace cv;

#define LINE_WIDTH 5//px

void gammaCorrection(const Mat &img, Mat &out,double gamma)
{
  static Mat lookupTable(1, 256, CV_8U);
  static bool first = true;

  out = img.clone();

  for(int i = 0; i < 256 && first; i++)
    lookupTable.ptr()[i] = saturate_cast<uint8_t>(pow(i/255.0, gamma)*255);
  first = false;

  cv::LUT(img, lookupTable, out);
}

int main(int argc, char** argv){
  Mat img;
  Mat result;

  img = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
  if(!img.data)
  {
    std::cerr << "Erro ao carregar imagem!\n";
    return -1;
  }

  gammaCorrection(img, result, 0.05);

  imshow("Saida", img);
  waitKey(0);

  imshow("Saida", result);
  waitKey(0);

  //pinta faixas pretas com largura de LINE_WIDTH pixels
  //espaçadas de LINE_WIDTH
  for(int y = 0; y < img.rows; y++)
  for(int x = 0; x < img.cols; x++)
  {
    result.at<uint8_t>(y,x) = 0;
    if((x+1)%LINE_WIDTH == 0)x += LINE_WIDTH;
  }

  imshow("Saida", result);
  waitKey(0);

  imwrite("entradaEfeito.png", img);
  imwrite("resultadoEfeito.png", result);
  return 0;
}

#include <string>
#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{
  Mat img;
  Mat res;
  Mat mask;
  float kernel_media[] = {1, 1, 1,
                          1, 1, 1,
                          1, 1, 1};

  img = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
  if(!img.data)
  {
    std::cerr << "Erro ao carregar imagem\n";
    return -1;
  }

  mask = Mat(3,3, CV_32F, kernel_media)/9.0;
  //Aplica filtro de suavização, filtro de Media
  filter2D(img, res, -1, mask);

  imshow("Entrada", img);
  int key;
  string fileName;
  int count = 0;
  while(true)
  {
    //Salva cada imagem resultante para gerar o gif, com o comando convert -delay 150 tmp/* animation.gif
    fileName = string("tmp/a") + to_string(count++) + ".png";
    imwrite(fileName, res);

    filter2D(res, res, -1, mask);
    imshow("Saida", res);
    key = waitKey(0);
    if(key == 27)
      break;
  }
  imwrite("entradaSuavizacao.png",img);
  imwrite("resultadoSuavizacao.png",res);
  return 0;
}

#include <string>
#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

#define MEDIA_SIZE 10.0

void convFilter(const Mat &src,Mat &dest ,const Mat &mask);

int main(int argc, char** argv)
{
  Mat img, result, tmp;
  Mat blurImg, contourImg;
  Mat mask;
  float kernel_media[(int)(MEDIA_SIZE*MEDIA_SIZE)];
  float kernel_gaussian[] = {1, 2, 1,
                             2, 4, 2,
                             1, 2, 1};
  float kernel_laplaciano[] = {1, 1, 1,
                               1, -8, 1,
                               1, 1, 1};

  for(uint i = 0; i < (MEDIA_SIZE*MEDIA_SIZE); i++)
    kernel_media[i] = 1.0/(MEDIA_SIZE*MEDIA_SIZE);

  img = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
  if(!img.data)
  {
    std::cerr << "Erro ao carregar imagem\n";
    return -1;
  }

  //suavizacao gaussiana
  mask = Mat(3,3, CV_32F,kernel_gaussian)/16.0;
  convFilter(img, contourImg, mask);

  //realçar contornos
  mask = Mat(3,3, CV_32F,kernel_laplaciano);
  convFilter(contourImg, contourImg, mask);
  contourImg.convertTo(tmp, CV_8U, 255.0/2040.0, 127.0);

  /*Exibir e salvar imagem*/
  imshow("Contornos", tmp);
  imwrite("contorno.png", tmp);

  //Borramento
  mask = Mat(MEDIA_SIZE, MEDIA_SIZE, CV_32F,kernel_media);
  convFilter(img, blurImg, mask);
  blurImg.convertTo(tmp, CV_8U);

  /*Exibir e salvar imagem*/
  imshow("Borrada", tmp);
  imwrite("borrada.png", tmp);

  result = blurImg - contourImg;
  result.convertTo(result, CV_8U);

  //trecho apenas para exibir e salvar as imagens
  imshow("Entrada", img);
  imshow("Saida", result);
  imwrite("entradaSuavizacao2.png", img);
  imwrite("saidaSuavizacao2.png", result);

  waitKey(0);
  return 0;
}

void convFilter(const Mat &src,Mat &dest ,const Mat &mask)
{
  float sum;
  Mat src_f;

  src.convertTo(src_f, CV_32F);
  dest = Mat::zeros(src.size(), CV_32F);

  for(int y = mask.rows/2; y < (src.rows - mask.rows/2); y++)
  for(int x = mask.cols/2; x < (src.cols - mask.cols/2); x++)
  {
      sum = 0;
      for(int v = 0; v < mask.rows; v++)
      for(int u = 0; u < mask.cols; u++)
      {
        sum+= src_f.at<float>(y - mask.rows/2 + v,x - mask.cols/2 + u)*mask.at<float>(v,u);
      }
      dest.at<float>(y,x) = sum;
  }

}

#include <opencv2/opencv.hpp>
#include <string>
#include <cmath>

using namespace cv;
using namespace std;

#define I_MAX 255

float calcPSNR(const Mat &ref, const Mat &img);
void calcHistograma(const Mat &src, uint32_t histograma[]);
//Esta função cria uma imagem, contendo o plot do histograma
//com a dimensão de 256x200 px
void drawHistograma(const uint32_t histograma[], Mat &imgH);

int main(int argc, char** argv){
  Mat orig, imgH;
  String path("./primeiroConjunto/*.jpg");
  std::vector<String> fn;
  std::vector<Mat> imagens;
  uint32_t histograma[I_MAX+1];

  glob(path, fn, true);
  orig = imread(fn[0], CV_LOAD_IMAGE_GRAYSCALE);
  if(!orig.data)
  {
    std::cerr << "Erro ao carregar a imagem original" << '\n';
    return-1;
  }

  // carrega as N imagens
  for(size_t i = 0; i < fn.size(); i++)
  {
    Mat im = imread(fn[i], CV_LOAD_IMAGE_GRAYSCALE);
    if(!im.data)continue;//caso falhe na leitura, vai para o proximo arquivo
    imagens.push_back(im);

    calcHistograma(im, histograma);
    drawHistograma(histograma, imgH);
    imshow("imagem", im);
    imshow("Histograma", imgH);
    imwrite(string("imagem") + to_string(i) + string(".png"), im);
    imwrite(string("histograma") + to_string(i) + string(".png"), imgH);

    std::cout << "PSNR:"<< calcPSNR(imagens[0], im) << '\n';

    waitKey(0);
  }

  if(imagens.empty())
  {
    std::cerr << "Erro ao carrega as imagens de " << path << "\n";
    return -1;
  }

  return 0;
}

void calcHistograma(const Mat &src, uint32_t histograma[])
{
  memset(histograma, 0, (I_MAX+1)*sizeof(uint32_t) ); //zera todas as posições do vetor de freq.

  for(int y = 0; y < src.rows; y++)
    for(int x = 0; x < src.cols; x++)
      histograma[src.at<uint8_t>(y,x)]++;
}

uint32_t maxValue(const uint32_t v[], size_t size)
{
  uint32_t max = 0;
  for(size_t i = 0; i < size; i++)
    max = (v[i] > max)?v[i]:max;
  return max;
}

void drawHistograma(const uint32_t histograma[], Mat &imgH)
{
  imgH = Mat::zeros(200, 256, CV_8U);
  uint32_t freqMax = maxValue(histograma, I_MAX+1);

  for(uint32_t i = 0; i < I_MAX+1; i++)
  {
    line(imgH, Point(i, 200), Point(i, 200-histograma[i]*(200.0/freqMax)), 255);
  }
}

float calcPSNR(const Mat &ref, const Mat &img)
{
  float mse = 0;
  for(int y = 0; y < ref.rows; y++)
  for(int x = 0; x < ref.cols; x++)
  {
    mse += pow(img.at<uint8_t>(y,x) - ref.at<uint8_t>(y,x), 2.0);
  }
  mse = mse/(ref.cols*ref.rows);
  return 10.0*log10((float)(I_MAX*I_MAX)/mse);
}