#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <stdlib.h>     /* system, NULL, EXIT_FAILURE */

using namespace cv;
using namespace std;


Mat filter_tmp;
int percent_GamaL = 0;
int percent_GamaH = 2;
int percentD0 = 20;
int percent_C = 0;
float d_max;

void slot_sliders(int, void*);
void calcFilter(Mat& H, float gamaL, float gamaH, float D0, float c);
// troca os quadrantes da imagem da DFT
void deslocaDFT(Mat& image ){
  Mat tmp, A, B, C, D;

  // se a imagem tiver tamanho impar, recorta a regiao para
  // evitar cópias de tamanho desigual
  image = image(Rect(0, 0, image.cols & -2, image.rows & -2));
  int cx = image.cols/2;
  int cy = image.rows/2;

  // reorganiza os quadrantes da transformada
  // A B   ->  D C
  // C D       B A
  A = image(Rect(0, 0, cx, cy));
  B = image(Rect(cx, 0, cx, cy));
  C = image(Rect(0, cy, cx, cy));
  D = image(Rect(cx, cy, cx, cy));

  // A <-> D
  A.copyTo(tmp);  D.copyTo(A);  tmp.copyTo(D);

  // C <-> B
  C.copyTo(tmp);  B.copyTo(C);  tmp.copyTo(B);
}

int main(int argc, char**argv){
  const char mainWindow[] = "Filtro";
  const int max_slider = 100;
  Mat image;
  Mat padded, filter;
  Mat complexImage, complexImage_out;
  Mat_<float> realInput, zeros;
  int dft_M, dft_N;
  vector<Mat> planos;

  if(argc != 1){//usuario passou um argumento, vou entender como sendo um endereco de uma imagem
    image = imread(argv[1]);
    //converte para escala de cinza
    cvtColor(image, image, CV_BGR2GRAY);
    imshow("Entrada", image);
  }else{
    std::cerr << "Erro ao carregar imagem!" << '\n';
    return -1;
  }

  // identifica os tamanhos otimos para
  // calculo do FFT
  dft_M = getOptimalDFTSize(image.rows);
  dft_N = getOptimalDFTSize(image.cols);
  d_max = sqrt(dft_M*dft_M + dft_N*dft_N)/2.0;

  // realiza o padding da imagem
  copyMakeBorder(image, padded, 0,
                 dft_M - image.rows, 0,
                 dft_N - image.cols,
                 BORDER_CONSTANT, Scalar::all(0));

  // parte imaginaria da matriz complexa (preenchida com zeros)
  zeros = Mat_<float>::zeros(padded.size());
  // prepara a matriz complexa para ser preenchida
  complexImage = Mat(padded.size(), CV_32FC2, Scalar(0));

  // cria a componente real
  realInput = Mat_<float>(padded);
  realInput += cv::Scalar::all(1);
  cv::log(realInput, realInput);
  // combina o array de matrizes em uma unica
  // componente complexa
  Mat comps[] = {realInput, zeros};
  merge(comps, 2,  complexImage);
  // calcula o dft
  dft(complexImage, complexImage);
  // realiza a troca de quadrantes
  deslocaDFT(complexImage);
  normalize(complexImage, complexImage, 0, 1, CV_MINMAX);
  // a funcao de transferencia (filtro frequencial) deve ter o
  // mesmo tamanho e tipo da matriz complexa
  filter = complexImage.clone();

  // matriz das componentes real
  // e imaginaria do filtro
  filter_tmp = Mat(dft_M, dft_N, CV_32F);
  calcFilter(filter_tmp, percent_GamaL/100.0,
                        (percent_GamaH/100.0)*9+1,
                        (percentD0/100.0)*d_max,
                        (percent_C/100.0)*4+1);

  namedWindow(mainWindow, WINDOW_AUTOSIZE);

  createTrackbar( "Gama L [0-100%]", mainWindow,
                  &percent_GamaL,
                  max_slider,
                  slot_sliders);
  createTrackbar( "Gama H [0-100%]", mainWindow,
                  &percent_GamaH,
                  max_slider,
                  slot_sliders);
  createTrackbar( "D0 [0-100%]", mainWindow,
                  &percentD0,
                  max_slider,
                  slot_sliders);
  createTrackbar( "c [0-100%]", mainWindow,
                  &percent_C,
                  max_slider,
                  slot_sliders);

  complexImage_out = complexImage.clone();
  while(true){
    // cria a matriz com as componentes do filtro e junta
    // ambas em uma matriz multicanal complexa
    planos.clear();
    planos.push_back(filter_tmp);
    planos.push_back(filter_tmp);
    merge(planos, filter);

    // aplica o filtro frequencial
    mulSpectrums(complexImage, filter,complexImage_out,0);
    // troca novamente os quadrantes
    deslocaDFT(complexImage_out);
    // calcula a DFT inversa
    idft(complexImage_out, complexImage_out);
    // limpa o array de planos
    planos.clear();
    // separa as partes real e imaginaria da
    // imagem filtrada
    split(complexImage_out, planos);
    cv::exp(planos[0], planos[0]);
    planos[0] -= cv::Scalar::all(1);

    // normaliza a parte real para exibicao
    normalize(planos[0], planos[0], 0, 1, CV_MINMAX);

    imshow(mainWindow, filter_tmp);
    imshow("Resultado", planos[0]);
    waitKey(10);
  }

  return 0;
}

