int main(int argc, char **argv) {
int commandArgs = 1;
int i;
char x;
char performContrast = 0;
char fft_filename[FILENAME_LENGTH];
char cdf_filename[FILENAME_LENGTH];
char histo_filename[FILENAME_LENGTH];
float contrastLow = 0.0;
float contrastHigh = 0.0;
float highpasslevel;
float lowpasslevel;
float percentCorrupt;
float sigma;
float brightness;
float sat;
int m;
int replaceWithM;
int performHistogram = 0;
int performCDF = 0;
int performFFT = 0;
int performVectorMedianFilter = 0;
int performMedianFilter = 0;
int performMeanFilter = 0;
int performSpacialFilter = 0;
int performLevelSlicing = 0;
int performEqualize = 0;
int performColorScale = 0;
int performSpatialReduceWidth = 0;
int performSpatialReduceHeigth = 0;
int performHighpass = 0;
int performLowpass = 0;
int performComponentMedianFilter = 0;
int performVectorOrderStatistic = 0;
int performVectorSpacialOrderStatistic = 0;
int performVectorMedianOrderStatistic = 0;
int performMinkowskiAddition = 0;
int performMinkowskiSubtraction = 0;
int performMinkowskiOpening = 0;
int performMinkowskiClosing = 0;
int performEdgeDetectOne = 0;
int performEdgeDetectTwo = 0;
int performEdgeDetectThree = 0;
int performEdgeDetectFour = 0;
int performAddGaussianNoise = 0;
int performAddSaltPepperNoise = 0;
int performSetBrightness = 0;
int performSetSaturation = 0;
int performBrightFilter = 0;
int imageWriteNecessary = 0;
int maskwidth = 0;
int maskheight = 0;
int maskrepeat = 0;
FILE *in = stdin;
FILE *out = stdout;
struct portImage *pi;
if (argc < 3) {
printf("\n");
printf(" Usage: %s [inputFile] ([outputFile]) [option] ([option] ...)\n", argv[0]);
printf("\n");
printf(" InputFile: Either a filename or '-' for stdin.\n");
printf(" OutputFile: Either a filename or '-' for stdout. (Not needed if no output necessary.)\n");
printf("\n");
printf(" Options:\n");
printf(" -ghisto FILENAME Graph Histogram\n");
printf(" -gcdf FILENAME Graph Cumulative Distribution\n");
printf(" -gfft FILENAME Graph FFT plot\n");
printf(" -color n Reduce color scale to n\n");
printf(" -spatial WIDTH-HEIGHT Perform spacial reduction to Width and Height\n");
printf(" -level n Perform level slicing from graylevel n to graylevel n+10\n");
printf(" -con LOW-HIGH Scale image contrast from LOW graylevel percentage to HIGH graylevel percentage\n");
printf(" -equ Histogram Eqaulization\n");
printf(" -medianf n Simple Median Filter of window size n*n\n");
printf(" -meanf n Simple Mean Filter of window size n*n\n");
printf(" -cmf n Component Median Filter of window size n*n\n");
printf(" -vmf n Vector Median Filter of window n*n\n");
printf(" -sf Spacial Filter\n");
printf(" -vos n v Vector Order Stat of window size n*n and value v\n");
printf(" -vmos n m [01] Vector Median Order Stat of window size n*n, m threshold, and 0 or 1(True) replace with m\n");
printf(" -vsos n m [01] Vector Spacial Order Stat of window size n*n, m threshold, and 0 or 1(True) replace with m\n");
printf(" -brightf n Perform an Brightness filter using HSV colorspace on size n*n window.\n");
printf(" -bright %% Set brightness to %% percent\n");
printf(" -sat %% Set saturation to %% percent\n");
printf(" -hp %% Highpass filter of %% percent\n");
printf(" -lp %% Lowpass filter of %% percent\n");
printf(" -ma NxM R Perform Minkowski Addition using NxM mask, repeated R times.\n");
printf(" -ms NxM R Perform Minkowski Subtraction using NxM mask, repeated R times.\n");
printf(" -mo NxM R Perform Minkowski Opening using NxM mask, repeated R times.\n");
printf(" -mc NxM R Perform Minkowski Closing using NxM mask, repeated R times.\n");
printf(" -e1 Perform Edge Detection using X/(X – B)\n");
printf(" -e2 Perform Edge Detection using (X + B)/X\n");
printf(" -e3 Perform Edge Detection using [(X+B)/(X-B)]-B\n");
printf(" -e4 n Experimental Edge Detection on Color Images using n*n window.\n");
printf(" -noiseG p s Add Gaussian noise to p (0 to 1 floating) percent of image with s sigma noise.\n");
printf(" -noiseSP p Add Salt and Pepper noise to p (0 to 1 floating) percent of image.\n");
printf("\n");
return(1);
}
if (strcmp(argv[commandArgs], "-") != 0) {
in = fopen(argv[1],"r");
if (in == NULL) {
fprintf(stderr, "File '%s' failed to open for reading.\n", argv[1]);
exit(1);
}
}
commandArgs++;
if (strcmp(argv[commandArgs], "-") != 0 && argv[commandArgs][0] != '-') {
commandArgs++;
out = fopen(argv[2],"w");
if (out == NULL) {
fprintf(stderr, "File '%s' failed to open for writing.\n", argv[2]);
exit(1);
}
}
for (; commandArgs < argc; commandArgs++) {
if (strcmp(argv[commandArgs], "-color") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performColorScale);
}
if (strcmp(argv[commandArgs], "-spatial") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &performSpatialReduceWidth, &x, &performSpatialReduceHeigth);
}
if (strcmp(argv[commandArgs], "-level") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performLevelSlicing);
}
if (strcmp(argv[commandArgs], "-con") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%f%c%f", &contrastLow, &performContrast, &contrastHigh);
}
if (strcmp(argv[commandArgs], "-vos") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorOrderStatistic);
commandArgs++;
sscanf(argv[commandArgs], "%d", &m);
}
if (strcmp(argv[commandArgs], "-vmf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorMedianFilter);
}
if (strcmp(argv[commandArgs], "-sf") == 0) {
imageWriteNecessary = 1;
performSpacialFilter = 1;
}
if (strcmp(argv[commandArgs], "-vmos") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorMedianOrderStatistic);
commandArgs++;
sscanf(argv[commandArgs], "%d", &m);
commandArgs++;
sscanf(argv[commandArgs], "%d", &replaceWithM);
}
if (strcmp(argv[commandArgs], "-vsos") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performVectorSpacialOrderStatistic);
commandArgs++;
sscanf(argv[commandArgs], "%d", &m);
commandArgs++;
sscanf(argv[commandArgs], "%d", &replaceWithM);
}
if (strcmp(argv[commandArgs], "-cmf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performComponentMedianFilter);
}
if (strcmp(argv[commandArgs], "-medianf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performMedianFilter);
}
if (strcmp(argv[commandArgs], "-meanf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performMeanFilter);
}
if (strcmp(argv[commandArgs], "-equ") == 0) {
imageWriteNecessary = 1;
performEqualize = 1;
}
if (strcmp(argv[commandArgs], "-hp") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performHighpass = 1;
sscanf(argv[commandArgs], "%f", &highpasslevel);
}
if (strcmp(argv[commandArgs], "-lp") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performLowpass = 1;
sscanf(argv[commandArgs], "%f", &lowpasslevel);
}
if (strcmp(argv[commandArgs], "-brightf") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performBrightFilter);
}
if (strcmp(argv[commandArgs], "-bright") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performSetBrightness = 1;
sscanf(argv[commandArgs], "%f", &brightness);
}
if (strcmp(argv[commandArgs], "-sat") == 0) {
imageWriteNecessary = 1;
commandArgs++;
performSetSaturation = 1;
sscanf(argv[commandArgs], "%f", &sat);
}
if (strcmp(argv[commandArgs], "-ghisto") == 0) {
commandArgs++;
performHistogram = 1;
strncpy(histo_filename, argv[commandArgs], FILENAME_LENGTH);
}
if (strcmp(argv[commandArgs], "-gcdf") == 0) {
commandArgs++;
performCDF = 1;
strncpy(cdf_filename, argv[commandArgs], FILENAME_LENGTH);
}
if (strcmp(argv[commandArgs], "-gfft") == 0) {
commandArgs++;
performFFT = 1;
strncpy(fft_filename, argv[commandArgs], FILENAME_LENGTH);
}
if (strcmp(argv[commandArgs], "-ma") == 0) {
imageWriteNecessary = 1;
performMinkowskiAddition = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-ms") == 0) {
imageWriteNecessary = 1;
performMinkowskiSubtraction = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-mo") == 0) {
imageWriteNecessary = 1;
performMinkowskiOpening = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-mc") == 0) {
imageWriteNecessary = 1;
performMinkowskiClosing = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d%c%d", &maskwidth, &x, &maskheight);
commandArgs++;
sscanf(argv[commandArgs], "%d", &maskrepeat);
}
if (strcmp(argv[commandArgs], "-e1") == 0) {
imageWriteNecessary = 1;
performEdgeDetectOne = 1;
}
if (strcmp(argv[commandArgs], "-e2") == 0) {
imageWriteNecessary = 1;
performEdgeDetectTwo = 1;
}
if (strcmp(argv[commandArgs], "-e3") == 0) {
imageWriteNecessary = 1;
performEdgeDetectThree = 1;
}
if (strcmp(argv[commandArgs], "-e4") == 0) {
imageWriteNecessary = 1;
commandArgs++;
sscanf(argv[commandArgs], "%d", &performEdgeDetectFour);
}
if (strcmp(argv[commandArgs], "-noiseG") == 0) {
imageWriteNecessary = 1;
performAddGaussianNoise = 1;
commandArgs++;
sscanf(argv[commandArgs], "%f", &percentCorrupt);
commandArgs++;
sscanf(argv[commandArgs], "%f", &sigma);
}
if (strcmp(argv[commandArgs], "-noiseSP") == 0) {
imageWriteNecessary = 1;
performAddSaltPepperNoise = 1;
commandArgs++;
sscanf(argv[commandArgs], "%f", &percentCorrupt);
}
}
pi = readImage(in);
if (performHighpass || performLowpass || performFFT) {
FFT2D(pi);
if (performHighpass) highpass(pi, highpasslevel);
if (performLowpass) lowpass(pi, lowpasslevel);
if (performFFT) graph_fftlogplot(pi, fft_filename);
IFFT2D(pi);
}
if (performEdgeDetectOne || performEdgeDetectTwo || performEdgeDetectThree ||
performMinkowskiAddition || performMinkowskiSubtraction || performMinkowskiOpening || performMinkowskiClosing)
thresholdImage(pi);
if (performAddGaussianNoise) addGaussianNoise(pi, percentCorrupt, sigma);
if (performAddSaltPepperNoise) addSaltPepperNoise(pi, percentCorrupt);
if (performMedianFilter) simpleMedianFilter(pi, performMedianFilter);
if (performMeanFilter) simpleMeanFilter(pi, performMeanFilter);
if (performComponentMedianFilter) componentMedianFilter(pi, performComponentMedianFilter);
if (performVectorOrderStatistic) vectorOrderStatistic(pi, performVectorOrderStatistic, m);
if (performVectorSpacialOrderStatistic) vectorSpacialOrderStatistic(pi, performVectorSpacialOrderStatistic, m, replaceWithM);
if (performVectorMedianOrderStatistic) vectorMedianOrderStatistic(pi, performVectorMedianOrderStatistic, m, replaceWithM);
if (performVectorMedianFilter) vectorMedianFilter(pi, performVectorMedianFilter);
if (performSpacialFilter) spacialFilter(pi);
if (performBrightFilter) HSV_ValueFilter(pi, performBrightFilter);
if (performColorScale) scale_reduce(pi,performColorScale);
if (performSetBrightness) setBrightness(pi,brightness);
if (performSetSaturation) setSaturation(pi,sat);
if (performSpatialReduceWidth) spacial_reduce(pi,performSpatialReduceWidth, performSpatialReduceHeigth);
if (performContrast) contrast_stretching(pi, contrastLow, contrastHigh);
if (performLevelSlicing) level_slice(pi, performLevelSlicing);
if (performEqualize) equalize(pi);
if (performHistogram) graph_histogram(pi, histo_filename);
if (performCDF) graph_cdf(pi, cdf_filename);
if (performMinkowskiAddition)
for (i = 0; i < maskrepeat; i++)
minkowskiAddition(pi, maskwidth, maskheight);
if (performMinkowskiSubtraction)
for (i = 0; i < maskrepeat; i++)
minkowskiSubtraction(pi, maskwidth, maskheight);
if (performMinkowskiOpening)
for (i = 0; i < maskrepeat; i++)
minkowskiOpening(pi, maskwidth, maskheight);
if (performMinkowskiClosing)
for (i = 0; i < maskrepeat; i++)
minkowskiClosing(pi, maskwidth, maskheight);
if (performEdgeDetectOne) {
struct portImage *pc = copyImage(pi);
imageWriteNecessary = 1;
minkowskiSubtraction(pc, 3, 3);
minkowskiDivision(pi, pc);
freeImage(pc);
}
if (performEdgeDetectTwo) {
struct portImage *pc = copyImage(pi);
imageWriteNecessary = 1;
minkowskiAddition(pi, 3, 3);
minkowskiDivision(pi, pc);
freeImage(pc);
}
if (performEdgeDetectThree) {
struct portImage *pd = copyImage(pi);
maskrepeat = 3;
imageWriteNecessary = 1;
for (i = 0; i < maskrepeat; i++) {
minkowskiAddition(pi, 3, 3);
minkowskiSubtraction(pd, 3, 3);
}
minkowskiDivision(pi, pd);
minkowskiSubtraction(pi, 3, 3);
freeImage(pd);
}
if (imageWriteNecessary)
writeImage(pi, out);
freeImage(pi);
if (in != stdin) fclose(in);
if (out != stdout) fclose(out);
return 0;
} /* End Main */
void ImagesDemos( Mat& image1, Mat& image2, Mat& logo_image, Mat& people_image )
{
Timestamper* timer = new Timestamper();
// Basic colour image access (demonstration using invert)
Mat output_image;
InvertColour( image1, output_image );
Mat output1 = JoinImagesHorizontally(image1,"Original Image",output_image,"Inverted Image",4);
imshow("Basic Image Processing", output1);
char c = cvWaitKey();
cvDestroyAllWindows();
// Sampling & Quantisation (Grey scale)
Mat image1_gray, smaller_image, resized_image, two_bit_image;
cvtColor(image1, image1_gray, CV_BGR2GRAY);
resize(image1_gray, smaller_image, Size( image1.cols/2, image1.rows/2 ));
resize(smaller_image, resized_image, image1.size() );
two_bit_image = image1_gray.clone();
ChangeQuantisationGrey( two_bit_image, 2 );
Mat image1_gray_display, smaller_image_display, resized_image_display, two_bit_image_display;
cvtColor(image1_gray, image1_gray_display, CV_GRAY2BGR);
cvtColor(smaller_image, smaller_image_display, CV_GRAY2BGR);
cvtColor(resized_image, resized_image_display, CV_GRAY2BGR);
cvtColor(two_bit_image, two_bit_image_display, CV_GRAY2BGR);
output1 = JoinImagesHorizontally(two_bit_image_display,"Quantisation 8->2 bits",image1_gray_display,"Original Greyscale Image",4);
Mat output2 = JoinImagesHorizontally(output1,"",smaller_image_display,"Half sized image",4);
Mat output3 = JoinImagesHorizontally(output2,"",resized_image_display,"Resized image",4);
// Sampling & Quantisation
Mat quantised_frame;
quantised_frame = image1.clone();
resize(image1, smaller_image, Size( image1.cols/2, image1.rows/2 ));
resize(smaller_image, resized_image, image1.size(), 0.0, 0.0, INTER_NEAREST );
changeQuantisation(quantised_frame, 2);
output1 = JoinImagesHorizontally(quantised_frame,"Quantisation 8->2 bits",image1,"Original Colour Image",4);
output2 = JoinImagesHorizontally(output1,"",smaller_image,"Half sized image",4);
Mat output4 = JoinImagesHorizontally(output2,"",resized_image,"Resized image",4);
Mat output5 = JoinImagesVertically(output3,"",output4,"",4);
imshow("Sampling & Quantisation", output5);
c = cvWaitKey();
cvDestroyAllWindows();
// Colour channels.
resize(image2, smaller_image, Size( image2.cols/2, image2.rows/2 ));
vector<Mat> input_planes(3);
split(smaller_image,input_planes);
Mat channel1_display, channel2_display, channel3_display;
cvtColor(input_planes[2], channel1_display, CV_GRAY2BGR);
cvtColor(input_planes[1], channel2_display, CV_GRAY2BGR);
cvtColor(input_planes[0], channel3_display, CV_GRAY2BGR);
output1 = JoinImagesHorizontally(channel1_display,"Red",channel2_display,"Green",4);
output2 = JoinImagesHorizontally(output1,"",channel3_display,"Blue",4);
Mat yuv_image;
cvtColor(smaller_image, yuv_image, CV_BGR2YUV);
split(yuv_image,input_planes);
cvtColor(input_planes[0], channel1_display, CV_GRAY2BGR);
cvtColor(input_planes[1], channel2_display, CV_GRAY2BGR);
cvtColor(input_planes[2], channel3_display, CV_GRAY2BGR);
output1 = JoinImagesHorizontally(channel1_display,"Y",channel2_display,"U",4);
output3 = JoinImagesHorizontally(output1,"",channel3_display,"V",4);
output4 = JoinImagesVertically(output2,"",output3,"",4);
Mat hls_image;
cvtColor(smaller_image, hls_image, CV_BGR2HLS);
vector<Mat> hls_planes(3);
split(hls_image,hls_planes);
Mat& hue_image = hls_planes[0];
cvtColor(hls_planes[0], channel1_display, CV_GRAY2BGR);
cvtColor(hls_planes[1], channel2_display, CV_GRAY2BGR);
cvtColor(hls_planes[2], channel3_display, CV_GRAY2BGR);
output1 = JoinImagesHorizontally(channel1_display,"Hue",channel2_display,"Luminance",4);
output2 = JoinImagesHorizontally(output1,"",channel3_display,"Saturation",4);
output3 = JoinImagesVertically(output4,"",output2,"",4);
Mat lab_image;
cvtColor(smaller_image, lab_image, CV_BGR2Lab);
vector<Mat> lab_planes(3);
split(lab_image,lab_planes);
cvtColor(lab_planes[0], channel1_display, CV_GRAY2BGR);
cvtColor(lab_planes[1], channel2_display, CV_GRAY2BGR);
cvtColor(lab_planes[2], channel3_display, CV_GRAY2BGR);
output1 = JoinImagesHorizontally(channel1_display,"Luminance",channel2_display,"A",4);
output2 = JoinImagesHorizontally(output1,"",channel3_display,"B",4);
output4 = JoinImagesVertically(output3,"",output2,"",4);
output3 = JoinImagesHorizontally(smaller_image,"",output4,"",4);
imshow("Colour Models - RGB, YUV, HLS, Lab", output3);
c = cvWaitKey();
cvDestroyAllWindows();
Mat hls_people_image, hls_skin_image, skin_image, redeye_image;
cvtColor(people_image, hls_people_image, CV_BGR2HLS);
SelectSkin( hls_people_image, hls_skin_image );
SelectRedEyePixels( people_image, redeye_image );
cvtColor(hls_skin_image, skin_image, CV_HLS2BGR);
output1 = JoinImagesHorizontally(people_image,"Original Image",skin_image,"Possible skin pixels",4);
output2 = JoinImagesHorizontally(output1,"",redeye_image,"Possible Red-Eye pixels",4);
imshow("Skin & Redeye detection", output2);
c = cvWaitKey();
cvDestroyAllWindows();
// Noise & Smoothing
resize(image1, smaller_image, Size( image1.cols*3/4, image1.rows*3/4 ));
Mat noise_test = smaller_image.clone();
addGaussianNoise(noise_test, 0.0, 20.0);
Mat noise_test1 = noise_test.clone();
Mat noise_test2 = noise_test.clone();
Mat noise_test3 = noise_test.clone();
blur(noise_test1,noise_test1,Size(5,5));
GaussianBlur(noise_test2,noise_test2,Size(5,5),1.5);
medianBlur(noise_test3,noise_test3,5);
output1 = JoinImagesHorizontally(noise_test,"Gaussian Noise (0, 20)",noise_test1,"Local Average",4);
output2 = JoinImagesHorizontally(output1,"",noise_test2,"Gaussian filtered",4);
output3 = JoinImagesHorizontally(output2,"",noise_test3,"Median filtered",4);
noise_test = smaller_image.clone();
addSaltAndPepperNoise(noise_test, 5.0);
noise_test1 = noise_test.clone();
noise_test2 = noise_test.clone();
noise_test3 = noise_test.clone();
blur(noise_test1,noise_test1,Size(5,5));
GaussianBlur(noise_test2,noise_test2,Size(5,5),1.5);
medianBlur(noise_test3,noise_test3,5);
output1 = JoinImagesHorizontally(noise_test,"Salt and Pepper Noise (5%)",noise_test1,"Local Average",4);
output2 = JoinImagesHorizontally(output1,"",noise_test2,"Gaussian filtered",4);
output4 = JoinImagesHorizontally(output2,"",noise_test3,"Median filtered",4);
output5 = JoinImagesVertically(output3,"",output4,"",4);
output1 = JoinImagesHorizontally(smaller_image,"Original Image",output5,"",4);
imshow("Noise and Smoothing", output1);
c = cvWaitKey();
cvDestroyAllWindows();
// Regions of Interest and weighted image addition.
Mat watermarked_image = image1.clone();
double scale = (((double)logo_image.cols)/((double)image1.cols)) > (((double)logo_image.rows)/((double)image1.rows)) ?
0.5/(((double)logo_image.cols)/((double)image1.cols)) : 0.5/(((double)logo_image.rows)/((double)image1.rows));
int new_logo_size = image1.cols < image1.rows ? image1.cols/8 : image1.rows/8;
resize(logo_image,logo_image,Size(((int) (((double) logo_image.cols)*scale)),((int) (((double) logo_image.rows)*scale))));
Mat imageROI;
imageROI = watermarked_image(cv::Rect((image1.cols-logo_image.cols)/2,(image1.rows-logo_image.rows)/2,logo_image.cols,logo_image.rows));
addWeighted(imageROI,1.0,logo_image,0.1,0.0,imageROI);
output1 = JoinImagesHorizontally(image1,"Original Image",logo_image,"Watermark",4);
output2 = JoinImagesHorizontally(output1,"",watermarked_image,"Watermarked Image",4);
imshow("Watermarking (Demo of Image ROIs & weighted addition)", output2);
c = cvWaitKey();
cvDestroyAllWindows();
}
