API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 19th, 2017
73
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.87 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #define _USE_MATH_DEFINES
  3.  
  4. #include <vector>
  5. #include <complex>
  6. #include <iostream>
  7. #include "CImg.h"
  8. #include <cmath>
  9.  
  10.  
  11. using namespace std;
  12. using namespace cimg_library;
  13.  
  14. CImg<double> horizontalFlip(CImg<double> image) {
  15.     for (int i = 0; i < image.width() / 2; i++) {
  16.         for (int j = 0; j < image.height(); j++) {
  17.             for (int z = 0; z < image.spectrum(); z++) {
  18.                 double temp = image(i, j, z);
  19.                 image(i, j, z) = image(image.width() - 1 - i, j, z);
  20.                 image(image.width() - 1 - i, j, z) = temp;
  21.             }
  22.         }
  23.     }
  24.     return image;
  25. }
  26.  
  27. CImg<double> verticalFlip(CImg<double> image) {
  28.     for (int i = 0; i < image.width(); i++) {
  29.         for (int j = 0; j < image.height() / 2; j++) {
  30.             for (int z = 0; z < image.spectrum(); z++) {
  31.                 double temp = image(i, j, z);
  32.                 image(i, j, z) = image(i, image.height() - j - 1, z);
  33.                 image(i, image.height() - j - 1, z) = temp;
  34.             }
  35.         }
  36.     }
  37.     return image;
  38. }
  39.  
  40. CImg<double> diagonalFlip(CImg<double> image) {
  41.     image = horizontalFlip(image);
  42.     image = verticalFlip(image);
  43.     return image;
  44. }
  45.  
  46.  
  47.  
  48. // ----------------------------------------------------------------------------------------------------
  49. // task 4
  50.  
  51. // ==============================================================================================================================
  52. // fast
  53.  
  54. void normalization(vector< complex<double> > &c)
  55. {
  56.     for (auto i = c.begin(); i < c.end(); ++i)
  57.     {
  58.         (*i) /= sqrt(c.size());
  59.     }
  60. }
  61.  
  62. //void fourierShift(vector< complex<double> >&c)
  63. //{
  64. //  const complex<double> I = (0, 1);
  65. //  double n = c.size();
  66. //  for (int k = 0; k < n; ++k)
  67. //  {
  68. //      c[k] = c[k] * exp( M_PI * I * (k / n));
  69. //  }
  70. //}
  71. void fft1d(vector< complex<double> > &input, bool inverse)
  72. {
  73.     const int N = input.size();
  74.     const complex<double> I = (0.0, 1.0);
  75.     if (N == 1) return;
  76.     else {
  77.  
  78.         vector< complex<double> > left, right, temp1, temp2, temp3;
  79.  
  80.         for (int i = 0; i < (N / 2); ++i)
  81.         {
  82.             left.push_back(input[i]);
  83.             right.push_back((input[N / 2 + i]));
  84.         }
  85.         for (int n = 0; n < N / 2; ++n)
  86.         {
  87.             temp1.push_back(left[n] + right[n]);
  88.             temp2.push_back(left[n] - right[n]);
  89.         }
  90.         for (int n = 0; n < N / 2; n++) {
  91.             //double angle = 0;
  92.             //angle = -2 * M_PI*n / N;
  93.             double angle = (inverse ? 2 * M_PI * n * 1 / N : -2 * M_PI * n * 1 / N);
  94.             double real = cos(angle);
  95.             double imaginary = sin(angle);
  96.             complex<double> W(real, imaginary);
  97.             temp2[n] *= W;
  98.         }
  99.         fft1d(temp1, inverse);
  100.         fft1d(temp2, inverse);
  101.         int j = 0;
  102.         for (int k = 0; k<N / 2; ++k)
  103.         {
  104.             input[j] = temp1[k];
  105.             input[j + 1] = temp2[k];
  106.             j += 2;
  107.         }
  108.     }
  109. }
  110. //vector< complex<double> > fft(vector< complex<double> > input, bool inverse) {
  111. //  const int N = input.size();
  112. //  if (N == 1) return input;
  113. //  else {
  114. //      vector< complex<double> > even, odd;
  115. //      for (int i = 0; i < (N / 2); i++) {
  116. //          even.push_back(input[2 * i]);
  117. //          odd.push_back((input[(2 * i) + 1]));
  118. //      }
  119. //      even = fft(even, inverse);
  120. //      odd = fft(odd, inverse);
  121. //
  122. //      for (int n = 0; n < N / 2; n++) {
  123. //          double angle = 0;
  124. //          if (inverse == false) {
  125. //              angle = -2 * M_PI*n / N;
  126. //          }
  127. //          else {
  128. //              angle = 2 * M_PI*n / N;
  129. //          }
  130. //          double real = cos(angle);
  131. //          double imaginary = sin(angle);
  132. //          complex<double> W(real, imaginary);
  133. //          input[n] = even[n] + W*odd[n];
  134. //          input[(N / 2) + n] = even[n] - W*odd[n];
  135. //      }
  136. //      return input;
  137. //  }
  138. //}
  139.  
  140. // ==============================================================================================================================
  141. // slow
  142. vector< complex<double> > dft(vector< complex<double> > input, bool inverse) {
  143.     vector< complex<double> > result;
  144.     const int N = input.size();
  145.     for (int n = 0; n < N; n++) {
  146.         complex<double> sum(0.0, 0.0);
  147.         for (int k = 0; k < N; k++) {
  148.             double angle = 0;
  149.             if (inverse == false) {
  150.                 angle = -2 * M_PI*k*n / N;
  151.             }
  152.             else {
  153.                 angle = 2 * M_PI*k*n / N;
  154.             }
  155.             double tempReal = cos(angle);
  156.             double tempImaginary = sin(angle);
  157.             complex<double> factor(tempReal, tempImaginary);
  158.             sum += input[k] * factor;
  159.         }
  160.         result.push_back(sum);
  161.     }
  162.     return result;
  163. }
  164.  
  165. // ==============================================================================================================================
  166.  
  167. vector<vector<complex<double> > > fourierTransformTwoDimensional(vector<vector<complex<double> > > input, CImg<double>&image, bool useFastAlgorithm, bool inverse) {
  168.     vector<vector<complex<double> > > matrix1, matrix2;
  169.     int k = 0;
  170.     for (int i = 0; i < image.height(); i++) {
  171.         vector<complex<double> > row;
  172.         for (int j = 0; j < image.width(); j++) {
  173.             row.push_back(input[j][i]);
  174.         }
  175.         if (useFastAlgorithm) {
  176.             fft1d(row, false);
  177.             normalization(row);
  178.         }
  179.         else {
  180.             fft1d(row, false);
  181.         }
  182.         matrix1.push_back(row);
  183.     }
  184.  
  185.     for (int j = 0; j < image.width(); j++) {
  186.         vector<complex<double> > column;
  187.         for (int i = 0; i < image.height(); i++) {
  188.             column.push_back(matrix1[i][j]);
  189.         }
  190.         if (useFastAlgorithm) {
  191.             fft1d(column, true);
  192.             normalization(column);
  193.         }
  194.         else {
  195.             fft1d(column, true);
  196.         }
  197.         matrix2.push_back(column);
  198.     }
  199.  
  200.     return matrix2;
  201. }
  202.  
  203. // ==============================================================================================================================
  204. // FUNKCJE DO RYSOWANIA I OBLICZANIA
  205.  
  206. void calculateMagnitude(vector<vector<complex<double> > >* input, CImg<double>&image) {
  207.     double realPart, imaginaryPart;
  208.     complex<double> temp;
  209.     for (int j = 0; j < image.width(); j++) {
  210.         for (int i = 0; i < image.height(); i++) {
  211.             temp = input->at(j).at(i);
  212.             realPart = temp.real();
  213.             imaginaryPart = temp.imag();
  214.             input->at(j).at(i) = complex<double>(sqrt(realPart*realPart + imaginaryPart*imaginaryPart), imaginaryPart);
  215.         }
  216.     }
  217. }
  218.  
  219. void moveDCtoCenter(vector<vector<complex<double> > >* input) {
  220.     const int N = input->size();
  221.     complex<double> temp;
  222.     for (int i = 0; i < N / 2; i++) {
  223.         for (int j = 0; j < N / 2; j++) {
  224.             temp = input->at(i).at(j);
  225.             input->at(i).at(j) = input->at(i + N / 2).at(j + N / 2);
  226.             input->at(i + N / 2).at(j + N / 2) = temp;
  227.             temp = input->at(i + N / 2).at(j);
  228.             input->at(i + N / 2).at(j) = input->at(i).at(j + N / 2);
  229.             input->at(i).at(j + N / 2) = temp;
  230.         }
  231.     }
  232. }
  233.  
  234. void logVector(vector<vector<complex<double> > >* input) {
  235.     const int N = input->size();
  236.     double logReal, logImag;
  237.     for (int j = 0; j < N; j++) {
  238.         for (int i = 0; i < N; i++) {
  239.             logReal = abs(input->at(j).at(i).real());
  240.             logImag = abs(input->at(j).at(i).imag());
  241.             if (logReal != 0) logReal = log(logReal);
  242.             if (logImag != 0) logImag = log(logImag);
  243.             input->at(j).at(i) = complex<double>(logReal, logImag);
  244.         }
  245.     }
  246. }
  247.  
  248. void scaleAndDraw(vector<vector<complex<double> > >* input, CImg<double>&image, CImg<double>* newWindow) {
  249.     double real = 0, imaginary = 0, scaleReal = 1, scaleImag = 0, maxReal = 0, maxImag = 0;
  250.     const int N = input->size();
  251.     for (int j = 0; j < N; j++) {
  252.         for (int i = 0; i < N; i++) {
  253.             real = input->at(j).at(i).real();
  254.             imaginary = input->at(j).at(i).imag();
  255.             if (real > maxReal) {
  256.                 maxReal = real;
  257.             }
  258.             if (imaginary > maxImag) {
  259.                 maxImag = imaginary;
  260.             }
  261.         }
  262.     }
  263.     scaleReal = 255 / maxReal;
  264.     scaleImag = 255 / maxImag;
  265.     double value = 0;
  266.     complex<double> temp;
  267.     for (int j = 0; j < image.width(); j++) {
  268.         for (int i = 0; i < image.height(); i++) {
  269.             temp = input->at(j).at(i);
  270.             real = scaleReal*temp.real();
  271.             imaginary = scaleImag*temp.imag();
  272.             if (real > 255) {
  273.                 real = 255;
  274.             }
  275.             else if (real < 0) {
  276.                 real = 0;
  277.             }
  278.             newWindow->atXYZC(j, i, 0, 0) = newWindow->atXYZC(j, i, 0, 1) = newWindow->atXYZC(j, i, 0, 2) = real;
  279.         }
  280.     }
  281. }
  282.  
  283. void CImgToVector(CImg<double> &image, vector<vector<complex<double> > >* imageVector) {
  284.     vector<complex<double> > row;
  285.     for (int i = 0; i < image.height(); i++) {
  286.         for (int j = 0; j < image.width(); j++) {
  287.             row.push_back(complex<double>(image._atXYZC(i, j, 0, 0)*1.0, 0.0));
  288.         }
  289.         imageVector->push_back(row);
  290.         row.clear();
  291.     }
  292. }
  293.  
  294. // ==============================================================================================================================
  295. // FOURIER
  296.  
  297. CImg<double> fourier(CImg<double> &image, bool useFastAlgorithm) {
  298.     CImg<double> image_output(image.width(), image.height(), image.depth(), image.spectrum());
  299.     CImg<double> spectrum(image.width(), image.height(), image.depth(), image.spectrum());
  300.     vector<vector<complex<double> > > img, imageSpectrum;
  301.     CImgToVector(image, &img);
  302.     imageSpectrum = fourierTransformTwoDimensional(img, image, useFastAlgorithm, false);
  303.     moveDCtoCenter(&imageSpectrum);
  304.     calculateMagnitude(&imageSpectrum, image);
  305.     logVector(&imageSpectrum);
  306.     scaleAndDraw(&imageSpectrum, image, &spectrum);
  307.  
  308.     return spectrum;
  309. }
  310.  
  311. // ==============================================================================================================================
  312. // LOW PASS FILTER  -  HIGH CUT FILTER
  313.  
  314. CImg<double> lowPass(CImg<double> &image, int radius) {
  315.     CImg<double> image_output(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  316.     CImg<double> spectrum(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  317.     vector<vector<complex<double> > > img;
  318.     vector<vector<complex<double> > > imageSpectrum;
  319.     CImgToVector(image, &img);
  320.     imageSpectrum = fourierTransformTwoDimensional(img, image, true, false);
  321.     moveDCtoCenter(&imageSpectrum);
  322.     double distance;
  323.     for (int j = 0; j<image.width(); j++) {
  324.         for (int i = 0; i<image.height(); i++) {
  325.             for (int k = 0; k<image.spectrum(); k++) {
  326.                 double temp1 = (j - image.width() / 2)*(j - image.width() / 2);
  327.                 double temp2 = (i - image.height() / 2)*(i - image.height() / 2);
  328.                 distance = sqrt(temp1 + temp2);
  329.                 if (distance <= radius) {}
  330.                 else
  331.                     imageSpectrum[j][i] = 0.0;
  332.             }
  333.         }
  334.     }
  335.     moveDCtoCenter(&imageSpectrum);
  336.     img = fourierTransformTwoDimensional(imageSpectrum, image, true, true);
  337.     scaleAndDraw(&img, image, &image_output);
  338.     return image_output;
  339. }
  340.  
  341. // ==============================================================================================================================
  342. // HIGH PASS FILTER - LOW CUT FILTER
  343.  
  344. CImg<double> highPass(CImg<double> &image, int radius) {
  345.     CImg<double> image_output(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  346.     CImg<double> spectrum(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  347.     vector<vector<complex<double> > > img;
  348.     vector<vector<complex<double> > > imageSpectrum;
  349.     CImgToVector(image, &img);
  350.     imageSpectrum = fourierTransformTwoDimensional(img, image, true, false);
  351.     moveDCtoCenter(&imageSpectrum);
  352.     complex<double> dcComponent = imageSpectrum[image.height() / 2][image.width() / 2];
  353.     double distance;
  354.     for (int j = 0; j<image.width(); j++) {
  355.         for (int i = 0; i<image.height(); i++) {
  356.             for (int k = 0; k<image.spectrum(); k++) {
  357.                 double temp1 = (j - image.width() / 2)*(j - image.width() / 2);
  358.                 double temp2 = (i - image.height() / 2)*(i - image.height() / 2);
  359.                 distance = sqrt(temp1 + temp2);
  360.                 if (distance <= radius) {
  361.                     imageSpectrum[j][i] = 0.0;
  362.                 }
  363.             }
  364.         }
  365.     }
  366.     imageSpectrum[image.height() / 2][image.width() / 2] = dcComponent;
  367.     moveDCtoCenter(&imageSpectrum);
  368.     img = fourierTransformTwoDimensional(imageSpectrum, image, true, true);
  369.     scaleAndDraw(&img, image, &image_output);
  370.     return image_output;
  371. }
  372.  
  373. // ==============================================================================================================================
  374. // BAND PASS FILTER
  375.  
  376. CImg<double> bandPass(CImg<double>&image, int min, int max) {
  377.     CImg<double> image_output(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  378.     CImg<double> spectrum(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  379.     vector<vector<complex<double> > > img;
  380.     vector<vector<complex<double> > > imageSpectrum;
  381.     CImgToVector(image, &img);
  382.     imageSpectrum = fourierTransformTwoDimensional(img, image, true, false);
  383.     moveDCtoCenter(&imageSpectrum);
  384.     // dc component
  385.     complex<double> dcComponent = imageSpectrum[image.height() / 2][image.width() / 2];
  386.     double distance;
  387.     for (int j = 0; j<image.width(); j++) {
  388.         for (int i = 0; i<image.height(); i++) {
  389.             for (int k = 0; k<image.spectrum(); k++) {
  390.                 double temp1 = (j - image.width() / 2)*(j - image.width() / 2);
  391.                 double temp2 = (i - image.height() / 2)*(i - image.height() / 2);
  392.                 distance = sqrt(temp1 + temp2);
  393.                 if ((distance < min) || (distance > max))
  394.                     imageSpectrum[j][i] = 0;
  395.             }
  396.         }
  397.     }
  398.     imageSpectrum[image.height() / 2][image.width() / 2] = dcComponent;
  399.     moveDCtoCenter(&imageSpectrum);
  400.     img = fourierTransformTwoDimensional(imageSpectrum, image, true, true);
  401.     scaleAndDraw(&img, image, &image_output);
  402.     return image_output;
  403. }
  404.  
  405. // ==============================================================================================================================
  406. // BAND CUT FILTER
  407.  
  408. CImg<double> bandCut(CImg<double>&image, int min, int max) {
  409.     CImg<double> image_output(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  410.     CImg<double> spectrum(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  411.     vector<vector<complex<double> > > img, imageSpectrum;
  412.     CImgToVector(image, &img);
  413.     imageSpectrum = fourierTransformTwoDimensional(img, image, true, false);
  414.     moveDCtoCenter(&imageSpectrum);
  415.     complex<double> dcComponent = imageSpectrum[image.height() / 2][image.width() / 2];
  416.     double distance;
  417.     for (int j = 0; j<image.width(); j++) {
  418.         for (int i = 0; i<image.height(); i++) {
  419.             for (int k = 0; k<image.spectrum(); k++) {
  420.                 double temp1 = (j - image.width() / 2)*(j - image.width() / 2);
  421.                 double temp2 = (i - image.height() / 2)*(i - image.height() / 2);
  422.                 distance = sqrt(temp1 + temp2);
  423.                 if ((distance > min) && (distance < max))
  424.                     imageSpectrum[j][i] = 0;
  425.             }
  426.         }
  427.     }
  428.     imageSpectrum[image.height() / 2][image.width() / 2] = dcComponent;
  429.     moveDCtoCenter(&imageSpectrum);
  430.     img = fourierTransformTwoDimensional(imageSpectrum, image, true, true);
  431.     scaleAndDraw(&img, image, &image_output);
  432.     return image_output;
  433. }
  434.  
  435. // ==============================================================================================================================
  436. // HIGH PASS FILTER WITH DETECTION OF EDGE DIRECTIONS
  437.  
  438. CImg<double> highPassWithEdgeDetection(CImg<double> &image, CImg<double>&mask) {
  439.     CImg<double> image_output(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  440.     CImg<double>hpfmask(image.width(), image.height(), 1, 3, 1);
  441.     CImg<double> spectrum(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  442.     vector<vector<complex<double> > > img;
  443.     vector<vector<complex<double> > > imageSpectrum;
  444.     CImgToVector(image, &img);
  445.     imageSpectrum = fourierTransformTwoDimensional(img, image, true, false);
  446.     moveDCtoCenter(&imageSpectrum);
  447.     complex<double> dcComponent = imageSpectrum[image.height() / 2][image.width() / 2];
  448.     for (int i = 0; i<image.width(); i++) {
  449.         for (int j = 0; j<image.height(); j++) {
  450.             for (int k = 0; k<image.spectrum(); k++) {
  451.                 if (mask(i,j,k) == 0)
  452.                     imageSpectrum[i][j] = 0;
  453.             }
  454.         }
  455.     }
  456.     imageSpectrum[image.height() / 2][image.width() / 2] = dcComponent;
  457.     moveDCtoCenter(&imageSpectrum);
  458.     img = fourierTransformTwoDimensional(imageSpectrum, image, true, true);
  459.     scaleAndDraw(&img, image, &image_output);
  460.  
  461.     return image_output;
  462. }
  463.  
  464. // ==============================================================================================================================
  465. // PHASE MODYFING FILTER
  466.  
  467. vector<vector<complex<double> > > phase(vector<vector<complex<double> > >  input, CImg<double> &image, int x, int y) {
  468.     for (int j = 0; j<image.width(); j++) {
  469.         for (int i = 0; i<image.height(); i++) {
  470.             input[i][j] = complex<double>(cos(((-i*x * 2 * M_PI) / (image.height())) + ((-j*y * 2 * M_PI) / (image.width())) + ((x + y)*M_PI)),
  471.                 sin(((-i*x * 2 * M_PI) / (image.height())) + ((-j*y * 2 * M_PI) / (image.width())) + ((x + y)*M_PI)));
  472.         }
  473.     }
  474.  
  475.     return input;
  476. }
  477.  
  478. CImg<double> phaseFilter(CImg<double> &image, int x, int y) {
  479.     CImg<double> image_output(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  480.     CImg<double> spectrum(image.width(), image.height(), image.depth(), image.spectrum(), 255);
  481.     vector<vector<complex<double> > > img, imageSpectrum, mask;
  482.     complex<double> number1, number2;
  483.     double number1X, number2X, number1Y, number2Y;
  484.     double realSum, imaginarySum;
  485.     CImgToVector(image, &img);
  486.     imageSpectrum = fourierTransformTwoDimensional(img, image, true, false);
  487.     mask = phase(img, image, x, y);
  488.     for (int j = 0; j<image.width(); j++) {
  489.         for (int i = 0; i<image.height(); i++) {
  490.             number1 = imageSpectrum[i][j];
  491.             number2 = mask[i][j];
  492.             number1X = number1.real();
  493.             number1Y = number1.imag();
  494.             number2X = number2.real();
  495.             number2Y = number2.imag();
  496.             realSum = (number1X*number2X) - (number1Y*number2Y);
  497.             imaginarySum = (number1Y*number2X) + (number1X*number2Y);
  498.             imageSpectrum[i][j] = complex<double>(realSum, imaginarySum);
  499.         }
  500.     }
  501.     img = fourierTransformTwoDimensional(imageSpectrum, image, true, true);
  502.     scaleAndDraw(&img, image, &image_output);
  503.  
  504.     return image_output;
  505. }
  506.  
  507. // ==============================================================================================================================
  508.  
  509. void save_img(CImg<double> image) {
  510.     string nameOfSavedFile;
  511.     cout << "Input the name of the saved image: ";
  512.     cin >> nameOfSavedFile;
  513.     image.save_bmp(nameOfSavedFile.c_str());
  514.     return;
  515. }
  516.  
  517. void help() {
  518.     cout << "-fft" << endl;
  519.  
  520.     cout << "-lowpass parameter" << endl;
  521.     cout << "-hightpass parameter" << endl;
  522.     cout << "-bandpass parameter1 parameter2" << endl;
  523.     cout << "-bandcut parameter1 parameter2" << endl;
  524.     cout << "-edgedet image masc" << endl;
  525.     cout << "-phase parameter1 parameter2" << endl;
  526. }
  527.  
  528. // ==============================================================================================================================
  529. // MENU
  530.  
  531. int main(int argc, char**argv) {
  532.  
  533.     if (argc < 2) {
  534.         cout << "Too few argumnets!!" << endl;
  535.         cout << "Check -help" << endl;
  536.     }
  537.     else if (argc == 2) {
  538.         string decision = argv[1];
  539.         if (decision == "-help") help();
  540.         else { help(); }
  541.     }
  542.     else if (argc > 2) {
  543.         CImg<double> image(argv[1]);
  544.         string decision = argv[2];
  545.  
  546.         if (decision == "-fft") {
  547.             CImg<double> newimage = fourier(image, true);
  548.             save_img(newimage);
  549.         }
  550.  
  551.         // -------------------------------------------------
  552.         // FILTERS
  553.         if (decision == "-lowpass") {
  554.             int parameter = atoi(argv[3]);
  555.             CImg<double> newimage = lowPass(image, parameter);
  556.             CImg<double> newimage2 = diagonalFlip(newimage);
  557.             save_img(newimage2);
  558.         }
  559.         else if (decision == "-highpass") {
  560.             int parameter = atoi(argv[3]);
  561.             CImg<double> newimage = highPass(image, parameter);
  562.             CImg<double> newimage2 = diagonalFlip(newimage);
  563.             save_img(newimage2);
  564.         }
  565.  
  566.         else if (decision == "-bandpass") {
  567.             int parameter1 = atoi(argv[3]);
  568.             int parameter2 = atoi(argv[4]);
  569.             CImg<double> newimage = bandPass(image, parameter1, parameter2);
  570.             CImg<double> newimage2 = diagonalFlip(newimage);
  571.             save_img(newimage2);
  572.         }
  573.         else if (decision == "-bandcut") {
  574.             int parameter1 = atoi(argv[3]);
  575.             int parameter2 = atoi(argv[4]);
  576.             CImg<double> newimage = bandCut(image, parameter1, parameter2);
  577.             diagonalFlip(newimage);
  578.             CImg<double> newimage2 = diagonalFlip(newimage);
  579.             save_img(newimage2);
  580.         }
  581.         else if (decision == "-edgedet") {
  582.             CImg<double> image2(argv[3]);
  583.             CImg<double> newimage = highPassWithEdgeDetection(image, image2);
  584.             save_img(newimage);
  585.         }
  586.         else if (decision == "-phase") {
  587.             int parameter1 = atoi(argv[3]);
  588.             int parameter2 = atoi(argv[4]);
  589.             CImg<double> newimage = phaseFilter(image, parameter1, parameter2);
  590.             CImg<double> newimage2 = diagonalFlip(newimage);
  591.             save_img(newimage2);
  592.         }
  593.         // -------------------------------------------------
  594.  
  595.         else {
  596.             cout << endl;
  597.         }
  598.         return 0;
  599.     }
  600.     else {
  601.         cout << "Sorry,something went wrong,check -help" << endl;
  602.     }
  603.     return 0;
  604. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!