//cada slider eh mapeado de 0-100% em um range de valores
//fixos para cada uma das variaveis.
// (foi uma maneira simples que achei para controlar as variaveis com sliders de valores inteiros)
void slot_sliders(int, void*){
  calcFilter(filter_tmp, percent_GamaL/100.0,
                     (percent_GamaH/100.0)*8+2,
                     (percentD0/100.0)*d_max,
                     (percent_C/100.0)*4+1);
}

void calcFilter(Mat& H, float gamaL, float gamaH, float D0, float c){
  system("clear");
  std::cout << "Gama L:"<< gamaL << '\n';
  std::cout << "Gama H:"<< gamaH << '\n';
  std::cout << "D0:"<< D0 << '\n';
  std::cout << "C:"<< c << '\n';

  int N = H.size().width;
  int M = H.size().height;

  //Macro de calculo de distancia, com relacao ao ponto central da imagem
  #define D(u,v) sqrt( ((u)-M/2)*((u)-M/2) + ((v)-N/2)*((v)-N/2) )

  for(int u = 0; u < M; u++){
    for(int v = 0; v < N; v++){
        H.at<float>(u,v) = (gamaH - gamaL)*(1 - exp(-c*(D(u,v)*D(u,v))/(D0*D0))) + gamaL;
    }
  }
}

#include <iostream>
#include <opencv2/opencv.hpp>
#include <fstream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <numeric>
#include <ctime>
#include <cstdlib>

using namespace std;
using namespace cv;

#define STEP 7
#define JITTER 3
#define RAIO_MAX 2

//funcao que desenha circulos de raio deteminados
//nas bordas destacadas pelo algoritmo de canny
//usando T1 e T2 = 3*T1, como limites infeior e superior
//respectivamente
//Os circulos sao desenhados em ordem aleatoria, para evitar efeitos padronizados
//e as cores dos circulos sao versoes levemente diferentes das tonalidades originais
//para dar efeito de erro humano
void pontilhar(const Mat &imgIn, Mat &imgOut,uint raio, uint T1);

int main(int argc, char** argv){
  vector<int> yrange;
  vector<int> xrange;

  Mat image, points, canny_img;

  uint width, height;
  uint x, y;

  image= imread(argv[1]);
  imshow("original", image);

  srand(time(0));

  if(!image.data){
    cout << "nao abriu" << argv[1] << endl;
    exit(0);
  }

  width=image.size().width;
  height=image.size().height;

  xrange.resize(height/STEP);
  yrange.resize(width/STEP);

  iota(xrange.begin(), xrange.end(), 0);
  iota(yrange.begin(), yrange.end(), 0);

  for(uint i=0; i<xrange.size(); i++){
    xrange[i]= xrange[i]*STEP+STEP/2;
  }

  for(uint i=0; i<yrange.size(); i++){
    yrange[i]= yrange[i]*STEP+STEP/2;
  }

  points =  Mat(height, width, CV_8UC3, Scalar::all(255));

  random_shuffle(xrange.begin(), xrange.end());
  for(auto i : xrange){
    random_shuffle(yrange.begin(), yrange.end());
    for(auto j : yrange){
      x = i+rand()%(2*JITTER)-JITTER +1;
      y = j+rand()%(2*JITTER)-JITTER +1;

      Vec3b val = image.at<Vec3b>(x,y);
      if(x >= height || y >= width)val = Vec3b(255,255,255);

      circle(points,
             cv::Point(y,x),
             RAIO_MAX+(rand()%2),
             val,
             -1,
             CV_AA);
    }
  }

  //3 tipos de tracos sao aplicados aqui
  //a medida que o limite inferior eh menor, mais bordas sao detectadas
  //e essas bordas serao "pintadas" com "pinceis mais grossos"
  //e para as bordas de menor limiar, "pinceis mais finos" sao usados
  pontilhar(image, points, 3, 1);
  pontilhar(image, points, 2, 20);
  pontilhar(image, points, 1, 80);

  std::string nomeArq = std::string(argv[1]);
  nomeArq = "Pontilhismo_"+nomeArq;
  imwrite(nomeArq, points);
  std::cout << "Resultado salvo em: " << nomeArq << '\n';
  return 0;
}

void pontilhar(const Mat &imgIn, Mat &imgOut, uint raio, uint T1){
  std::vector<int> xrange(imgIn.rows);
  std::vector<int> yrange(imgIn.cols);
  cv::Mat canny_img;
  uint x, y;

  iota(xrange.begin(), xrange.end(), 0);
  iota(yrange.begin(), yrange.end(), 0);

  //Destacando as bordas com o filtro de Canny
  cvtColor(imgIn, canny_img, CV_BGR2GRAY);
  Canny(canny_img, canny_img, T1, 3*T1);

  random_shuffle(xrange.begin(), xrange.end());
  for(auto i : xrange){
    random_shuffle(yrange.begin(), yrange.end());
    for(auto j : yrange){
      if(canny_img.at<uint8_t>(i,j) == 255){
        x = i+rand()%(4*raio)-1.5*raio + 1;
        y = j+rand()%(4*raio)-1.5*raio + 1;
        circle(imgOut,
          cv::Point(y,x),
          raio,
          imgIn.at<Vec3b>(i,j)*(1+(rand()%3)/10.0),  //realiza pequenas mudanças nas tonalidades originais, para dar efeito de erro humano
          -1,
          CV_AA);
      }
    }
  }
}

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

using namespace cv;

int main( int argc, char** argv ){
  int nClusters = 10;
  Mat rotulos;
  int nRodadas = 10;
  Mat centros;
  Mat resultados[nRodadas];

  if(argc!=2)exit(0);

  Mat img = imread( argv[1], CV_LOAD_IMAGE_COLOR);

  Mat samples(img.rows * img.cols, 3, CV_32F);

  //preenche o vetor de amostras
  for( int y = 0; y < img.rows; y++ ){
    for( int x = 0; x < img.cols; x++ ){
      for( int z = 0; z < 3; z++){
        samples.at<float>(y + x*img.rows, z) = img.at<Vec3b>(y,x)[z];
	  }
	 }
  }

  //Realiza nRodadas de calculo de kmeans, cada uma, muito provavelmente, retornara
  //um valor diferente para cada media represntativa, pra cada uma das nClusters classes
  for(uint i = 0; i < nRodadas; i++)
  {
    kmeans(samples,
      nClusters,
      rotulos,
      TermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS, 10000, 0.0001),
      1,
      KMEANS_RANDOM_CENTERS,
      centros );

      Mat rotulada( img.size(), img.type() );
      for( int y = 0; y < img.rows; y++ ){
        for( int x = 0; x < img.cols; x++ ){
          int indice = rotulos.at<int>(y + x*img.rows,0);
          rotulada.at<Vec3b>(y,x)[0] = (uchar) centros.at<float>(indice, 0);
          rotulada.at<Vec3b>(y,x)[1] = (uchar) centros.at<float>(indice, 1);
          rotulada.at<Vec3b>(y,x)[2] = (uchar) centros.at<float>(indice, 2);
        }
      }
      //salva no vetor resultados, para posteriormente virarem um gif
      rotulada.copyTo(resultados[i]);
  }
  //salva cada iteraca em um arquivo png
  //para posteriormente virarem um gif
  //com a ferramenta imageMagick por meio do
  //do programa via terminal, convert.
  for(uint i = 0; i < nRodadas; i++)
    imwrite("rodada-"+std::to_string(i)+".png", resultados[i]);
}

#include <iostream>
#include <fstream>
#include <string>
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"

#include <system_tools.h>

using namespace cv;
using namespace std;

#define NUM_COLORS 3


struct RANGE{
  RANGE( ){
      inf = cv::Scalar(179, 255,255);
      sup = cv::Scalar(179, 255,255);
  }

  RANGE( cv::Scalar sInf, cv::Scalar sSup){
      inf = sInf;
      sup = sSup;
  }
  cv::Scalar inf;
  cv::Scalar sup;
};

static const cv::Vec3b PxLARANJA(0,127,255);
static const cv::Vec3b PxAZUL(255, 0, 0);
static const cv::Vec3b PxAMARELO(0,255,255);
static const cv::Vec3b PxVERDE(0,255,0);
static const cv::Vec3b PxMAGENTA(255, 0, 255);
static const cv::Vec3b PxCIANO(255,255, 0);
static const cv::Vec3b PxPRETO(0,0,0);
static const cv::Vec3b PxBRANCO(255,255,255);

static const cv::Vec3b COLORS[] = { PxLARANJA, PxAZUL, PxAMARELO, PxVERDE, PxMAGENTA, PxCIANO};

static const RANGE AZUL_range = RANGE( cv::Scalar(91, 233, 77),  cv::Scalar(165, 255, 200));
static const RANGE LARANJA_range = RANGE( cv::Scalar(0, 148, 61),  cv::Scalar(25, 255, 255));
static const RANGE AMARELO_range = RANGE( cv::Scalar(91, 233, 77),  cv::Scalar(165, 255, 200));

static  RANGE COLORS_RANGE[NUM_COLORS];

void readFile(){
  std::ifstream in("../calibracao.cal");
  int colorIndex;
  int Hmin,Smin,Vmin;
  int Hmax,Smax,Vmax;

  if(!in.is_open()){
    std::cerr << "Erro abrir arquivo de calibracao" << '\n';
    exit(1);
  }

  for(int c = 0; c < NUM_COLORS; c++)
  {
    in >> Hmin;
    in >> Smin;
    in >> Vmin;

    in >> Hmax;
    in >> Smax;
    in >> Vmax;

    COLORS_RANGE[c] = RANGE(cv::Scalar(Hmin, Smin, Vmin), cv::Scalar(Hmax, Smax, Vmax));
  }
  in.close();
};

 int main( int argc, char** argv )
 {
    VideoCapture cap(argc > 1 ? atoi(argv[1]) : 0);

    if ( !cap.isOpened() )  // if not success, exit program
    {
         cout << "Cannot open the web cam" << endl;
         return -1;
    }
    readFile();//carrega os limires de HSV estabelecidos no programa de calibracação

  Mat segment;
  double dt_process;
  double dt_BGR2HSV;

    while (true)
    {
      Mat imgOriginal;

       if (!cap.read(imgOriginal))
      {
           cout << "Erro na captura!" << endl;
           break;
      }

    dt_BGR2HSV = tools::clock();
    Mat imgHSV;
    cvtColor(imgOriginal, imgHSV, COLOR_BGR2HSV);
    dt_BGR2HSV = tools::clock() - dt_BGR2HSV;

    dt_process = tools::clock();
    for(uint color = 0; color < NUM_COLORS; color++){
      Mat imgThresholded;

      inRange(imgHSV, COLORS_RANGE[color].inf, COLORS_RANGE[color].sup, imgThresholded); //Threshold
      //operacao morfologia de abertura, para remover ruidos de formato
      erode(imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );
      dilate( imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );

      //filtro morfologico, fechamento (para preencher espacos vazios dos objetos)
      dilate(imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );
      erode(imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );

      if(color == 0)segment = imgThresholded.clone();
      else segment = segment + imgThresholded;

      //calcula dos momentos da imagem segmentada
      Moments oMoments = moments(imgThresholded);

      //uso dos momentos espacais para o calculo do centroide
      double dM01 = oMoments.m01; //momento em torno de x
      double dM10 = oMoments.m10; //momento em torno de y
      double dArea = oMoments.m00;//area
      dt_process = tools::clock() - dt_process;

      imshow(to_string(color),  imgThresholded);
      //considera apenas regioes com mais de 1000 pixels
      if (dArea > 1000)
      {
        //Calculo do Centro da regiao
        int posX = dM10 / dArea;
        int posY = dM01 / dArea;

        circle(imgOriginal,
          cv::Point(posX, posY),
          6,
          COLORS[color],  //realiza pequenas mudanças nas tonalidades originais, para dar efeito de erro humano
          -1,
          CV_AA);
        }
      }

    imshow("Thresholded Image", segment); //show the thresholded image
    imshow("Original", imgOriginal); //show the original image

    std::cout << "Tempo de Processsamento Total:" << dt_process + dt_BGR2HSV << 's' <<'\n';

    if (waitKey(30) == 27)//para sair com a tecla  ESC
    {
        cout << "Programa Finalizado" << endl;
        break;
    }
  }
     return 0;
  }