--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,9 @@
+syntax: glob
+*.orig
+*.rej
+*~
+*.o
+.dummy
+
+syntax: regexp
+.*\#.*\#$

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ANNOUNCEMENT	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,132 @@
+Watermarking source
+
+version 0.4
+
+
+This package provides source code for some watermarking algorithms in
+portable C code. Currently it includes the following
+
+  watermarking algorithms
+
+    Bruyndonckx [bruyn]
+      refer to
+        O. Bruyndonckx, Jean-Jacques Quisquater, and Benoit M. Macq.
+        Spatial method for copyright labeling of digital images.
+        In IEEE Workshop on Nonlinear Signal and Image Processing '95,
+        Thessaloniki, Greece, pages 456 - 459, 1995.
+
+    Corvi
+      refer to
+        Marco Corvi and Gianluca Nicchiotti.
+        Wavelet-based image watermarking for copyright protection.
+        In Scandinavian Conference on Image Analysis SCIA '97, Lappeenranta,
+        Finland, June 1997.
+
+    Cox
+      refer to
+        Ingemar J. Cox, Joe Kilian, Tom Leighton, and Talal G. Shamoon.
+        Secure spread spectrum watermarking for multimedia.
+        In Proceedings of the IEEE ICIP '97,
+        volume 6, pages 1673 - 1687, Santa Barbara, California, USA, 1997.
+
+    Dugad
+      refer to
+        Rakesh Dugad, Krishna Ratakonda, and Narendra Ahuja. 
+        A new wavelet-based scheme for watermarking images. In Proceedings of 
+        the IEEE International Conference on Image Processing, ICIP '98, 
+        Chicago, IL, USA, October 1998. 
+
+    Fridrich (2. scheme)
+      refer to
+        Jiri Fridrich.
+        Combining low-frequency and spread spectrum watermarking. In Proceedings of 
+        the SPIE Symposium on Optical Science, Engineering and Instrumentation, 
+        San Diego, USA, July 1998. 
+
+    Koch
+      refer to
+        Eckhard Koch and Jian Zhao.
+        Towards robust and hidden image copyright labeling.
+        In Proceedings of the IEEE International Workshop on Nonlinear
+        Signal and Image Processing, pages 452 - 455, Halkidiki, Marmaras,
+        Greece, June 1995.
+
+    Kim
+      refer to
+        Jong Ryul Kim and Young Shik Moon.
+        A robust wavelet-based digital watermark using level-adaptive
+        thresholding. In Proceedings of the 6th IEEE International
+        Conference on Image Processing ICIP '99, page 202,
+        Kobe, Japan, October 1999.
+
+    Wang
+      refer to
+        Houng-Jyh Wang, Po-Chyi Su, and C.-C. Jay Kuo. 
+        Wavelet-based digital image watermarking. Optics Express, 3 
+        pp. 497, December 1998. 
+
+    Xia
+      refer to
+        Xiang-Gen Xia, Charles G. Boncelet, and Gonzalo R. Arce.
+        Wavelet transform based watermark for digital images. Optics Express, 3
+        pp. 497, December 1998.
+
+    Xie
+      refer to
+        Liehua Xie and Gonzalo R. Arce.
+        Joint wavelet compression and authentication watermarking. In 
+        Proceedings of the IEEE International Conference on Image Processing,   
+        ICIP '98, Chicago, IL, USA, 1998.
+
+    Zhu
+      refer to
+       Wenwu Zhu, Zixiang Xiong, and Ya-Qin Zhang. 
+       Multiresolution watermarking for images and video: a unified approach. 
+       In Proceedings of the IEEE International Conference on Image Processing, 
+       ICIP '98, Chicago, IL, USA, October 1998. 
+
+   Piva/Fotopoulos [cast|test-pv,hart,sub]
+     contribution by Vassilis Fotopoulos
+     refer to
+
+        M.Barni, F. Bartolini, V. Cappellini, A. Piva. A DCT-Domain
+        System for Robust Image Watermarking,
+        Signal Processing, vol. 66, pp 357 - 372, 1998.
+
+        V. Fotopoulos, A. N. Skodras, A Subband DCT approach to
+        image watermarking, X European Signal Processing Conference,
+        September 4 - 8, 2000, Tampere, Finland
+
+    many more algorithms to come!
+    see what is in stock: http://www.cosy.sbg.ac.at/~pmeerw/Watermarking
+
+  and utility programs
+
+    cmp_pgm     - compute difference image, PSNR, ...
+    cmp_dct     - compute full-frame DCT domain difference image
+    cmp_dct8x8  - compute 8x8 block-based DCT difference image
+    cmp_dwt     - compute DWT domain difference image
+
+
+
+Contact: Comments are welcome!
+
+More algorithms will be added over time, I have implemented about 13
+watermarking algorithms in the spatial-, DCT-, and wavelet domain so far.
+
+Please report what problems you have, suggestions, ...
+
+Peter Meerwald
+
+Dept. of Scientific Computing
+University of Salzburg
+Jakob-Haringer-Str. 2
+A-5020 Salzburg
+AUSTRIA
+
+pmeerw@cosy.sbg.ac.at
+http://www.cosy.sbg.ac.at/~pmeerw/Watermarking
+
++43-662-8044-6327
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/CHANGES	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,2 @@
+removed #include <values.h> - it is not needed and MS VC++ does not have 
+it (Sarat Atluri)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/Makefile	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,44 @@
+# Makefile
+
+include ../make/make.config
+
+all: cast-pv$(EXE) cast-hart$(EXE) cast-sub$(EXE) test-pv$(EXE) test-hart$(EXE) test-sub$(EXE)
+
+.SUFFIXES: .c .o
+
+.c$(O):
+	$(CC) $(CFLAGS) $(INCLUDES) -o $@ -c $<
+
+cast-pv$(EXE):  cast-pv$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ cast-pv$(O) common$(O) $(PGMLIBS)
+
+cast-hart$(EXE):  cast-hart$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ cast-hart$(O) common$(O) $(PGMLIBS)
+
+cast-sub$(EXE):  cast-sub$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ cast-sub$(O) common$(O) $(PGMLIBS)
+
+test-pv$(EXE):  test-pv$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ test-pv$(O) common$(O) $(PGMLIBS)
+
+test-hart$(EXE):  test-hart$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ test-hart$(O) common$(O) $(PGMLIBS)
+
+test-sub$(EXE):  test-sub$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ test-sub$(O) common$(O) $(PGMLIBS)
+
+test: cast-pv$(EXE) cast-hart$(EXE) cast-sub$(EXE) test-pv$(EXE) test-hart$(EXE) test-sub$(EXE)
+	cast-pv < ../images/lena.pgm > ../watermarked/foto-pv_lena.pgm
+	cast-hart  < ../images/lena.pgm > ../watermarked/foto-hart_lena.pgm
+	cast-sub  < ../images/lena.pgm > ../watermarked/foto-sub_lena.pgm
+
+	test-pv < ../watermarked/foto-pv_lena.pgm > ../wms/foto-pv.wm
+	test-hart < ../watermarked/foto-hart_lena.pgm > ../wms/foto-hart.wm
+	test-sub < ../watermarked/foto-sub_lena.pgm > ../wms/foto-sub.wm
+
+install: cast-pv$(EXE) cast-hart$(EXE) cast-sub$(EXE) test-pv$(EXE) test-hart$(EXE) test-sub$(EXE)
+	$(CP) cast-pv$(EXE) cast-hart$(EXE) cast-sub$(EXE) test-pv$(EXE) test-hart$(EXE) test-sub$(EXE) $(INSTALLDIR)
+
+clean:
+	$(RM) *$(O) cast-pv$(EXE) cast-hart$(EXE) cast-sub$(EXE) test-pv$(EXE) test-hart$(EXE) test-sub$(EXE)
+	$(RM) ../watermarked/* ../wms/*

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/README	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,21 @@
+M.Barni, F. Bartolini, V. Cappellini, A. Piva. "A DCT-Domain
+System for Robust Image Watermarking",
+Signal Processing, vol.66, pp 357-372, 1998.
+
+V. Fotopoulos, A.N. Skodras, "A Subband DCT approach to
+image watermarking", X European Signal Processing Conference,
+September 4-8, 2000, Tampere, Finland
+
+parameters:
+for starting coefficient reasonable values for the dct and hartley schemes
+and this kind of dimensions is around 5000-20000, for the watermark length 10000-50000,
+and seed/key should be in the range 1-1000 so that the output file of the testing module
+gives a right similarity diagram
+
+for the subband dct version, things change corresponding to coefficients
+because the bands' sizes are 1/4 of the original image's size.
+starting coef should be between 3000-5000 and length 10000-20000
+for the alpha parameter i use 0.2 for all bands except LL for which i use
+0.1
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/README_VASSILIS	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,67 @@
+These codes use the DCT,Hartley and Subband DCT
+Transforms for watermarking purposes.All schemes
+are blind,no original image is used for detection.
+Each casting module is accompanied by a testing 
+module.Supposing that the watermark key that you
+select during casting is in the range 1-1000,the
+testing module will test all the keys in this range
+to produce the well known similarity diagrams used
+by Cox, Piva and many more with the peak being the
+proof of the watermark existence.
+
+I do not include a detection module because this implies
+the use of certain thresholds. Although the casting
+methods are almost standardized (multiplicative formula)
+there are still questions about this thresholding but
+the testing modules can be easily changed to fit this
+purpose.
+
+The DCT scheme does not use the visual masking improvement
+that Barni and his team suggest in one of their later works.
+In all casting programs we assume that the coefficients are
+diagonaly scanned,and ordered as shown in the following example.
+
+----------------------
+| 1| 3| 6|10|15|...
+----------------------
+| 2| 5| 9|14|...
+----------------------
+| 4| 8|13|...
+----------------------
+| 7|12|...
+----------------------
+|11|...
+----------------------
+
+which is quite simple comparing to the zig zag scanning 
+pattern that we know from the JPEG standard but does not
+affect at all the idea that we have of the middle 
+frequencies.Also the user should take care that
+
+starting_coefficient+number_of_coeffs_to_change<(N*N)/2
+
+which means that we shouldn't exceed the matrix diagonal.
+To do so the scanning scheme should be changed accordingly
+but this doesn't seem important because in all of the
+schemes we don't get out of the middle frequencies coefs.
+With correctly selected parameters,the schemes perform in
+the same way as if the coeffs were zig zag scanned.
+
+In the Subband DCT version,the first set of questions
+about starting coefficient,number of coefficients to
+alter and alpha parameter, refer to the LH,HL and HH
+band while the second set of questions sets the parameters
+about the LL band only.
+
+All schemes should not be used with the same set of parameters
+because each of the transforms, possess certain specific
+properties. This should be kept in mind for testing purposes.
+To use the right set of parameters please refer to corresponding
+bibliography.
+All code has been tested in Visual C++ v6.0
+
+Have some nice tests...
+Vassilis Fotopoulos
+
+for more info,ideas or points of discussion
+email vfotop1@physics.upatras.gr

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/cast-hart.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,112 @@
+/* Watermarking program - Hartley Transform based	*/
+/* Module	: Casting				*/
+/* Author	: Vassilis Fotopoulos			*/
+/* Date		: 26/7/1999				*/
+/* Revision	: 2.01a					*/
+/* Developed at	: ELLAB                  		*/
+/*                Electronics Laboratory           	*/
+/*                Department of Physics             	*/
+/*                University of Patras - GREECE      	*/
+/*		  Copyleft (c) 1999			*/
+/*------------------------------------------------------*/
+/*	pseudorandom noise generator's code is		*/
+/*	taken from "Numerical Recipes in C"		*/
+/*------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <getopt.h>
+#include "common.h"
+
+int height, width;
+
+void add_watermark(double **in, int N, int coeff_start, int wm_length, int wm_key, double wm_alpha)
+{
+  int row, col, count;
+  long int elem, L, M, temp, seed;
+  double a;
+  count = 0;
+  elem = 0;
+  M = coeff_start;
+  L = wm_length;
+  seed = wm_key;
+  a = wm_alpha;
+  for (row = 0; row < N; row++)
+    for (col = 0; col < N; col++) {
+      elem++;
+      if (elem > M && count < L) {
+        in[row][col] += a * fabs(in[row][col]) * gasdev(&seed);
+        count++;
+      }
+    }
+
+}
+
+//--------------------------------------------------------
+int main(int argc, char* argv[])
+{
+  FILE *in, *out;
+  int **image;
+  double **image_i;
+  double **image_d;
+  int c;
+  int N;
+  int coeff_start = 5000, wm_length = 10000, wm_key = 123;
+  double wm_alpha = 0.2;
+
+  pgm_init(&argc, argv); wm_init();
+
+  while ((c = getopt(argc, argv, "a:s:l:k:")) != EOF) {
+    switch (c) {
+        case 'a':
+        wm_alpha = atof(optarg);
+        break;
+        case 's':
+        coeff_start = atoi(optarg);
+        break;
+        case 'l':
+        wm_length = atoi(optarg);
+        break;
+        case 'k':
+        wm_key = atoi(optarg);
+        break;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+
+  in = stdin;
+  out = stdout;
+
+  open_image(in, &width, &height);
+  image = imatrix(height, width);
+  load_image(image, in, width, height);
+
+  if (height == width)
+    N = height;
+  else {
+    fprintf(stderr, "Cannot Proccess non-square images!\n");
+    exit( -11);
+  }
+
+  image_i = dmatrix(height, width);
+  image_d = dmatrix(height, width);
+  if (image_d == NULL) {
+    fprintf(stderr, "Unable to allocate the double array\n");
+    exit(1);
+  }
+  matrix_i2d(image, image_i, N);
+  hartley(image_i, image_d, N);
+  add_watermark(image_d, N, coeff_start, wm_length, wm_key, wm_alpha);
+  hartley(image_d, image_i, N);
+  matrix_d2i(image_i, image, N);
+  save_image(image, out, width, height);
+
+  freematrix_d(image_i, height);
+  freematrix_d(image_d, height);
+  fclose(in);
+  fclose(out);
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/cast-pv.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,132 @@
+/* Watermarking program - Fast Cosine Transform based	*/
+/* Module	: Casting				*/
+/* Author	: Vassilis Fotopoulos			*/
+/* Date		: 21/7/1999				*/
+/* Revision	: 2.01a					*/
+/* Developed at	: ELLAB                  		*/
+/*                Electronics Laboratory           	*/
+/*                Department of Physics             	*/
+/*                University of Patras - GREECE      	*/
+/*		  Copyleft (c) 1999	    		*/
+/*  		  (without Visual Masking)              */
+/*------------------------------------------------------*/
+/*	pseudorandom noise generator's code is		*/
+/*	taken from "Numerical Recipes in C"		*/
+/*	FCT implementation from the University of Bath	*/
+/*------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <getopt.h>
+#include "common.h"
+
+double cu[1024];
+double cv[1024];
+int height, width;
+
+//--------------------------------------------------------
+void add_watermark(double *in, int N, int coeff_start, int wm_length, int wm_key, double wm_alpha)
+{
+  int row, col, count;
+  long int elem, L, M, temp, seed;
+  double a;
+  count = 0;
+  elem = 0;
+  row = 2;
+  col = -1;
+  M = coeff_start;
+  L = wm_length;
+  seed = wm_key;
+  a = wm_alpha;
+  do {
+    do {
+      row--;
+      col++;
+      elem++;
+      if (col < N) {
+        if (elem > M) {
+          temp = row * N + col;
+          in[temp] += a * fabs(in[temp]) * gasdev(&seed);
+          count++;
+        }
+      }
+    } while (row > 0);
+    row = 2 + col;
+    col = -1;
+  } while (count < L);
+}
+//--------------------------------------------------------
+void initialize_constants(void)
+{
+  int i;
+  cu[0] = cv[0] = 0.7071068;
+  for (i = 1; i < 1024; i++)
+    cu[i] = cv[i] = 1.0;
+}
+
+//--------------------------------------------------------
+int main(int argc, char* argv[])
+{
+  FILE *in, *out;
+  int **image_i;
+  double *image_f = NULL;
+  int N;
+  int c;
+  int coeff_start = 5000, wm_length = 10000, wm_key = 123;
+  double wm_alpha = 0.2;
+
+  pgm_init(&argc, argv); wm_init();
+
+  while ((c = getopt(argc, argv, "a:s:l:k:")) != EOF) {
+    switch (c) {
+        case 'a':
+        wm_alpha = atof(optarg);
+        break;
+        case 's':
+        coeff_start = atoi(optarg);
+        break;
+        case 'l':
+        wm_length = atoi(optarg);
+        break;
+        case 'k':
+        wm_key = atoi(optarg);
+        break;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+
+  in = stdin;
+  out = stdout;
+
+  open_image(in, &width, &height);
+  image_i = imatrix(height, width);
+  load_image(image_i, in, width, height);
+
+  if (height == width)
+    N = height;
+  else {
+    fprintf(stderr, "Cannot Proccess non-square images!\n");
+    exit( -11);
+  }
+
+  initialize_constants();
+  image_f = (double *)calloc(N * N, sizeof(double));
+  if (image_f == NULL) {
+    printf("Unable to allocate the float array\n");
+    exit(1);
+  }
+
+  put_image_from_int_2_double(image_i, image_f, N);
+  fct2d(image_f, N, N);
+  add_watermark(image_f, N, coeff_start, wm_length, wm_key, wm_alpha);
+  ifct2d(image_f, N, N);
+  put_image_from_double_2_int(image_f, image_i, N);
+  save_image(image_i, out, width, height);
+  freematrix(image_i, height);
+  free(image_f);
+  fclose(in);
+  fclose(out);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/cast-sub.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,247 @@
+/* Watermarking program - Subband DCT Transform based	*/
+/* Module	: Casting				*/
+/* Author	: Vassilis Fotopoulos			*/
+/* Date		: 25/4/2000				*/
+/* Revision	: 7.0					*/
+/* Developed at	: ELLAB                  		*/
+/*                Electronics Laboratory           	*/
+/*                Department of Physics             	*/
+/*                University of Patras - GREECE      	*/
+/*		  Copyleft (c) 1999	    		*/
+/*------------------------------------------------------*/
+/*	pseudorandom noise generator's code is		*/
+/*	taken from "Numerical Recipes in C"		*/
+/*	FCT implementation from University of Bath	*/
+/*------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <getopt.h>
+#include "common.h"
+
+void add_hor_add_ver(double **in, int N, double **out);
+void add_hor_sub_ver(double **in, int N, double **out);
+void sub_hor_add_ver(double **in, int N, double **out);
+void sub_hor_sub_ver(double **in, int N, double **out);
+void band_synthesis(double **ll, double **lh, double **hl, double **hh, int N, double **s);
+void watermark(double **i, int N, long key, long int L, long int M, double a);
+
+double cu[1024];
+double cv[1024];
+int height, width;
+
+//--------------------------------------------------------
+void add_hor_add_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] + in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] + temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+//--------------------------------------------------------
+void add_hor_sub_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] + in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] - temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+//--------------------------------------------------------
+void sub_hor_add_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] - in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] + temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+//--------------------------------------------------------
+void sub_hor_sub_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] - in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] - temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+//--------------------------------------------------------
+void band_synthesis(double **ll, double **lh, double **hl, double **hh, int N, double **s)
+{
+  int r, c;
+  double b1, b2, b3, b4;
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N; c++) {
+      b1 = ll[r][c] + lh[r][c] + hl[r][c] + hh[r][c]; 	//Reconstruct each
+      b2 = ll[r][c] + lh[r][c] - hl[r][c] - hh[r][c]; 	//of the pixels
+      b3 = ll[r][c] - lh[r][c] + hl[r][c] - hh[r][c];
+      b4 = ll[r][c] - lh[r][c] - hl[r][c] + hh[r][c];
+      b1 = (b1 > 255.0) ? 255.0 : b1; 					//Check for positive...
+      b1 = (b1 < 0.0) ? 0.0 : b1; 						//or negative core!
+      b2 = (b2 > 255.0) ? 255.0 : b2;
+      b2 = (b2 < 0.0) ? 0.0 : b2;
+      b3 = (b3 > 255.0) ? 255.0 : b3;
+      b3 = (b3 < 0.0) ? 0.0 : b3;
+      b4 = (b4 > 255.0) ? 255.0 : b4;
+      b4 = (b4 < 0.0) ? 0.0 : b4;
+      s[2*r][2*c] = b1; 							//Put them back in
+      s[2*r][2*c + 1] = b2; 						//the right position
+      s[2*r + 1][2*c] = b3;
+      s[2*r + 1][2*c + 1] = b4;
+    }
+}
+
+void watermark(double **i, int N, long key, long int L, long int M, double a)
+{
+  int row, col, count;
+  long int elem, temp, seed;
+  double *v;
+  v = dvector(N * N);
+  put_matrix_2_vector(i, v, N);
+  fct2d(v, N, N);
+  seed = key;
+  count = 0;
+  elem = 0;
+  row = 2;
+  col = -1;
+  do {
+    do {
+      row--;
+      col++;
+      elem++;
+      if (col < N) {
+        if (elem > M) {
+          temp = row * N + col;
+          v[temp] += a * fabs(v[temp]) * gasdev(&seed);
+          count++;
+        }
+      }
+    } while (row > 0);
+    row = 2 + col;
+    col = -1;
+  } while (count < L);
+  ifct2d(v, N, N);
+  put_vector_2_matrix(v, i, N);
+  free(v);
+}
+
+int main(int argc, char* argv[])
+{
+  double **i;
+  double **o;
+  FILE *in;
+  FILE *out;
+  int N;
+  int c;
+  long int M1, L1, M2, L2;
+  int **image_i;
+  double **ll, **lh, **hl, **hh;
+  double a_ll = 0.1, a_other = 0.2;
+  int wm_length_1 = 10000, wm_length_ll = 10000, coeff_start_1 = 3000,
+                                          coeff_start_ll = 3000, wm_key = 123;
+
+  pgm_init(&argc, argv); wm_init();
+
+  while ((c = getopt(argc, argv, "a:b:t:m:s:l:k:")) != EOF) {
+    switch (c) {
+        case 'a':
+        a_ll = atof(optarg);
+        break;
+        case 'b':
+        a_other = atof(optarg);
+        break;
+        case 't':
+        coeff_start_1 = atoi(optarg);
+        break;
+        case 'm':
+        wm_length_1 = atoi(optarg);
+        break;
+        case 's':
+        coeff_start_ll = atoi(optarg);
+        break;
+        case 'l':
+        wm_length_ll = atoi(optarg);
+        break;
+        case 'k':
+        wm_key = atoi(optarg);
+        break;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+
+  in = stdin;
+  out = stdout;
+  open_image(in, &width, &height);
+  image_i = imatrix(height, width);
+  load_image(image_i, in, width, height);
+  if (height == width)
+    N = height;
+  else {
+    fprintf(stderr, "Cannot Proccess non-square images!\n");
+    exit( -11);
+  }
+  // starting coeff. for 1st level decomp.
+  M1 = coeff_start_1;
+  // number of coeffs to alter
+  L1 = wm_length_1;
+
+  // now the LL band
+  M2 = coeff_start_ll;
+  L2 = wm_length_ll;
+
+  i = dmatrix(N, N);
+  o = dmatrix(N, N);
+  ll = dmatrix(N / 2, N / 2);
+  lh = dmatrix(N / 2, N / 2);
+  hl = dmatrix(N / 2, N / 2);
+  hh = dmatrix(N / 2, N / 2);
+
+  matrix_i2d(image_i, i, N);
+
+  //---------------------1o decomposition-------------------
+  add_hor_add_ver(i, N, ll);
+  add_hor_sub_ver(i, N, lh);
+  sub_hor_add_ver(i, N, hl);
+  sub_hor_sub_ver(i, N, hh);
+  //---------------------Watermark medium frequency bands---
+  watermark(lh, N / 2, wm_key, L1, M1, a_other);
+  watermark(hl, N / 2, wm_key, L1, M1, a_other);
+  watermark(hh, N / 2, wm_key, L1, M1, a_other);
+  watermark(ll, N / 2, wm_key, L2, M2, a_ll);
+  //---------------------Synthesis stage--------------------
+  band_synthesis(ll, lh, hl, hh, N / 2, o);
+  //--------------------------------------------------------
+  matrix_d2i(o, image_i, N);
+  save_image(image_i, out, width, height);
+
+  fclose(in);
+  fclose(out);
+}
+
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/common.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,571 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include "pgm.h"
+#include "common.h"
+
+#define IA      16807
+#define IM      2147483647
+#define AM      (1.0/IM)
+#define IQ      127773
+#define IR      2836
+#define MASK    123459876
+
+static int NN = 0;
+static int m = 0;
+static double two_over_N = 0;
+static double root2_over_rootN = 0;
+static double *C = NULL;
+
+static gray maxval;
+static int format;
+
+void open_image(FILE *in, int *width, int *height)
+{
+
+  pgm_readpgminit(in, width, height, &maxval, &format);
+}
+
+void load_image(int **im, FILE *in, int width, int height)
+{
+  int col, row;
+  gray *rowbuf;
+
+  rowbuf = malloc(sizeof(gray) * width);
+
+  for (row = 0; row < height; row++) {
+    pgm_readpgmrow(in, rowbuf, width, maxval, format);
+    for (col = 0; col < width; col++)
+      im[row][col] = rowbuf[col];
+  }
+
+  free(rowbuf);
+}
+
+void save_image(int **im, FILE *out, int width, int height)
+{
+  int col, row;
+  gray *rowbuf;
+
+  pgm_writepgminit(out, width, height, 255, 0);
+
+  rowbuf = malloc(sizeof(gray) * width);
+
+  for (row = 0; row < height; row++) {
+    for (col = 0; col < width; col++)
+      rowbuf[col] = im[row][col];
+    pgm_writepgmrow(out, rowbuf, width, 255, 0);
+  }
+
+  free(rowbuf);
+}
+
+int ** imatrix(int nrows, int ncols)
+{
+  int **m;
+  int i, j;
+  m = (int **) malloc (nrows * sizeof(int *));
+  for (i = 0; i < nrows; i++) {
+    m[i] = (int *) malloc (ncols * sizeof(int));
+    if (!m[i]) fprintf(stderr, "\nIt's not working");
+  }
+  for (i = 0; i < nrows; i++)
+    for (j = 0; j < ncols; j++)
+      m[i][j] = 0;
+  return m;
+}
+
+void freematrix(int **I, int rows)
+{
+  int k;
+  for (k = 0; k < rows; k++)
+    free (I[k]);
+}
+
+float ran0(long int *idum)
+{
+  long int k;
+  float ans;
+  *idum ^= MASK;
+  k = (*idum) / IQ;
+  *idum = IA * (*idum - k * IQ) - IR * k;
+  if (*idum < 0) *idum += IM;
+  ans = AM * (*idum);
+  *idum ^= MASK;
+  return ans;
+}
+
+float gasdev(long int *idum)
+{
+
+  float v1;
+  v1 = (float) sqrt( -2.0 * log(ran0(idum))) * cos(2 * PI * ran0(idum));
+  return v1;
+}
+
+
+void put_image_from_int_2_double(int **i, double *f, int N)
+{
+  int l, j, k;
+  k = 0;
+  for (l = 0; l < N; l++)
+    for (j = 0; j < N; j++)
+      f[k++] = (double) i[l][j];
+}
+
+void put_image_from_double_2_int(double *f, int **i, int N)
+{
+  int l, j, k;
+  k = 0;
+  for (l = 0; l < N; l++)
+    for (j = 0; j < N; j++)
+      i[l][j] = (int) f[k++];
+}
+
+
+void bitrev(double *f, int len)
+{
+  int i, j, m, halflen;
+  double temp;
+
+  if (len <= 2) return ;  /* No action necessary if n=1 or n=2 */
+  halflen = len >> 1;
+  j = 1;
+  for (i = 1; i <= len; i++) {
+    if (i < j) {
+      temp = f[j - 1];
+      f[j - 1] = f[i - 1];
+      f[i - 1] = temp;
+    }
+    m = halflen;
+    while (j > m) {
+      j = j - m;
+      m = (m + 1) >> 1;
+    }
+    j = j + m;
+  }
+}
+
+void inv_sums(double *f)
+{
+  int ii, stepsize, stage, curptr, nthreads, thread, step, nsteps;
+
+  for (stage = 1; stage <= m - 1; stage++) {
+    nthreads = 1 << (stage - 1);
+    stepsize = nthreads << 1;
+    nsteps = (1 << (m - stage)) - 1;
+    for (thread = 1; thread <= nthreads; thread++) {
+      curptr = NN - thread;
+      for (step = 1; step <= nsteps; step++) {
+        f[curptr] += f[curptr - stepsize];
+        curptr -= stepsize;
+      }
+    }
+  }
+}
+
+//--------------------------------------------------------
+//Foreign code - FCT from Bath Univerity
+//--------------------------------------------------------
+void rarrwrt(double f[], int n)
+{
+  int i;
+
+  for (i = 0; i <= n - 1; i++) {
+    fprintf(stderr, "%4d : %f\n", i, f[i]);
+  }
+}
+
+/* fast DCT based on IEEE signal proc, 1992 #8, yugoslavian authors. */
+
+void fwd_sums(double *f)
+{
+  int ii, stepsize, stage, curptr, nthreads, thread, step, nsteps;
+
+  for (stage = m - 1; stage >= 1; stage--) {
+    nthreads = 1 << (stage - 1);
+    stepsize = nthreads << 1;
+    nsteps = (1 << (m - stage)) - 1;
+    for (thread = 1; thread <= nthreads; thread++) {
+      curptr = nthreads + thread - 1;
+      for (step = 1; step <= nsteps; step++) {
+        f[curptr] += f[curptr + stepsize];
+        curptr += stepsize;
+      }
+    }
+  }
+}
+
+void scramble(double *f, int len)
+{
+  double temp;
+  int i, ii1, ii2, halflen, qtrlen;
+
+  halflen = len >> 1;
+  qtrlen = halflen >> 1;
+  bitrev(f, len);
+  bitrev(&f[0], halflen);
+  bitrev(&f[halflen], halflen);
+  ii1 = len - 1;
+  ii2 = halflen;
+  for (i = 0; i <= qtrlen - 1; i++) {
+    temp = f[ii1];
+    f[ii1] = f[ii2];
+    f[ii2] = temp;
+    ii1--;
+    ii2++;
+  }
+}
+
+void unscramble(double *f, int len)
+{
+  double temp;
+  int i, ii1, ii2, halflen, qtrlen;
+
+  halflen = len >> 1;
+  qtrlen = halflen >> 1;
+  ii1 = len - 1;
+  ii2 = halflen;
+  for (i = 0; i <= qtrlen - 1; i++) {
+    temp = f[ii1];
+    f[ii1] = f[ii2];
+    f[ii2] = temp;
+    ii1--;
+    ii2++;
+  }
+  bitrev(&f[0], halflen);
+  bitrev(&f[halflen], halflen);
+  bitrev(f, len);
+}
+
+void initcosarray(int length)
+{
+  int i, group, base, item, nitems, halfN;
+  double factor;
+
+  m = -1;
+  do {
+    m++;
+    NN = 1 << m;
+    if (NN > length) {
+      fprintf(stderr, "ERROR in FCT-- length %d not a power of 2\n", length);
+      exit(1);
+    }
+  } while (NN < length);
+  if (C != NULL) free(C);
+  C = (double *)calloc(NN, sizeof(double));
+  if (C == NULL) {
+    fprintf(stderr, "Unable to allocate C array\n");
+    exit(1);
+  }
+  halfN = NN / 2;
+  two_over_N = 2.0 / (double)NN;
+  root2_over_rootN = sqrt(2.0 / (double)NN);
+  for (i = 0; i <= halfN - 1; i++) C[halfN + i] = 4 * i + 1;
+  for (group = 1; group <= m - 1; group++) {
+    base = 1 << (group - 1);
+    nitems = base;
+    factor = 1.0 * (1 << (m - group));
+    for (item = 1; item <= nitems; item++) C[base + item - 1] = factor * C[halfN + item - 1];
+  }
+
+  //printf("before taking cos, C array =\n"); rarrwrt(C,N);
+  for (i = 1; i <= NN - 1; i++) C[i] = 1.0 / (2.0 * cos(C[i] * PI / (2.0 * NN)));
+  //printf("After taking cos, Carray = \n"); rarrwrt(C,N);
+}
+
+
+void inv_butterflies(double *f)
+{
+  int stage, ii1, ii2, butterfly, ngroups, group, wingspan, increment, baseptr;
+  double Cfac, T;
+
+  for (stage = 1; stage <= m; stage++) {
+    ngroups = 1 << (m - stage);
+    wingspan = 1 << (stage - 1);
+    increment = wingspan << 1;
+    for (butterfly = 1; butterfly <= wingspan; butterfly++) {
+      Cfac = C[wingspan + butterfly - 1];
+      baseptr = 0;
+      for (group = 1; group <= ngroups; group++) {
+        ii1 = baseptr + butterfly - 1;
+        ii2 = ii1 + wingspan;
+        T = Cfac * f[ii2];
+        f[ii2] = f[ii1]-T;
+        f[ii1] = f[ii1] + T;
+        baseptr += increment;
+      }
+    }
+  }
+}
+
+void fwd_butterflies(double *f)
+{
+  int stage, ii1, ii2, butterfly, ngroups, group, wingspan, increment, baseptr;
+  double Cfac, T;
+
+  for (stage = m; stage >= 1; stage--) {
+    ngroups = 1 << (m - stage);
+    wingspan = 1 << (stage - 1);
+    increment = wingspan << 1;
+    for (butterfly = 1; butterfly <= wingspan; butterfly++) {
+      Cfac = C[wingspan + butterfly - 1];
+      baseptr = 0;
+      for (group = 1; group <= ngroups; group++) {
+        ii1 = baseptr + butterfly - 1;
+        ii2 = ii1 + wingspan;
+        T = f[ii2];
+        f[ii2] = Cfac * (f[ii1]-T);
+        f[ii1] = f[ii1] + T;
+        baseptr += increment;
+      }
+    }
+  }
+}
+
+void ifct_noscale(double *f, int length)
+{
+  if (length != NN) initcosarray(length);
+  f[0] *= INVROOT2;
+  inv_sums(f);
+  bitrev(f, NN);
+  inv_butterflies(f);
+  unscramble(f, NN);
+}
+
+void fct_noscale(double *f, int length)
+{
+  if (length != NN) initcosarray(length);
+  scramble(f, NN);
+  fwd_butterflies(f);
+  bitrev(f, NN);
+  fwd_sums(f);
+  f[0] *= INVROOT2;
+}
+
+void ifct_defn_scaling(double *f, int length)
+{
+  ifct_noscale(f, length);
+}
+
+void fct_defn_scaling(double *f, int length)
+{
+  int i;
+
+  fct_noscale(f, length);
+  for (i = 0; i <= NN - 1; i++) f[i] *= two_over_N;
+}
+
+void ifct(double *f, int length)
+{
+  /* CALL THIS FOR INVERSE 1D DCT DON-MONRO PREFERRED SCALING */
+  int i;
+
+  if (length != NN) initcosarray(length);   /* BGS patch June 1997 */
+  for (i = 0; i <= NN - 1; i++) f[i] *= root2_over_rootN;
+  ifct_noscale(f, length);
+}
+
+void fct(double *f, int length)
+{
+  /* CALL THIS FOR FORWARD 1D DCT DON-MONRO PREFERRED SCALING */
+  int i;
+
+  fct_noscale(f, length);
+  for (i = 0; i <= NN - 1; i++) f[i] *= root2_over_rootN;
+}
+
+/****************************************************************
+    2D FAST DCT SECTION
+****************************************************************/
+
+static double *g = NULL;
+static double two_over_sqrtncolsnrows = 0.0;
+static int ncolsvalue = 0;
+static int nrowsvalue = 0;
+
+void initfct2d(int nrows, int ncols)
+{
+  if ((nrows <= 0) || (ncols < 0)) {
+    fprintf(stderr, "FCT2D -- ncols=%d or nrows=%d is <=0\n", nrows, ncols);
+    exit(1);
+  }
+  if (g != NULL) free(g);
+  g = (double *)calloc(nrows, sizeof(double));
+  if (g == NULL) {
+    fprintf(stderr, "FCT2D -- Unable to allocate g array\n");
+    exit(1);
+  }
+  ncolsvalue = ncols;
+  nrowsvalue = nrows;
+  two_over_sqrtncolsnrows = 2.0 / sqrt(ncols * 1.0 * nrows);
+}
+
+void fct2d(double f[], int nrows, int ncols)
+/* CALL THIS FOR FORWARD 2d DCT DON-MONRO PREFERRED SCALING */
+{
+  int u, v;
+
+  if ((ncols != ncolsvalue) || (nrows != nrowsvalue)){
+    initfct2d(nrows, ncols);
+  }
+  for (u = 0; u <= nrows - 1; u++){
+    fct_noscale(&f[u*ncols], ncols);
+  }
+  for (v = 0; v <= ncols - 1; v++){
+    for (u = 0; u <= nrows - 1; u++) {
+      g[u] = f[u * ncols + v];
+    }
+    fct_noscale(g, nrows);
+    for (u = 0; u <= nrows - 1; u++) {
+      f[u*ncols + v] = g[u] * two_over_sqrtncolsnrows;
+    }
+  }
+}
+
+void ifct2d(double f[], int nrows, int ncols)
+/* CALL THIS FOR INVERSE 2d DCT DON-MONRO PREFERRED SCALING */
+{
+  int u, v;
+
+  if ((ncols != ncolsvalue) || (nrows != nrowsvalue)){
+    initfct2d(nrows, ncols);
+  }
+  for (u = 0; u <= nrows - 1; u++){
+    ifct_noscale(&f[u*ncols], ncols);
+  }
+  for (v = 0; v <= ncols - 1; v++){
+    for (u = 0; u <= nrows - 1; u++) {
+      g[u] = f[u * ncols + v];
+    }
+    ifct_noscale(g, nrows);
+    for (u = 0; u <= nrows - 1; u++) {
+      f[u*ncols + v] = g[u] * two_over_sqrtncolsnrows;
+    }
+  }
+}
+
+void matmul(double **a, double **b, double **r, int N)
+{
+  int i, j, k;
+
+  for (i = 0; i < N; i++)
+    for (j = 0; j < N; j++) {
+      r[i][j] = 0.0;
+      for (k = 0; k < N; k++)
+        r[i][j] += a[i][k] * b[k][j];
+    }
+}
+
+void hartley(double **in, double **out, int N)
+{
+  int k, n;
+  double **h;
+
+  h = dmatrix(N, N);
+  //Building up the transformation matrix
+  for (k = 0; k < N; k++)
+    for (n = 0; n < N; n++)
+      h[k][n] = (cos(2 * PI * k * n / N) + sin(2 * PI * k * n / N)) / sqrt(N);
+
+  // Now we have to multiply the input with the transformation matrix
+  matmul(h, in, out, N);
+  freematrix_d(h, N);
+  return ;
+}
+
+double ** dmatrix(int nrows, int ncols)
+{
+  double **m;
+  int i, j;
+  m = (double **) malloc (nrows * sizeof(double *));
+  for (i = 0; i < nrows; i++) {
+    m[i] = (double *) malloc (ncols * sizeof(double));
+    if (!m[i]) printf("\nIt's not working");
+  }
+  for (i = 0; i < nrows; i++)
+    for (j = 0; j < ncols; j++)
+      m[i][j] = 0.0;
+  return m;
+}
+
+void freematrix_d(double **I, int rows)
+{
+  int k;
+  for (k = 0; k < rows; k++)
+    free (I[k]);
+}
+
+void matrix_i2d(int **i, double **d, int N)
+{
+  int x, y;
+  for (x = 0; x < N; x++)
+    for (y = 0; y < N; y++)
+      d[y][x] = i[y][x];
+}
+
+void matrix_d2i(double **d, int **i, int N)
+{
+  int x, y;
+  for (x = 0; x < N; x++)
+    for (y = 0; y < N; y++)
+      i[y][x] = d[y][x];
+}
+
+double * dvector(long int N)
+{
+  double *m;
+  m = (double *) malloc (N * sizeof(double));
+  if (!m) printf("\nIt's not working");
+  return m;
+}
+
+void put_matrix_2_vector(double **i, double *f, int N)
+{
+  int l, j, k;
+  k = 0;
+  for (l = 0; l < N; l++)
+    for (j = 0; j < N; j++)
+      f[k++] = i[l][j];
+}
+
+void put_vector_2_matrix(double *f, double **i, int N)
+{
+  int l, j, k;
+  k = 0;
+  for (l = 0; l < N; l++)
+    for (j = 0; j < N; j++)
+      i[l][j] = f[k++];
+}
+
+void set_in_binary() {
+#if defined(EMX)
+  _fsetmode(in, "b");
+#elif defined(MINGW)
+  setmode(STDIN_FILENO, O_BINARY);
+#endif
+}
+
+void set_out_binary() {
+#if defined(EMX)  
+  _fsetmode(out, "b");
+#elif defined(MINGW)
+  setmode(STDOUT_FILENO, O_BINARY);
+#endif
+}
+ 
+void wm_init2() {
+  set_out_binary();
+}
+
+void wm_init1() {
+  set_in_binary();
+}
+
+void wm_init() {
+  set_in_binary();
+  set_out_binary();
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/common.h	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,28 @@
+#define PI      3.1415926535897932
+#define INVROOT2 0.7071067814
+
+void open_image(FILE *in, int *width, int *height);
+void load_image(int **im, FILE *in, int width, int height);
+void save_image(int **im, FILE *out, int width, int height);
+int ** imatrix(int nrows, int ncols);
+void freematrix(int **I, int rows);
+float ran0(long int *idum);
+float gasdev(long int *idum);
+void put_image_from_int_2_double(int **i, double *f, int N);
+void put_image_from_double_2_int(double *f, int **i, int N);
+void fct2d(double f[], int nrows, int ncols);
+void ifct2d(double f[], int nrows, int ncols);
+void matmul(double **a, double **b, double **r, int N);
+void hartley(double **in, double **out, int N);
+double ** dmatrix(int nrows, int ncols);
+void freematrix_d(double **I, int rows);
+void hartley(double **in, double **out, int N);
+void matrix_i2d(int **i, double **d, int N);
+void matrix_d2i(double **d, int **i, int N);
+void put_matrix_2_vector(double **i, double *f, int N);
+void put_vector_2_matrix(double *f, double **i, int N);
+double * dvector(long int N);
+
+void wm_init();   
+void wm_init1();   
+void wm_init2(); 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/test-hart.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,109 @@
+/* Watermarking program - Hartley Transform based	*/
+/* Module	: Testing				*/
+/* Author	: Vassilis Fotopoulos			*/
+/* Date		: 26/7/1999		      		*/
+/* Developed at	: ELLAB                 		*/
+/*                Electronics Laboratory            	*/
+/*                Department of Physics             	*/
+/*                University of Patras - GREECE      	*/
+/*		  Copyleft (c) 1999             	*/
+/*------------------------------------------------------*/
+/*	pseudorandom noise generator's code is		*/
+/*	taken from "Numerical Recipes in C"		*/
+/*------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <getopt.h>
+#include "common.h"
+
+int height, width;
+
+void read_watermark(double **in, int N, int coeff_start, int wm_length, double wm_alpha)
+{
+  int row, col, count;
+  long int elem, L, M, seed, i;
+  double a;
+  double z;
+  M = coeff_start;
+  L = wm_length;
+  a = wm_alpha;
+  for (i = 1; i <= 1000; i++) {
+    seed = i;
+    z = 0.0;
+    count = 0;
+    elem = 0;
+
+    for (row = 0; row < N; row++)
+      for (col = 0; col < N; col++) {
+        elem++;
+        if (elem > M && count < L) {
+          z += in[row][col] * gasdev(&seed);
+          count++;
+        }
+      }
+
+    printf("%ld\t%f\n", i, z / L);
+  }
+  return ;
+}
+
+int main(int argc, char* argv[])
+{
+  FILE *in;
+  int **image;
+  double **image_i;
+  double **image_d;
+  int c;
+  int N;
+  int coeff_start = 5000, wm_length = 10000;
+  double wm_alpha = 0.2;
+  int width, height;
+
+  pgm_init(&argc, argv); wm_init2();
+
+  while ((c = getopt(argc, argv, "a:s:l:")) != EOF) {
+    switch (c) {
+        case 'a':
+        wm_alpha = atof(optarg);
+        break;
+        case 's':
+        coeff_start = atoi(optarg);
+        break;
+        case 'l':
+        wm_length = atoi(optarg);
+        break;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+
+  in = stdin;
+
+  open_image(in, &width, &height);
+  image = imatrix(height, width);
+  load_image(image, in, width, height);
+
+  if (height == width)
+    N = height;
+  else {
+    fprintf(stderr, "Cannot Proccess non-square images!\n");
+    exit( -11);
+  }
+
+  image_i = dmatrix(height, width);
+  image_d = dmatrix(height, width);
+  if (image_d == NULL) {
+    fprintf(stderr, "Unable to allocate the double array\n");
+    exit(1);
+  }
+  matrix_i2d(image, image_i, N);
+  hartley(image_i, image_d, N);
+  read_watermark(image_d, N, coeff_start, wm_length, wm_alpha);
+
+  freematrix_d(image_i, height);
+  freematrix_d(image_d, height);
+  fclose(in);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/test-pv.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,127 @@
+/* Watermarking program - Fast Cosine Transform based	*/
+/* Module	: Testing				*/
+/* Author	: Vassilis Fotopoulos			*/
+/* Date		: 21/7/1999				*/
+/* Developed at	: ELLAB                  		*/
+/*                Electronics Laboratory            	*/
+/*                Department of Physics             	*/
+/*                University of Patras - GREECE      	*/
+/*		  Copyleft (c) 1999	    		*/
+/*		  Testing Program       		*/
+/*------------------------------------------------------*/
+/*	pseudorandom noise generator's code is		*/
+/*	taken from "Numerical Recipes in C"		*/
+/*	FCT implementation from the University of Bath	*/
+/*------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <getopt.h>
+#include "common.h"
+
+double cu[1024];
+double cv[1024];
+int height, width;
+
+void read_watermark(double *in, int N, int start_coeff, int wm_length, double wm_alpha)
+{
+  int row, col, count;
+  long int elem, L, M, temp, seed, i;
+  double a;
+  double z;
+  FILE *f;
+  M = start_coeff;
+  L = wm_length;
+  a = wm_alpha;
+  for (i = 1; i <= 1000; i++) {
+    seed = i;
+    z = 0.0;
+    count = 0;
+    elem = 0;
+    row = 2;
+    col = -1;
+    do {
+      do {
+        row--;
+        col++;
+        elem++;
+        if (col < N) {
+          if (elem > M) {
+            temp = row * N + col;
+            z += in[temp] * gasdev(&seed);
+            count++;
+          }
+        }
+      } while (row > 0);
+      row = 2 + col;
+      col = -1;
+    } while (count < L);
+    printf("%ld\t%f\n", i, z / L);
+  }
+  return ;
+}
+//--------------------------------------------------------
+void initialize_constants(void)
+{
+  int i;
+  cu[0] = cv[0] = 0.7071068;
+  for (i = 1; i < 1024; i++)
+    cu[i] = cv[i] = 1.0;
+}
+
+int main(int argc, char* argv[])
+{
+  FILE *in;
+  int **image_i;
+  double *image_f = NULL;
+  int N;
+  int c;
+  int coeff_start = 5000, wm_length = 10000;
+  double wm_alpha = 0.2;
+
+  pgm_init(&argc, argv); wm_init2();
+
+  while ((c = getopt(argc, argv, "a:s:l:")) != EOF) {
+    switch (c) {
+        case 'a':
+        wm_alpha = atof(optarg);
+        break;
+        case 's':
+        coeff_start = atoi(optarg);
+        break;
+        case 'l':
+        wm_length = atoi(optarg);
+        break;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+  in = stdin;
+
+  open_image(in, &width, &height);
+  image_i = imatrix(height, width);
+  load_image(image_i, in, width, height);
+
+  if (height == width)
+    N = height;
+  else {
+    fprintf(stderr, "Cannot Proccess non-square images!\n");
+    exit( -11);
+  }
+
+  initialize_constants();
+  image_f = (double *)calloc(N * N, sizeof(double));
+  if (image_f == NULL) {
+    printf("Unable to allocate the float array\n");
+    exit(1);
+  }
+
+  put_image_from_int_2_double(image_i, image_f, N);
+  fct2d(image_f, N, N);
+  read_watermark(image_f, N, coeff_start, wm_length, wm_alpha);
+  fclose(in);
+  freematrix(image_i, height);
+  free(image_f);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos/test-sub.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,237 @@
+/* Watermarking program - Subband DCT Transform based	*/
+/* Module	: Testing				*/
+/* Author	: Vassilis Fotopoulos			*/
+/* Date		: 25/4/2000				*/
+/* Revision	: 6.0					*/
+/* Developed at	: ELLAB                  		*/
+/*                Electronics Laboratory           	*/
+/*                Department of Physics             	*/
+/*                University of Patras - GREECE      	*/
+/*		  Copyleft (c) 1999	    		*/
+/*------------------------------------------------------*/
+/*	pseudorandom noise generator's code is		*/
+/*	taken from "Numerical Recipes in C"		*/
+/*	FCT implementation from University of Bath	*/
+/*------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <getopt.h>
+#include "common.h"
+
+//--------------------------------------------------------
+void add_hor_add_ver(double **in, int N, double **out);
+void add_hor_sub_ver(double **in, int N, double **out);
+void sub_hor_add_ver(double **in, int N, double **out);
+void sub_hor_sub_ver(double **in, int N, double **out);
+double detect_mark(double *i, int N, long key, long int L, long int M, double a);
+
+//--------------------------------------------------------
+double cu[1024];
+double cv[1024];
+int height, width;
+//--------------------------------------------------------
+void add_hor_add_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] + in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] + temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+//--------------------------------------------------------
+void add_hor_sub_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] + in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] - temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+//--------------------------------------------------------
+void sub_hor_add_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] - in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] + temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+//--------------------------------------------------------
+void sub_hor_sub_ver(double **in, int N, double **out)
+{
+  double **temp;
+  int r, c;
+  temp = dmatrix(N, N);
+  for (r = 0; r < N; r++)
+    for (c = 0; c < N / 2; c++)
+      temp[r][c] = (in[r][2 * c] - in[r][2 * c + 1]) / 2;
+  for (c = 0; c < N / 2; c++)
+    for (r = 0; r < N / 2; r++)
+      out[r][c] = (temp[2 * r][c] - temp[2 * r + 1][c]) / 2;
+  freematrix_d(temp, N);
+}
+
+//---------------------------------------------------------
+double detect_mark(double *i, int N, long key, long int L, long int M, double a)
+{
+  int row, col, count;
+  long int elem, temp, seed;
+  double z;
+
+
+  seed = key;
+  z = 0.0;
+  count = 0;
+  elem = 0;
+  row = 2;
+  col = -1;
+  do {
+    do {
+      row--;
+      col++;
+      elem++;
+      if (col < N) {
+        if (elem > M) {
+          temp = row * N + col;
+          z += i[temp] * gasdev(&seed);
+          count++;
+        }
+      }
+    } while (row > 0);
+    row = 2 + col;
+    col = -1;
+  } while (count < L);
+
+  return (z / L);
+}
+
+int main(int argc, char* argv[])
+{
+  double **i;
+  FILE *in;
+  int N;
+  long int key, M1, L1, M2, L2;
+  double **ll, **lh, **hl, **hh;
+  double *v1, *v2, *v3, *v99;
+  double m1, m2, m3, detect_value, m99;
+  int ** image_i;
+  int c;
+  int wm_length_1 = 10000, wm_length_ll = 10000, coeff_start_1 = 3000, coeff_start_ll = 3000;
+  double a_ll = 0.1, a_other = 0.2;
+
+  pgm_init(&argc, argv); wm_init2();
+
+  while ((c = getopt(argc, argv, "a:b:t:m:s:l:")) != EOF) {
+    switch (c) {
+        case 'a':
+        a_ll = atof(optarg);
+        break;
+        case 'b':
+        a_other = atof(optarg);
+        break;
+        case 't':
+        coeff_start_1 = atoi(optarg);
+        break;
+        case 'm':
+        wm_length_1 = atoi(optarg);
+        break;
+        case 's':
+        coeff_start_ll = atoi(optarg);
+        break;
+        case 'l':
+        wm_length_ll = atoi(optarg);
+        break;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+
+  in = stdin;
+  open_image(in, &width, &height);
+  image_i = imatrix(height, width);
+  load_image(image_i, in, width, height);
+
+  if (height == width)
+    N = height;
+  else {
+    fprintf(stderr, "Cannot Proccess non-square images!\n");
+    exit( -11);
+  }
+  // starting coeff. for 1st level decomp.
+  M1 = coeff_start_1;
+  // number of coeffs to alter
+  L1 = wm_length_1;
+  // alpha parameter
+
+  // now the LL band
+  M2 = coeff_start_ll;
+  L2 = wm_length_ll;
+
+
+  i = dmatrix(N, N);
+  ll = dmatrix(N / 2, N / 2);
+  lh = dmatrix(N / 2, N / 2);
+  hl = dmatrix(N / 2, N / 2);
+  hh = dmatrix(N / 2, N / 2);
+  v1 = dvector(N * N / 4);
+  v2 = dvector(N * N / 4);
+  v3 = dvector(N * N / 4);
+  v99 = dvector(N * N / 4);
+
+  matrix_i2d(image_i, i, N);
+
+  //---------------------1o decomposition-------------------
+  add_hor_add_ver(i, N, ll);
+  add_hor_sub_ver(i, N, lh);
+  sub_hor_add_ver(i, N, hl);
+  sub_hor_sub_ver(i, N, hh);
+  //---------------------Detect Watermark from all bands----
+  put_matrix_2_vector(lh, v1, N / 2);
+  put_matrix_2_vector(hl, v2, N / 2);
+  put_matrix_2_vector(hh, v3, N / 2);
+  put_matrix_2_vector(ll, v99, N / 2);
+  fct2d(v1, N / 2, N / 2);
+  fct2d(v2, N / 2, N / 2);
+  fct2d(v3, N / 2, N / 2);
+  fct2d(v99, N / 2, N / 2);
+  for (key = 1; key <= 1000; key++) {
+    m1 = detect_mark(v1, N / 2, key, L1, M1, a_other);
+    m2 = detect_mark(v2, N / 2, key, L1, M1, a_other);
+    m3 = detect_mark(v3, N / 2, key, L1, M1, a_other);
+    m99 = detect_mark(v99, N / 2, key, L2, M2, a_ll);
+    detect_value = (m1 + m2 + m3 + m99) / 4;
+    printf("%ld\t%f\t%f\t%f\t%f\t%f\n", key, m1, m2, m3, m99, detect_value);
+  }
+  //--------------------------------------------------------
+  free(v1);
+  free(v2);
+  free(v3);
+  free(v99);
+  freematrix_d(ll, N / 2);
+  freematrix_d(hl, N / 2);
+  freematrix_d(lh, N / 2);
+  freematrix_d(hh, N / 2);
+  fclose(in);
+}
+
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,36 @@
+# Makefile
+
+WEBDIR = /home/scicomp/pmeerw/public-www/Watermarking/source
+
+all: meerwald fotopoulos 
+
+meerwald:
+	cd Meerwald ; make
+
+fotopoulos:
+	cd Fotopoulos ; make
+
+install:
+	cd Meerwald ; make install
+	cd Fotopoulos ; make install
+
+clean:
+	cd Meerwald ; make clean
+	cd Fotopoulos ; make clean
+
+dist:
+	cp -v manual.pdf manual.ps $(WEBDIR)
+	cp -v ANNOUNCEMENT README $(WEBDIR)
+	cd linux_bin ; tar -czf ../wm_linux_bin.tar.gz *
+	mv -v wm_linux_bin.tar.gz $(WEBDIR)
+	cd win32_bin ; zip -9 ../wm_win32_bin.zip *
+	mv -v wm_win32_bin.zip $(WEBDIR)
+	tar -czf wm_source_bin.tar.gz *
+	mv -v wm_source_bin.tar.gz $(WEBDIR)
+	zip -9r wm_source_bin.zip *
+	mv -v wm_source_bin.zip $(WEBDIR)
+	tar -czf wm_source.tar.gz ANNOUNCEMENT Fotopoulos/* Meerwald/* Makefile README images/* make/* manual.* sigs/.dummy watermarked/.dummy wms/.dummy win32_bin/.dummy linux_bin/.dummy
+	mv -v wm_source.tar.gz $(WEBDIR)
+	zip -9r wm_source.zip ANNOUNCEMENT Fotopoulos/* Meerwald/* Makefile README images/* make/* manual.* sigs/.dummy watermarked/.dummy wms/.dummy linux_bin/.dummy win32_bin/.dummy
+	mv -v wm_source.zip $(WEBDIR)
+	chmod a+r $(WEBDIR)/*

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/Makefile	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,423 @@
+# Makefile
+
+# choose build platform
+include ../make/make.config
+
+all: 	tools \
+	bruyn \
+	koch \
+	corvi \
+	xia \
+	xie \
+	cox \
+	zhu \
+	dugad \
+	wang \
+	frid2 \
+	kim
+
+.SUFFIXES: .c .o .1 .ps
+
+.c$(O):
+	$(CC) $(CFLAGS) $(INCLUDES) -o $@ -c $<
+
+.1.ps:
+	$(GROFF) $< > $@ 
+
+# library containing general stuff
+
+$(LIBPREFIX)wm$(LIB): dct$(O) coeff$(O) gray$(O) sort$(O) signature$(O) coord$(O) wm$(O)
+	$(RM) $@
+	ar -rc $@ dct$(O) coeff$(O) gray$(O) sort$(O) signature$(O) coord$(O) wm$(O)
+
+libraryclean:
+	$(RM) $(LIBPREFIX)wm$(LIB)
+
+# library containing wavelet transform stuff
+
+$(LIBPREFIX)wavelet$(LIB): wavelet$(O) dwt$(O) dwt_util$(O)
+	$(RM) $@
+	ar -rc $@ wavelet$(O) dwt$(O) dwt_util$(O)
+
+waveletclean:
+	$(RM) $(LIBPREFIX)wavelet$(LIB)
+
+# some general tools to compute difference image, PSNR, ...
+
+tools: cmp_pgm$(EXE)  cmp_dct8x8$(EXE)  cmp_dct$(EXE) cmp_dwt$(EXE)
+
+toolstest:
+
+toolsinstall: tools
+	$(CP) cmp_pgm$(EXE)  cmp_dct8x8$(EXE)  cmp_dct$(EXE) cmp_dwt$(EXE) $(INSTALLDIR)
+
+toolsman: cmp_pgm.ps cmp_dct8x8.ps cmp_dct.ps
+
+toolsclean:
+	$(RM) cmp_pgm$(EXE) cmp_dct$(EXE) cmp_dct8x8$(EXE)
+
+cmp_pgm$(EXE):  cmp_pgm$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_pgm$(O) $(WMLIB) $(PGMLIBS)
+
+cmp_dct$(EXE):  cmp_dct$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_dct$(O) $(WMLIB) $(PGMLIBS)
+
+cmp_dwt$(EXE):  cmp_dwt$(O) $(LIBPREFIX)wavelet$(LIB)  $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_dwt$(O) $(WAVELIB) $(WMLIB) $(PGMLIBS)
+
+cmp_dct8x8$(EXE): cmp_dct8x8$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_dct8x8$(O) $(WMLIB) $(PGMLIBS)
+
+
+# Koch's algorithm (8x8 block DCT, blind, binary)
+
+koch: gen_koch_sig$(EXE) wm_koch_e$(EXE) wm_koch_d$(EXE) cmp_koch_sig$(EXE)
+
+kochtest: koch
+	gen_koch_sig$(EXE) -n 150 < gen_koch_sig.c > ../sigs/koch.sig
+	wm_koch_e$(EXE) -s ../sigs/koch.sig -o ../watermarked/koch_lena.pgm ../images/lena.pgm
+	wm_koch_d$(EXE) -s ../sigs/koch.sig -o ../wms/koch.wm ../watermarked/koch_lena.pgm
+	cmp_koch_sig$(EXE) -s ../sigs/koch.sig ../wms/koch.wm
+
+kochinstall: koch
+	$(CP) gen_koch_sig$(EXE) wm_koch_e$(EXE) wm_koch_d$(EXE) cmp_koch_sig$(EXE) $(INSTALLDIR)
+
+kochclean:
+	$(RM) gen_koch_sig$(EXE) wm_koch_e$(EXE) wm_koch_d$(EXE) cmp_koch_sig$(EXE)
+
+kochman:
+
+wm_koch_e$(EXE): wm_koch_e$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_koch_e$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+wm_koch_d$(EXE): wm_koch_d$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_koch_d$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+gen_koch_sig$(EXE): gen_koch_sig$(O) wm$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_koch_sig$(O) wm$(O) $(LIBS)
+
+cmp_koch_sig$(EXE): cmp_koch_sig$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_koch_sig$(O) $(WMLIB) $(LIBS)
+
+# Fridrich's 2. scheme (full-frame DCT, blind, binary)
+
+frid2: gen_frid2_sig$(EXE) wm_frid2_e$(EXE) wm_frid2_d$(EXE) cmp_frid2_sig$(EXE)
+
+frid2test: frid2
+	gen_frid2_sig$(EXE) -n 250 < gen_frid2_sig.c > ../sigs/frid2.sig
+	wm_frid2_e$(EXE) -s ../sigs/frid2.sig -o ../watermarked/frid2_lena.pgm ../images/lena.pgm
+	wm_frid2_d$(EXE) -s ../sigs/frid2.sig -o ../wms/frid2.wm ../watermarked/frid2_lena.pgm
+	cmp_frid2_sig$(EXE) -s ../sigs/frid2.sig ../wms/frid2.wm
+
+frid2install: frid2
+	$(CP) gen_frid2_sig$(EXE) wm_frid2_e$(EXE) wm_frid2_d$(EXE) cmp_frid2_sig$(EXE) $(INSTALLDIR)
+
+frid2clean:
+	$(RM) gen_frid2_sig$(EXE) wm_frid2_e$(EXE) wm_frid2_d$(EXE) cmp_frid2_sig$(EXE)
+
+frid2man:
+
+wm_frid2_e$(EXE): wm_frid2_e$(O) $(LIBPREFIX)wm$(LIB) frid2_common$(O)
+	$(CC) $(LDFLAGS) -o $@ wm_frid2_e$(O) frid2_common$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+wm_frid2_d$(EXE): wm_frid2_d$(O) $(LIBPREFIX)wm$(LIB) frid2_common$(O)
+	$(CC) $(LDFLAGS) -o $@  wm_frid2_d$(O) frid2_common$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+gen_frid2_sig$(EXE): gen_frid2_sig$(O) wm$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_frid2_sig$(O) wm$(O) $(LIBS)
+
+cmp_frid2_sig$(EXE): cmp_frid2_sig$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_frid2_sig$(O) $(WMLIB) $(LIBS)
+
+
+# Bruyndonckx's algorithm (spatial domain, block classification, blind)
+
+bruyn: gen_bruyn_sig$(EXE) wm_bruyn_e$(EXE) wm_bruyn_d$(EXE) cmp_bruyn_sig$(EXE)
+
+bruyntest: bruyn
+	gen_bruyn_sig$(EXE) -n 400 < gen_bruyn_sig.c > ../sigs/bruyn.sig
+	wm_bruyn_e$(EXE) -s ../sigs/bruyn.sig -o ../watermarked/bruyn_lena.pgm ../images/lena.pgm
+	wm_bruyn_d$(EXE) -s ../sigs/bruyn.sig -o ../wms/bruyn.wm ../watermarked/bruyn_lena.pgm
+	cmp_bruyn_sig$(EXE) -s ../sigs/bruyn.sig ../wms/bruyn.wm
+
+bruyninstall: bruyn
+	$(CP) gen_bruyn_sig$(EXE) wm_bruyn_e$(EXE) wm_bruyn_d$(EXE) cmp_bruyn_sig$(EXE) $(INSTALLDIR)
+
+bruynclean:
+	$(RM) gen_bruyn_sig$(EXE) wm_bruyn_e$(EXE) wm_bruyn_d$(EXE) cmp_bruyn_sig$(EXE)
+
+bruynman:
+
+wm_bruyn_e$(EXE): wm_bruyn_e$(O) bruyn_common$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_bruyn_e$(O) bruyn_common$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+wm_bruyn_d$(EXE): wm_bruyn_d$(O)  bruyn_common$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_bruyn_d$(O) bruyn_common$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+gen_bruyn_sig$(EXE): gen_bruyn_sig$(O) wm$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_bruyn_sig$(O) wm$(O) $(LIBS)
+
+cmp_bruyn_sig$(EXE): cmp_bruyn_sig$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_bruyn_sig$(O) $(WMLIB) $(LIBS)
+
+
+# Cox's algorithm (full-frame DCT, non-blind, spread-spectrum)
+
+cox: gen_cox_sig$(EXE) wm_cox_e$(EXE) wm_cox_d$(EXE) cmp_cox_sig$(EXE)
+
+coxtest: cox
+	gen_cox_sig$(EXE) > ../sigs/cox.sig
+	wm_cox_e$(EXE) -s ../sigs/cox.sig -o ../watermarked/cox_lena.pgm ../images/lena.pgm
+	wm_cox_d$(EXE) -s ../sigs/cox.sig -o ../wms/cox.wm -i ../images/lena.pgm ../watermarked/cox_lena.pgm 
+	cmp_cox_sig$(EXE) -s ../sigs/cox.sig ../wms/cox.wm
+
+coxinstall: cox
+	$(CP) gen_cox_sig$(EXE) wm_cox_e$(EXE) wm_cox_d$(EXE) cmp_cox_sig$(EXE) $(INSTALLDIR)
+
+coxman: gen_cox_sig.ps wm_cox_e.ps wm_cox_d.ps
+
+wm_cox_e$(EXE): wm_cox_e$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_cox_e$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+wm_cox_d$(EXE): wm_cox_d$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_cox_d$(O) $(WMLIB) $(LIBS) $(PGMLIBS)
+
+gen_cox_sig$(EXE): gen_cox_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_cox_sig$(O) $(LIBS)
+
+cmp_cox_sig$(EXE): cmp_cox_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ cmp_cox_sig$(O) $(LIBS)
+
+coxclean:
+	$(RM) gen_cox_sig$(EXE) wm_cox_e$(EXE) wm_cox_d$(EXE) cmp_cox_sig$(EXE)
+
+
+# Corvi's algorithm (DWT, non-blind, spread-spectrum, approximation image)
+
+corvi: gen_corvi_sig$(EXE) wm_corvi_e$(EXE) wm_corvi_d$(EXE) cmp_corvi_sig$(EXE)
+
+corvitest: corvi
+	gen_corvi_sig$(EXE) > ../sigs/corvi.sig
+	wm_corvi_e$(EXE) -s ../sigs/corvi.sig -o ../watermarked/corvi_lena.pgm ../images/lena.pgm
+	wm_corvi_d$(EXE) -s ../sigs/corvi.sig -o ../wms/corvi.wm -i ../images/lena.pgm ../watermarked/corvi_lena.pgm 
+	cmp_corvi_sig$(EXE) -s ../sigs/corvi.sig ../wms/corvi.wm
+
+corviinstall: corvi
+	$(CP) gen_corvi_sig$(EXE) wm_corvi_e$(EXE) wm_corvi_d$(EXE) cmp_corvi_sig$(EXE) $(INSTALLDIR)
+
+corviman: gen_corvi_sig.ps wm_corvi_e.ps wm_corvi_d.ps
+
+wm_corvi_e$(EXE): wm_corvi_e$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_corvi_e$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+wm_corvi_d$(EXE): wm_corvi_d$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_corvi_d$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+gen_corvi_sig$(EXE): gen_corvi_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_corvi_sig$(O) $(LIBS)
+
+cmp_corvi_sig$(EXE): cmp_corvi_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ cmp_corvi_sig$(O) $(LIBS)
+
+corviclean:
+	$(RM) gen_corvi_sig$(EXE) wm_corvi_e$(EXE) wm_corvi_d$(EXE) cmp_corvi_sig$(EXE)
+
+
+# Xia's algorithm (DWT, non-blind, spread-spectrum, detail subbands)
+
+xia: gen_xia_sig$(EXE) wm_xia_e$(EXE) wm_xia_d$(EXE) cmp_xia_sig$(EXE)
+
+xiatest: xia
+	gen_xia_sig$(EXE) > ../sigs/xia.sig
+	wm_xia_e$(EXE) -s ../sigs/xia.sig -o ../watermarked/xia_lena.pgm ../images/lena.pgm
+	wm_xia_d$(EXE) -s ../sigs/xia.sig -o ../wms/xia.wm -i ../images/lena.pgm ../watermarked/xia_lena.pgm 
+	cmp_xia_sig$(EXE) -s ../sigs/xia.sig ../wms/xia.wm
+
+xiainstall: xia
+	$(CP) gen_xia_sig$(EXE) wm_xia_e$(EXE) wm_xia_d$(EXE) cmp_xia_sig$(EXE) $(INSTALLDIR)
+
+xiaman: gen_xia_sig.ps wm_xia_e.ps wm_xia_d.ps
+
+wm_xia_e$(EXE): wm_xia_e$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_xia_e$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+wm_xia_d$(EXE): wm_xia_d$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_xia_d$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+gen_xia_sig$(EXE): gen_xia_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_xia_sig$(O) $(LIBS)
+
+cmp_xia_sig$(EXE): cmp_xia_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ cmp_xia_sig$(O) $(LIBS)
+
+xiaclean:
+	$(RM) gen_xia_sig$(EXE) wm_xia_e$(EXE) wm_xia_d$(EXE) cmp_xia_sig$(EXE)
+
+# Wang's algorithm (DWT, non-blind, spread-spectrum, detail subbands)
+
+wang: gen_wang_sig$(EXE) wm_wang_e$(EXE) wm_wang_d$(EXE) cmp_wang_sig$(EXE)
+
+wangtest: wang
+	gen_wang_sig$(EXE) -n 1000 > ../sigs/wang.sig
+	wm_wang_e$(EXE) -s ../sigs/wang.sig -o ../watermarked/wang_lena.pgm ../images/lena.pgm
+	wm_wang_d$(EXE) -s ../sigs/wang.sig -o ../wms/wang.wm -i ../images/lena.pgm ../watermarked/wang_lena.pgm 
+	cmp_wang_sig$(EXE) -s ../sigs/wang.sig ../wms/wang.wm
+
+wanginstall: wang
+	$(CP) gen_wang_sig$(EXE) wm_wang_e$(EXE) wm_wang_d$(EXE) cmp_wang_sig$(EXE) $(INSTALLDIR)
+
+wangman: gen_wang_sig.ps wm_wang_e.ps wm_wang_d.ps
+
+wm_wang_e$(EXE): wm_wang_e$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB) wang_common$(O)
+	$(CC) $(LDFLAGS) -o $@ wm_wang_e$(O) wang_common$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+wm_wang_d$(EXE): wm_wang_d$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB) wang_common$(O)
+	$(CC) $(LDFLAGS) -o $@  wm_wang_d$(O) wang_common$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+gen_wang_sig$(EXE): gen_wang_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_wang_sig$(O) $(LIBS)
+
+cmp_wang_sig$(EXE): cmp_wang_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ cmp_wang_sig$(O) $(LIBS)
+
+wangclean:
+	$(RM) gen_wang_sig$(EXE) wm_wang_e$(EXE) wm_wang_d$(EXE) cmp_wang_sig$(EXE)
+
+# Kim's algorithm (DWT, non-blind, spread-spectrum, approx. & detail subbands)
+
+kim: gen_kim_sig$(EXE) wm_kim_e$(EXE) wm_kim_d$(EXE) cmp_kim_sig$(EXE)
+
+kimtest: kim
+	gen_kim_sig$(EXE) -n 1000 > ../sigs/kim.sig
+	wm_kim_e$(EXE) -s ../sigs/kim.sig -o ../watermarked/kim_lena.pgm ../images/lena.pgm
+	wm_kim_d$(EXE) -s ../sigs/kim.sig -o ../wms/kim.wm -i ../images/lena.pgm ../watermarked/kim_lena.pgm 
+	cmp_kim_sig$(EXE) -s ../sigs/kim.sig ../wms/kim.wm
+
+kiminstall: kim
+	$(CP) gen_kim_sig$(EXE) wm_kim_e$(EXE) wm_kim_d$(EXE) cmp_kim_sig$(EXE) $(INSTALLDIR)
+
+kimman: gen_kim_sig.ps wm_kim_e.ps wm_kim_d.ps
+
+wm_kim_e$(EXE): wm_kim_e$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB) kim_common$(O)
+	$(CC) $(LDFLAGS) -o $@ wm_kim_e$(O) kim_common$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+wm_kim_d$(EXE): wm_kim_d$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB) kim_common$(O)
+	$(CC) $(LDFLAGS) -o $@  wm_kim_d$(O) kim_common$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+gen_kim_sig$(EXE): gen_kim_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_kim_sig$(O) $(LIBS)
+
+cmp_kim_sig$(EXE): cmp_kim_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ cmp_kim_sig$(O) $(LIBS)
+
+kimclean:
+	$(RM) gen_kim_sig$(EXE) wm_kim_e$(EXE) wm_kim_d$(EXE) cmp_kim_sig$(EXE)
+
+# Zhu's algorithm (DWT, non-blind, spread-spectrum, detail subbands)
+
+zhu: gen_zhu_sig$(EXE) wm_zhu_e$(EXE) wm_zhu_d$(EXE) cmp_zhu_sig$(EXE)
+
+zhutest: zhu
+	gen_zhu_sig$(EXE) > ../sigs/zhu.sig
+	wm_zhu_e$(EXE) -s ../sigs/zhu.sig -o ../watermarked/zhu_lena.pgm ../images/lena.pgm
+	wm_zhu_d$(EXE) -s ../sigs/zhu.sig -o ../wms/zhu.wm -i ../images/lena.pgm ../watermarked/zhu_lena.pgm 
+	cmp_zhu_sig$(EXE) -s ../sigs/zhu.sig ../wms/zhu.wm
+
+zhuinstall: zhu
+	$(CP) gen_zhu_sig$(EXE) wm_zhu_e$(EXE) wm_zhu_d$(EXE) cmp_zhu_sig$(EXE) $(INSTALLDIR)
+
+zhuman: gen_zhu_sig.ps wm_zhu_e.ps wm_zhu_d.ps
+
+wm_zhu_e$(EXE): wm_zhu_e$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_zhu_e$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+wm_zhu_d$(EXE): wm_zhu_d$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_zhu_d$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+gen_zhu_sig$(EXE): gen_zhu_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_zhu_sig$(O) $(LIBS)
+
+cmp_zhu_sig$(EXE): cmp_zhu_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ cmp_zhu_sig$(O) $(LIBS)
+
+zhuclean:
+	$(RM) gen_zhu_sig$(EXE) wm_zhu_e$(EXE) wm_zhu_d$(EXE) cmp_zhu_sig$(EXE)
+
+# Xie's algorithm (DWT, blind, binary, quantization, approximation image)
+
+xie: gen_xie_sig$(EXE) wm_xie_e$(EXE) wm_xie_d$(EXE) cmp_xie_sig$(EXE)
+
+xietest: xie
+	gen_xie_sig$(EXE) -n 800 gen_xie_sig.c > ../sigs/xie.sig
+	wm_xie_e$(EXE) -s ../sigs/xie.sig -o ../watermarked/xie_lena.pgm ../images/lena.pgm
+	wm_xie_d$(EXE) -s ../sigs/xie.sig -o ../wms/xie.wm ../watermarked/xie_lena.pgm 
+	cmp_xie_sig$(EXE) -s ../sigs/xie.sig ../wms/xie.wm
+
+xieinstall: xie
+	$(CP) gen_xie_sig$(EXE) wm_xie_e$(EXE) wm_xie_d$(EXE) cmp_xie_sig$(EXE) $(INSTALLDIR)
+
+xieman: gen_xie_sig.ps wm_xie_e.ps wm_xie_d.ps
+
+wm_xie_e$(EXE): wm_xie_e$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_xie_e$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+wm_xie_d$(EXE): wm_xie_d$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_xie_d$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+gen_xie_sig$(EXE): gen_xie_sig$(O) wm$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_xie_sig$(O) wm$(O) $(LIBS)
+
+cmp_xie_sig$(EXE): cmp_xie_sig$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_xie_sig$(O) $(WMLIB) $(LIBS)
+
+xieclean:
+	$(RM) gen_xie_sig$(EXE) wm_xie_e$(EXE) wm_xie_d$(EXE) cmp_xie_sig$(EXE)
+
+# Dugad's algorithm (DWT, blind)
+
+dugad: gen_dugad_sig$(EXE) wm_dugad_e$(EXE) wm_dugad_d$(EXE) cmp_dugad_sig$(EXE)
+
+dugadtest: dugad
+	gen_dugad_sig$(EXE) -o ../sigs/dugad.sig
+	wm_dugad_e$(EXE) -s ../sigs/dugad.sig -o ../watermarked/dugad_lena.pgm ../images/lena.pgm
+	wm_dugad_d$(EXE) -s ../sigs/dugad.sig -o ../wms/dugad.wm ../watermarked/dugad_lena.pgm 
+	cmp_dugad_sig$(EXE) -s ../sigs/dugad.sig ../wms/dugad.wm
+
+dugadinstall: dugad
+	$(CP) gen_dugad_sig$(EXE) wm_dugad_e$(EXE) wm_dugad_d$(EXE) cmp_dugad_sig$(EXE) $(INSTALLDIR)
+
+dugadman: gen_dugad_sig.ps wm_dugad_e.ps wm_dugad_d.ps
+
+wm_dugad_e$(EXE): wm_dugad_e$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@ wm_dugad_e$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+wm_dugad_d$(EXE): wm_dugad_d$(O) $(LIBPREFIX)wm$(LIB) $(LIBPREFIX)wavelet$(LIB)
+	$(CC) $(LDFLAGS) -o $@  wm_dugad_d$(O) $(WMLIB) $(WAVELIB) $(LIBS) $(PGMLIBS)
+
+gen_dugad_sig$(EXE): gen_dugad_sig$(O)
+	$(CC) $(LDFLAGS) -o $@ gen_dugad_sig$(O) $(LIBS)
+
+cmp_dugad_sig$(EXE): cmp_dugad_sig$(O) $(LIBPREFIX)wm$(LIB)
+	$(CC) $(LDFLAGS) -o $@ cmp_dugad_sig$(O) $(WMLIB) $(LIBS)
+
+dugadclean:
+	$(RM) gen_dugad_sig$(EXE) wm_dugad_e$(EXE) wm_dugad_d$(EXE) cmp_dugad_sig$(EXE)
+
+
+
+clean:	coxclean bruynclean kochclean corviclean xiaclean zhuclean xieclean \
+	dugadclean kimclean wangclean frid2clean toolsclean libraryclean waveletclean
+	$(RM) *$(O) *.ps ../sigs/* ../wms/* ../watermarked/* 
+	
+
+man:	coxman bruynman kochman corviman xiaman xieman toolsman
+
+test:	coxtest bruyntest kochtest corvitest xiatest xietest dugadtest zhutest \
+	wangtest frid2test kimtest toolstest
+
+install: coxinstall bruyninstall kochinstall corviinstall xiainstall xieinstall \
+	dugadinstall zhuinstall wanginstall frid2install kiminstall toolsinstall
+
+depend:
+	$(MAKEDEP) *.h *.c
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/README	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,157 @@
+This package provides source code for some watermarking algorithms in portable
+C code. Currently it includes the following
+
+  watermarking algorithms
+
+    Bruyndonckx
+      refer to
+        O. Bruyndonckx, Jean-Jacques Quisquater, and Benoit M. Macq. 
+        Spatial method for copyright labeling of digital images. 
+        In IEEE Workshop on Nonlinear Signal and Image Processing '95, 
+        Thessaloniki, Greece, pages 456 - 459, 1995. 
+
+    Corvi
+      refer to
+        Marco Corvi and Gianluca Nicchiotti. 
+        Wavelet-based image watermarking for copyright protection. 
+        In Scandinavian Conference on Image Analysis SCIA '97, Lappeenranta, 
+        Finland, June 1997. 
+
+    Cox 
+      refer to
+	Ingemar J. Cox, Joe Kilian, Tom Leighton, and Talal G. Shamoon. 
+	Secure spread spectrum watermarking for multimedia. 
+	In Proceedings of the IEEE ICIP '97, 
+	volume 6, pages 1673 - 1687, Santa Barbara, California, USA, 1997. 
+
+    Dugad
+      refer to
+        Rakesh Dugad, Krishna Ratakonda, and Narendra Ahuja.
+        A new wavelet-based scheme for watermarking images. In Proceedings of
+        the IEEE International Conference on Image Processing, ICIP '98,
+        Chicago, IL, USA, October 1998.
+
+    Fridrich (2. scheme)
+      refer to
+        Jiri Fridrich.
+        Combining low-frequency and spread spectrum watermarking. In
+        Proceedings of the SPIE Symposium on Optical Science, Engineering and
+        Instrumentation, San Diego, USA, July 1998.
+
+    Koch
+      refer to
+        Eckhard Koch and Jian Zhao. 
+        Towards robust and hidden image copyright labeling. 
+        In Proceedings of the IEEE International Workshop on Nonlinear 
+        Signal and Image Processing, pages 452 - 455, Halkidiki, Marmaras, 
+        Greece, June 1995. 
+
+    Kim
+      refer to
+        Jong Ryul Kim and Young Shik Moon. 
+        A robust wavelet-based digital watermark using level-adaptive
+        thresholding. In Proceedings of the 6th IEEE International
+        Conference on Image Processing ICIP '99, page 202,
+        Kobe, Japan, October 1999. 
+
+    Wang
+      refer to
+        Houng-Jyh Wang, Po-Chyi Su, and C.-C. Jay Kuo.
+        Wavelet-based digital image watermarking. Optics Express, 3
+        pp. 497, December 1998.
+
+    Xia
+      refer to
+        Xiang-Gen Xia, Charles G. Boncelet, and Gonzalo R. Arce. 
+        Wavelet transform based watermark for digital images. Optics Express, 3
+        pp. 497, December 1998. 
+
+    Xie
+      refer to
+        Liehua Xie and Gonzalo R. Arce. 
+        Joint wavelet compression and authentication watermarking. In 
+        Proceedings of the IEEE International Conference on Image Processing, 
+        ICIP '98, Chicago, IL, USA, 1998. 
+
+    Zhu
+      refer to
+       Wenwu Zhu, Zixiang Xiong, and Ya-Qin Zhang.
+       Multiresolution watermarking for images and video: a unified approach.
+       In Proceedings of the IEEE International Conference o
+
+    many more algorithms to come! 
+    see what is in stock: http://www.cosy.sbg.ac.at/~pmeerw/Watermarking
+
+  and utility programs
+
+    cmp_pgm	- compute difference image, PSNR, ...
+    cmp_dct	- compute full-frame DCT domain difference image
+    cmp_dct8x8  - compute 8x8 block-based DCT difference image
+    cmp_dwt     - compute DWT domain difference image
+
+What do I need?
+
+Unix (Linux), a reasonable C compiler (GCC), and the netpbm library which you 
+can get at http://wuarchive.wustl.edu/graphics/graphics/packages/NetPBM/
+
+
+Directions: How do I use the stuff?
+
+look at the MAKEFILE...
+each algorithms has at least 4 files: gen_algo_sig.c, wm_algo_e.c, wm_algo_d.c,
+cmp_algo_sig.c where 'algo' is the name of the actual watermarking algorithm 
+(usually the principal author's name), where might also be some common files 
+for each algorithm, algo_common.{c|h}, and some support files for sorting,
+the DCT, ...
+
+just try
+  
+  make
+  make test
+
+next, try to run each program with the -h parameter to find out what options 
+are supported - the programs are pretty consistent and have reasonable
+default settings
+
+e.g. 
+
+  wm_cox_e -h
+
+The programs all support standard input and standard output, the only
+supported image file format is PGM for grayscale images and PPM for color
+images; most programs have only been tested with 512x512 images.
+You can find the Lena image in PGM format in the images/ sub-directory.
+
+
+Disclaimer: #include <disclaimer.h>
+
+Feel free to use the accompaigning code for your research! However, I do
+not guarantee for anything, in particular parts of the provided code may
+be covered by copyrights of a third party or by patent claims. I do not
+guarantee for any functionality, bla-bla, ...
+
+If you use the accompanying code, please cite my thesis:
+
+  Peter Meerwald, Digital Image Watermarking in the Wavelet Transform Domain, 
+  Master's Thesis, Department of Scientific Computing, University of Salzburg,
+  Austria, January 2001.
+
+
+Contact: Comments are welcome!
+
+More algorithms will be added over time, I have implemented about 13
+watermarking algorithms in the spatial-, DCT-, and wavelet domain so far.
+Please report what problems you have, suggestions, ...
+
+Peter Meerwald
+
+Dept. of Scientific Computing
+University of Salzburg
+Jakob-Haringer-Str. 2
+A-5020 Salzburg 
+AUSTRIA
+
+pmeerw@cosy.sbg.ac.at
+http://www.cosy.sbg.ac.at/~pmeerw/Watermarking
+
++43-662-8044-6327

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/bruyn_common.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,44 @@
+#include "bruyn_common.h"
+
+gray lookup_pattern(int pattern, int c, int r) {
+#define A CATEGORY_A
+#define B CATEGORY_B
+
+  gray pattern1[4][4] =
+    {{A, A, B, B},
+     {A, A, B, B},
+     {B, B, A, A},
+     {B, B, A, A}};
+
+  gray pattern2[8][8] =
+    {{B, B, B, B, A, A, A, A},
+     {B, B, B, B, A, A, A, A},
+     {B, B, B, B, A, A, A, A},
+     {B, B, B, B, A, A, A, A},
+     {A, A, A, A, B, B, B, B},
+     {A, A, A, A, B, B, B, B},
+     {A, A, A, A, B, B, B, B},
+     {A, A, A, A, B, B, B, B}};
+
+  gray pattern3[2][2] =
+    {{A, B}, {B, A}};
+
+#undef A
+#undef B
+
+  switch (pattern) {
+    case 1:
+      return pattern1[r % 4][c % 4];
+      break;
+    case 2:
+      return pattern2[r % 8][c % 8];
+      break;
+    case 3:
+      return pattern3[r % 2][c % 2];
+      break;
+  }
+
+  return CATEGORY_VOID;
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/bruyn_common.h	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,41 @@
+#ifndef BRUYN_COMMON_H
+#define BRUYN_COMMON_H
+
+#include "pgm.h"
+
+// for block type classification
+#define BLOCKTYPE_UNKNOWN 0
+#define BLOCKTYPE_HARD 1
+#define BLOCKTYPE_PROGRESSIVE 2
+#define BLOCKTYPE_NOISE 3
+
+// thresholds
+#define THRESHOLD_NOISE 10.0
+#define THRESHOLD_SLOPE 5.0
+#define THRESHOLD_NOISE_USAGE "10.0"
+#define THRESHOLD_SLOPE_USAGE "5.0"
+
+// zone classification
+#define ZONE_VOID 0
+#define ZONE_1 1
+#define ZONE_2 2
+
+// category classification
+#define CATEGORY_VOID 0
+#define CATEGORY_A 4
+#define CATEGORY_B 8
+
+// classifiction = zone | category
+#define CLASSIFICATION_1A (ZONE_1 | CATEGORY_A)
+#define CLASSIFICATION_1B (ZONE_1 | CATEGORY_B)
+#define CLASSIFICATION_2A (ZONE_2 | CATEGORY_A)
+#define CLASSIFICATION_2B (ZONE_2 | CATEGORY_B)
+#define CLASSIFICATION_A CATEGORY_A
+#define CLASSIFICATION_B CATEGORY_B
+
+#define NPATTERN 3
+#define NPATTERN_USAGE "3"
+
+gray lookup_pattern(int pattern, int c, int r);
+
+#endif BRUYN_COMMON_H

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/cmp_bruyn_sig.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,150 @@
+#include "wm.h"
+#include "signature.h"
+
+char *progname;
+
+void usage(void) {
+  fprintf(stderr, "usage: %s [-h] [-C] [-o file] [-v n] -s file file\n\n", progname);
+  fprintf(stderr, "\t-C\t\toutput correlation only\n");
+  fprintf(stderr, "\t-h\t\tprint usage\n");
+  fprintf(stderr, "\t-o file\t\toutput file\n");
+  fprintf(stderr, "\t-s file\t\toriginal signature file\n");
+  fprintf(stderr, "\t-v n\t\tverbosity level\n");
+  exit(0);
+}
+
+int main(int argc, char *argv[]) {
+
+  FILE *in = stdin;
+  FILE *out = stdout;
+  FILE *sig = NULL;
+
+  char signature_name[MAXPATHLEN];
+  char output_name[MAXPATHLEN] = "(stdout)";
+  char input_name[MAXPATHLEN] = "(stdin)";
+
+  int c, i;
+  int pattern1, pattern2;
+  double quality;
+  double threshold1, threshold2;
+  int blocksize;
+  int corr = 0, match = 0;
+  int verbose = 0;
+  int skipping = 0;
+
+  int correlation_only = 0;
+
+  int seed;
+  char line[32];
+
+  progname = argv[0];
+
+  while ((c = getopt(argc, argv, "h?Co:s:v:")) != EOF) {
+    switch (c) {
+      case 'h':
+      case '?':
+        usage();
+        break; 
+      case 'C':
+        correlation_only = 1;
+        break;
+      case 'o':
+        if ((out = fopen(optarg, "w")) == NULL) {
+          fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(output_name, optarg);
+        break;
+      case 's':
+        if ((sig = fopen(optarg, "r")) == NULL) {
+          fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(signature_name, optarg);
+        break;
+     case 'v':
+        verbose = atoi(optarg);
+        if (verbose < 0) {
+          fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose);
+          exit(1);
+        }
+        break;
+    }
+  }
+
+  argc -= optind;
+  argv += optind;
+
+  if (argc > 1) {
+    usage();
+    exit(1);
+  }
+
+  if (argc == 1 && *argv[0] != '-')
+    if ((in = fopen(argv[0], "r")) == NULL) {
+      fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]);
+      exit(1);
+    }
+    else
+      strcpy(input_name, argv[0]);
+
+  if (sig) {
+    fgets(line, sizeof(line), sig);
+    if (strspn(line, "BRSG") >= 4) {
+      fscanf(sig, "%d\n", &nbit_signature1);
+      fscanf(sig, "%d\n", &skipping);
+      fscanf(sig, "%d\n", &pattern1);
+      fscanf(sig, "%d\n", &pattern2);
+      fscanf(sig, "%lf\n", &quality);
+      fscanf(sig, "%lf\n", &threshold1);
+      fscanf(sig, "%lf\n", &threshold2);
+      fscanf(sig, "%d\n", &blocksize);
+      fscanf(sig, "%d\n", &seed);
+      srandom(seed);
+      n_signature1 = NBITSTOBYTES(nbit_signature1);
+      fread(signature1, sizeof(char), n_signature1, sig);
+      fscanf(sig, "\n");
+    }
+    else {
+      fprintf(stderr, "%s: invalid signature file %s\n", progname, signature_name);
+      exit(1);
+    }
+    close(sig);
+  }
+  else {
+    fprintf(stderr, "%s: original signature file not specified, use -s file option\n", progname);
+    exit(1);
+  }
+
+  fgets(line, sizeof(line), in);
+  if (strspn(line, "BRWM") >= 4) {
+    fscanf(in, "%d\n", &nbit_signature2);
+    n_signature2 = NBITSTOBYTES(nbit_signature2);
+    fread(signature2, sizeof(char), n_signature2, in);
+    fscanf(in, "\n");    
+  }
+  else {
+    fprintf(stderr, "%s: invalid watermark file %s\n", progname, input_name);
+    exit(1);
+  }
+
+  if (verbose > 0) {
+    fprintf(stderr, "signature length: %d\n", nbit_signature1);
+    fprintf(stderr, "watermark length: %d\n", nbit_signature2);
+  }
+
+  for (i = 0; i < nbit_signature2; i++)
+    if (get_signature1_bit(i % nbit_signature1) == get_signature2_bit(i))
+      corr++, match++;
+    else
+      corr--;
+
+  if (correlation_only)
+    fprintf(out, "%lf\n", (double) corr / nbit_signature2);
+  else {
+    fprintf(out, "bit matches: %d/%d\n", match, nbit_signature2);
+    fprintf(out, "correlation: %lf\n", (double) corr / nbit_signature2);
+  }
+
+  exit(0);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/cmp_corvi_sig.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,159 @@
+#include "wm.h"
+
+char *progname;
+
+void usage(void) {
+  fprintf(stderr, "usage: %s [-h] [-C] [-o file] [-v n] -s file file\n\n", progname);
+  fprintf(stderr, "\t-C\t\toutput correlation only\n");
+  fprintf(stderr, "\t-h\t\tprint usage\n");
+  fprintf(stderr, "\t-o file\t\toutput file\n");
+  fprintf(stderr, "\t-v n\t\tverbosity level\n");
+  fprintf(stderr, "\t-s file\t\toriginal signature file\n");
+  exit(0);
+}
+
+int main(int argc, char *argv[]) {
+
+  FILE *in = stdin;
+  FILE *out = stdout;
+  FILE *sig = NULL;
+
+  char signature_name[MAXPATHLEN];
+  char output_name[MAXPATHLEN] = "(stdout)";
+  char input_name[MAXPATHLEN] = "(stdin)";
+
+  int c;
+  int sig_n, in_n;
+  double s1, s2, s3;
+  char line[32];
+  int matches;
+
+  int verbose = 0;
+  int correlation_only = 0;
+
+  progname = argv[0];
+
+  while ((c = getopt(argc, argv, "h?o:s:v:C")) != EOF) {
+    switch (c) {
+      case 'h':
+      case '?':
+        usage();
+        break;
+      case 'o':
+        if ((out = fopen(optarg, "w")) == NULL) {
+          fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(output_name, optarg);
+        break;
+      case 's':
+        if ((sig = fopen(optarg, "r")) == NULL) {
+          fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(signature_name, optarg);
+        break;
+     case 'v':
+        verbose = atoi(optarg);
+        if (verbose < 0) {
+          fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose);
+          exit(1);
+        }
+        break;
+     case 'C':
+        correlation_only = 1;
+        break;
+    }
+  }
+
+  argc -= optind;
+  argv += optind;
+
+  if (argc > 1) {
+    usage();
+    exit(1);
+  }
+
+  if (argc == 1 && *argv[0] != '-')
+    if ((in = fopen(argv[0], "r")) == NULL) {
+      fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]);
+      exit(1);
+    }
+    else
+      strcpy(input_name, argv[0]);
+
+  if (!sig) {
+    fprintf(stderr, "%s: original signature file not specified, use -s file option\n", progname);
+    exit(1);
+  }
+
+  fgets(line, sizeof(line), sig);
+  if (strspn(line, "CVSG") < 4) {
+    fprintf(stderr, "%s: original signature file %s invalid\n", progname, signature_name);
+    exit(1);
+  }
+
+  fgets(line, sizeof(line), in);
+  if (strspn(line, "CVWM") < 4) {
+    fprintf(stderr, "%s: signature file %s invalid\n", progname, input_name);
+    exit(1);
+  }
+
+  fscanf(sig, "%d\n", &sig_n);
+  fscanf(in, "%d\n", &in_n);
+  if (sig_n != in_n) {
+    fprintf(stderr, "%s: watermark length mismatch (original %d, input %d)\n", progname, sig_n, in_n);
+    exit(1);
+  }
+  if (sig_n <= 0 || sig_n > 1000) {
+    fprintf(stderr, "%s: invalid original watermark length %d\n", progname, sig_n);
+    exit(1);
+  }
+  if (in_n <= 0 || in_n > 1000) {
+    fprintf(stderr, "%s: invalid watermark length %d\n", progname, in_n);
+    exit(1);
+  }
+
+  fscanf(sig, "%*lf\n");
+  fscanf(sig, "%*d\n");
+  fscanf(sig, "%*d\n");
+  fscanf(sig, "%*[^\n\r]\n");
+
+  /*
+   * normalized correlation
+   * Craver, S., "Can Invisible Watermarks Resolve Rightful Ownership?", IBM Research Report, 1996, p. 5
+   */
+
+  s1 = s2 = s3 = 0.0;
+  matches = 0;
+  while (in_n > 0) {
+    double sig_x, in_x;
+
+    fscanf(sig, "%lf\n", &sig_x);
+    fscanf(in, "%lf\n", &in_x);
+
+    matches += SIGN(sig_x * in_x);
+
+    if (verbose >= 1) {
+      fprintf(stderr, "orig %f input %f\n", sig_x, in_x);
+    }
+
+    s1 += sig_x * in_x;
+    s2 += in_x * in_x;
+    s3 += sig_x * sig_x;
+
+    in_n--;
+  }
+
+  if (!correlation_only) {
+    fprintf(out, "%s: correlation %f, hamming distance %f\n", progname, s1 / sqrt(s2 * s3), (double) matches / sig_n);
+  }
+  else
+    fprintf(out, "%f\n", (double) matches / sig_n);
+
+  fclose(sig);
+  fclose(out);
+  fclose(in);
+
+  exit(0);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/cmp_cox_sig.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,153 @@
+#include "wm.h"
+
+char *progname;
+
+void usage(void) {
+  fprintf(stderr, "usage: %s [-h] [-C] [-o file] [-v n] -s file file\n\n", progname);
+  fprintf(stderr, "\t-C\t\toutput correlation only\n");
+  fprintf(stderr, "\t-h\t\tprint usage\n");
+  fprintf(stderr, "\t-o file\t\toutput file\n");
+  fprintf(stderr, "\t-s file\t\toriginal signature file\n");
+  fprintf(stderr, "\t-v n\t\tverbosity level\n");
+  exit(0);
+}
+
+int main(int argc, char *argv[]) {
+
+  FILE *in = stdin;
+  FILE *out = stdout;
+  FILE *sig = NULL;
+
+  char signature_name[MAXPATHLEN];
+  char output_name[MAXPATHLEN] = "(stdout)";
+  char input_name[MAXPATHLEN] = "(stdin)";
+
+  int c;
+  int sig_n, in_n;
+  double sig_a, in_a;
+  double sig_mean, sig_variance;
+  double s1, s2, s3;
+  char line[32];
+ 
+  int verbose = 0;
+  int correlation_only = 0;
+
+  progname = argv[0];
+
+  while ((c = getopt(argc, argv, "h?Co:s:v:")) != EOF) {
+    switch (c) {
+      case 'h':
+      case '?':
+        usage();
+        break;
+      case 'C':
+        correlation_only = 1;
+        break;
+      case 'o':
+        if ((out = fopen(optarg, "w")) == NULL) {
+          fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(output_name, optarg);
+        break;
+      case 's':
+        if ((sig = fopen(optarg, "r")) == NULL) {
+          fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(signature_name, optarg);
+        break;
+     case 'v':
+        verbose = atoi(optarg);
+        if (verbose < 0) {
+          fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose);
+          exit(1);
+        }
+        break;
+    }
+  }
+
+  argc -= optind;
+  argv += optind;
+
+  if (argc > 1) {
+    usage();
+    exit(1);
+  }
+
+  if (argc == 1 && *argv[0] != '-')
+    if ((in = fopen(argv[0], "r")) == NULL) {
+      fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]);
+      exit(1);
+    }
+    else
+      strcpy(input_name, argv[0]);
+
+  if (!sig) {
+    fprintf(stderr, "%s: original signature file not specified, use -s file option\n", progname);
+    exit(1);
+  }
+
+  fgets(line, sizeof(line), sig);
+  if (strspn(line, "CXSG") < 4) {
+    fprintf(stderr, "%s: original signature file %s invalid\n", progname, signature_name);
+    exit(1);
+  }
+
+  fgets(line, sizeof(line), in);
+  if (strspn(line, "CXWM") < 4) {
+    fprintf(stderr, "%s: watermark file %s invalid\n", progname, input_name);
+    exit(1);
+  }
+
+  fscanf(sig, "%d\n", &sig_n);
+  fscanf(in, "%d\n", &in_n);
+  if (sig_n != in_n) {
+    fprintf(stderr, "%s: watermark length mismatch (original %d, input %d)\n", progname, sig_n, in_n);
+    exit(1);
+  }
+  if (sig_n <= 0 || sig_n > 32000) {
+    fprintf(stderr, "%s: invalid original watermark length %d\n", progname, sig_n);
+    exit(1);
+  }
+  if (in_n <= 0 || in_n > 32000) {
+    fprintf(stderr, "%s: invalid watermark length %d\n", progname, in_n);
+    exit(1);
+  }
+
+  fscanf(sig, "%lf\n", &sig_a);
+
+  fscanf(sig, "%lf\n", &sig_mean);
+  fscanf(sig, "%lf\n", &sig_variance);
+
+  /*
+   * normalized correlation
+   * Craver, S., "Can Invisible Watermarks Resolve Rightful Ownership?", IBM Research Report, 1996, p. 5
+   */
+
+  s1 = s2 = s3 = 0.0;
+  while (in_n > 0) {
+    double sig_x, in_x;
+
+    fscanf(sig, "%lf\n", &sig_x);
+    fscanf(in, "%lf\n", &in_x);
+
+    if (verbose >= 1) {
+      fprintf(stderr, "orig %f input %f\n", sig_x, in_x);  
+    }
+
+    s1 += sig_x * in_x;
+    s2 += in_x * in_x;
+    s3 += sig_x * sig_x;
+
+    in_n--;
+  }
+
+  fprintf(out, "%f\n", s1 / sqrt(s2 * s3));
+
+  fclose(sig);
+  fclose(out);
+  fclose(in);
+
+  exit(0);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/cmp_dct.1	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,79 @@
+.\"
+.\" cmp_dct.1 - the *roff document processor man page source
+.\"
+.TH cmp_dct 1 "98/07/08" "Watermarking, Version 1.0"
+.SH NAME
+cmp_dct \- a program to create the difference image of the
+frequency domain of two PGM images
+.SH SYNOPSIS
+.B cmp_dct
+[
+.B \-h
+]
+[
+.BI \-m \ number
+]
+[
+.BI \-o \ ofile
+]
+.BI \-i \ ifile
+.I file
+.SH DESCRIPTION
+.B cmp_dct
+is a program to create the difference image of the
+frequency domain of two PGM (portable graymap) grayscale
+images. To compare images in the spatial domain, either in
+PPM (portable pixmap) format for RGB color images or in PGM (portable
+graymap) format for grayscale images, use the
+.B cmp_ppm
+program or the
+.B cmp_pgm
+program, respectively.
+.PP
+If
+.I file
+or
+.I ofile
+is not specified, then standard input or standard output is
+used.
+.PP
+.SH OPTIONS
+.TP
+.B \-h
+Print a help message.
+.TP
+.BI \-i \ ifile
+The original image. Mandatory.
+.TP
+.BI \-m \ number
+Multiplication factor to magnify differences between the to
+original and input image.
+Default value: 16.
+.TP
+.BI \-o \ ofile
+Output image file to contain the difference image in PGM format.
+.TP
+.I file
+Input image that is compared against
+.I ifile.
+Default: standard input.
+.SH OUTPUT
+The difference image in PGM format is written to standard output or,
+optionally, to
+.I ofile.
+.SH AUTHOR
+Peter Meerwald.
+Email bug reports to pmeerw@cosy.sbg.ac.at.
+.SH AVAILABILITY
+The most recent released version of
+.B cmp_dct
+is always available
+at http://www.cosy.sbg.ac.at/~pmeerw/Watermarking or via anonymous ftp from ftp.cosy.sbg.ac.at in the
+directory /pub/people/pmeerw/Watermarking.
+.SH "SEE ALSO"
+.B cmp_pgm
+(1),
+.B cmp_ppm
+(1),
+.B cmp_dct8x8
+(1)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/cmp_dct.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,197 @@
+#include "wm.h"
+#include "dct.h"
+#include "gray.h"
+#include "pgm.h"
+
+char *progname;
+
+void usage(void) {
+  fprintf(stderr, "usage: %s [-h] [-m n] [-o file] [-pP] -i file file\n\n", progname);
+  fprintf(stderr, "\t-h\t\tprint usage\n");
+  fprintf(stderr, "\t-i file\t\toriginal image file\n");
+  fprintf(stderr, "\t-m n\t\tmultiplication factor (default 16)\n");
+  fprintf(stderr, "\t-o file\t\toutput file\n");
+  fprintf(stderr, "\t-p\t\tprint PSNR, RMS and MSE\n");
+  fprintf(stderr, "\t-P\t\tonly print PSNR, RMS and MSE, no difference image\n");
+  exit(0);
+}
+
+int main(int argc, char *argv[]) {
+
+  FILE *in = stdin;
+  FILE *out = stdout;
+  FILE *orig = NULL;
+
+  gray **input_image;
+  gray **orig_image;
+  double **input_dcts;
+  double **orig_dcts;
+  gray **output;
+
+  char output_name[MAXPATHLEN] = "(stdout)";
+  char input_name[MAXPATHLEN] = "(stdin)";
+  char orig_name[MAXPATHLEN];
+
+  int in_cols, in_rows, in_format;
+  gray in_maxval;
+  int orig_cols, orig_rows, orig_format;
+  gray orig_maxval;
+  int cols, rows, format;
+  gray maxval;
+  int col, row;
+
+  int no_orig = 0;
+  int c;
+
+  double error = 0.0;
+  int print_psnr = 0;
+  int print_psnr_only = 0;
+  int m = 16;
+
+  progname = argv[0];
+
+  pgm_init(&argc, argv); wm_init();
+
+  while ((c = getopt(argc, argv, "h?i:m:o:pP")) != EOF) {
+    switch (c) {
+      case 'h':
+      case '?':
+        usage();
+        break;
+      case 'i':
+        if (!strcmp(optarg, "-")) {
+          no_orig = 1;
+          strcpy(orig_name, "(zero)");
+        }
+        else {
+          if ((orig = fopen(optarg, "rb")) == NULL) {
+            fprintf(stderr, "%s: unable to open original image file %s\n", progname, optarg);
+            exit(1);
+          }
+          strcpy(orig_name, optarg);
+        }
+        break;
+      case 'm':
+        m = atoi(optarg);
+        if (m <= 0) {
+          fprintf(stderr, "%s: multiplication factor %d out of range\n", progname, m);
+          exit(1);
+        }
+        break;
+      case 'o':
+        if ((out = fopen(optarg, "wb")) == NULL) {
+          fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(output_name, optarg);
+        break;
+      case 'p':
+        print_psnr = 1;
+        break;
+      case 'P':
+        print_psnr_only = 1;
+        break;
+    }
+  }
+
+  argc -= optind;
+  argv += optind;
+
+  if (argc > 1) {
+    usage();
+    exit(1);
+  }
+
+  if (argc == 1 && *argv[0] != '-')
+    if ((in = fopen(argv[0], "rb")) == NULL) {
+      fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]);
+      exit(1);
+    }
+    else
+      strcpy(input_name, argv[0]);
+
+  if (!orig && !no_orig) {
+    fprintf(stderr, "%s: original image file not specified, using zero image\n", progname);
+    strcpy(orig_name, "(zero)");
+    no_orig = 1;
+  }
+
+  pgm_readpgminit(in, &in_cols, &in_rows, &in_maxval, &in_format);
+
+  if (!no_orig) {
+    pgm_readpgminit(orig, &orig_cols, &orig_rows, &orig_maxval, &orig_format);
+
+    if (in_cols != orig_cols || in_rows != orig_rows) {
+      fprintf(stderr, "%s: input image %s does not match dimensions of original image %s\n", progname, input_name, orig_name);
+      exit(1);
+    }
+  }
+
+  cols = in_cols;
+  rows = in_rows;
+  format = in_format;
+  maxval = in_maxval;
+
+  input_image = pgm_allocarray(cols, rows);
+  orig_image = pgm_allocarray(cols, rows);
+
+  init_dct_NxN(cols, rows);
+  input_dcts = alloc_coeffs(cols, rows);
+  orig_dcts = alloc_coeffs(cols, rows);
+  output = alloc_grays(cols, rows);
+
+  if (no_orig) {
+    for (row = 0; row < rows; row++) {
+      pgm_readpgmrow(in, input_image[row], cols, maxval, format);
+      bzero(orig_image[row], sizeof(gray) * cols);
+    }
+  }
+  else {
+    for (row = 0; row < rows; row++) {
+      pgm_readpgmrow(in, input_image[row], cols, maxval, format);
+      pgm_readpgmrow(orig, orig_image[row], cols, maxval, format);
+    }
+  }
+
+  fclose(in);
+  if (!no_orig)
+    fclose(orig);
+
+  fdct_NxN(input_image, input_dcts);
+  fdct_NxN(orig_image, orig_dcts);
+
+  for (row = 0; row < rows; row++)
+    for (col = 0; col < cols; col++) {
+      error += sqr(input_dcts[row][col] - orig_dcts[row][col]);
+      output[row][col] = PIXELRANGE(fabs(input_dcts[row][col] - orig_dcts[row][col]) * m);
+    }
+
+  if (!print_psnr_only) {
+    pgm_writepgminit(out, cols, rows, maxval, 0);
+    for (row = 0; row < rows; row++)
+      pgm_writepgmrow(out, output[row], cols, maxval, 0);
+
+    fclose(out);
+  }
+
+  pgm_freearray(input_image, rows);
+  pgm_freearray(orig_image, rows);
+  free_coeffs(input_dcts);
+  free_coeffs(orig_dcts);
+  free_grays(output);
+
+  if (print_psnr || print_psnr_only) {
+    double mse = error / (double) (cols * rows);
+    double rmse = sqrt(mse);
+    double psnr = 20.0 * log(255.0 / rmse) / log(10.0);
+    FILE *print = print_psnr_only ? out : stderr;
+    if (mse > 0.0)
+      fprintf(print, "PSNR: %lf dB\n", psnr);
+    else
+      fprintf(print, "PSNR: inf\n");
+    fprintf(print, "RMS: %lf\n", rmse);
+    fprintf(print, "MSE: %lf\n", mse);
+  }
+
+  exit(0);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/cmp_dct8x8.1	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,79 @@
+.\"
+.\" cmp_dct8x8.1 - the *roff document processor man page source
+.\"
+.TH cmp_dct8x8 1 "98/07/08" "Watermarking, Version 1.0"
+.SH NAME
+cmp_dct8x8 \- a program to create the difference image of the
+8x8 DCT blocks of two PGM images
+.SH SYNOPSIS
+.B cmp_dct8x8
+[
+.B \-h
+]
+[
+.BI \-m \ number
+]
+[
+.BI \-o \ ofile
+]
+.BI \-i \ ifile
+.I file
+.SH DESCRIPTION
+.B cmp_dct8x8
+is a program to create the difference image of the 8x8 DCT blocks
+(frequency domain) of two PGM (portable graymap) grayscale
+images. To compare images in the spatial domain, either in
+PPM (portable pixmap) format for RGB color images or in PGM (portable
+graymap) format for grayscale images, use the
+.B cmp_ppm
+program or the
+.B cmp_pgm
+program, respectively.
+.PP
+If
+.I file
+or
+.I ofile
+is not specified, then standard input or standard output is
+used.
+.PP
+.SH OPTIONS
+.TP
+.B \-h
+Print a help message.
+.TP
+.BI \-i \ ifile
+The original image. Mandatory.
+.TP
+.BI \-m \ number
+Multiplication factor to magnify differences between the to
+original and input image.
+Default value: 16.
+.TP
+.BI \-o \ ofile
+Output image file to contain the difference image in PGM format.
+.TP
+.I file
+Input image that is compared against
+.I ifile.
+Default: standard input.
+.SH OUTPUT
+The difference image in PGM format is written to standard output or,
+optionally, to
+.I ofile.
+.SH AUTHOR
+Peter Meerwald. 
+Email bug reports to pmeerw@cosy.sbg.ac.at.
+.SH AVAILABILITY
+The most recent released version of
+.B cmp_dct8x8
+is always available
+at http://www.cosy.sbg.ac.at/~pmeerw/Watermarking or via anonymous ftp from ftp.cosy.sbg.ac.at in the
+directory /pub/people/pmeerw/Watermarking.
+.SH "SEE ALSO"
+.B cmp_pgm
+(1),
+.B cmp_ppm
+(1),
+.B cmp_dct
+(1)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Meerwald/cmp_dct8x8.c	Sun Aug 12 13:14:34 2007 +0200
@@ -0,0 +1,196 @@
+#include "wm.h"
+#include "dct.h"
+#include "gray.h"
+#include "pgm.h"
+
+char *progname;
+
+void usage(void) {
+  fprintf(stderr, "usage: %s [-h] [-m n] [-o file] [-pP] -i file file\n\n", progname);
+  fprintf(stderr, "\t-h\t\tprint usage\n");
+  fprintf(stderr, "\t-i file\t\toriginal image file\n");
+  fprintf(stderr, "\t-m n\t\tmultiplication factor (default 16)\n");
+  fprintf(stderr, "\t-o file\t\toutput file\n");
+  fprintf(stderr, "\t-p\t\tprint PSNR, RMS and MSE\n");
+  fprintf(stderr, "\t-P\t\tonly print PSNR, RMS and MSE, no difference image\n");
+  exit(0);
+}
+
+int main(int argc, char *argv[]) {
+
+  FILE *in = stdin;
+  FILE *out = stdout;
+  FILE *orig = NULL;
+
+  gray **input_image;
+  gray **orig_image;
+  double **input_dcts;
+  double **orig_dcts;
+  gray **output;
+
+  char output_name[MAXPATHLEN] = "(stdout)";
+  char input_name[MAXPATHLEN] = "(stdin)";
+  char orig_name[MAXPATHLEN];
+
+  int in_cols, in_rows, in_format;
+  gray in_maxval;
+  int orig_cols, orig_rows, orig_format;
+  gray orig_maxval;
+  int cols, rows, format;
+  gray maxval;
+  int col, row;
+
+  int i, j;
+  int c;
+
+  int m = 16;
+
+  int print_psnr = 0;
+  int print_psnr_only = 0;
+  double error = 0.0;
+
+  progname = argv[0];
+
+  pgm_init(&argc, argv); wm_init();
+
+  while ((c = getopt(argc, argv, "h?i:m:o:pP")) != EOF) {
+    switch (c) {
+      case 'h':
+      case '?':
+        usage();
+        break;
+      case 'i':
+        if ((orig = fopen(optarg, "rb")) == NULL) {
+          fprintf(stderr, "%s: unable to open original image file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(orig_name, optarg);
+        break;
+      case 'm':
+        m = atoi(optarg);
+        if (m <= 0) {
+          fprintf(stderr, "%s: multiplication factor %d out of range\n", progname, m);
+          exit(1);
+        }
+        break;
+      case 'o':
+        if ((out = fopen(optarg, "w")) == NULL) {
+          fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg);
+          exit(1);
+        }
+        strcpy(output_name, optarg);
+        break;
+      case 'p':
+        print_psnr = 1;
+        break;
+      case 'P':
+        print_psnr_only = 1;
+        break;
+    }
+  }
+
+  argc -= optind;
+  argv += optind;
+
+  if (argc > 1) {
+    usage();
+    exit(1);
+  }
+
+  if (argc == 1 && *argv[0] != '-')
+    if ((in = fopen(argv[0], "rb")) == NULL) {
+      fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]);
+      exit(1);
+    }
+    else
+      strcpy(input_name, argv[0]);
+
+  if (!orig) {
+    fprintf(stderr, "%s: original image file not specified, use -i file option\n", progname);
+    exit(1);
+  }
+
+  pgm_readpgminit(in, &in_cols, &in_rows, &in_maxval, &in_format);
+
+  pgm_readpgminit(orig, &orig_cols, &orig_rows, &orig_maxval, &orig_format);
+
+  if (in_cols != orig_cols || in_rows != orig_rows) {
+    fprintf(stderr, "%s: input image %s does not match dimensions of original image %s\n", progname, input_name, orig_name);
+    exit(1);
+  }
+
+  if (cols % NJPEG) {
+    fprintf(stderr, "%s: image width %d not a multiple of %d\n", progname, cols, NJPEG);
+    exit(1);
+  }
+
+  if (rows % NJPEG) {
+    fprintf(stderr, "%s: image height %d not a multiple of %d\n", progname, rows, NJPEG);
+    exit(1);
+  }
+
+  cols = in_cols;
+  rows = in_rows;
+  format = in_format;
+  maxval = in_maxval;
+
+  input_image = pgm_allocarray(cols, NJPEG);
+  orig_image = pgm_allocarray(cols, NJPEG);
+
+  init_dct_8x8();
+  input_dcts = alloc_coeffs_8x8();
+  orig_dcts = alloc_coeffs_8x8();
+  output = alloc_grays(cols, NJPEG);
+
+  if (!print_psnr_only)
+    pgm_writepgminit(out, cols, rows, maxval, 0);
+
+  for (row = 0; row < rows; row += NJPEG) {
+
+    for (i = 0; i < NJPEG; i++) {
+      pgm_readpgmrow(in, input_image[row % NJPEG], cols, maxval, format);
+      pgm_readpgmrow(orig, orig_image[row % NJPEG], cols, maxval, format);
+    }
+
+    for (col = 0; col < cols; col += NJPEG) {
+      fdct_block_8x8(input_image, col, 0, input_dcts);
+      fdct_block_8x8(orig_image, col, 0, orig_dcts);
+
+      for (i = 0; i < NJPEG; i++)
+        for (j = 0; j < NJPEG; j++)
+          error += sqr(input_dcts[j][i + cols] - orig_dcts[j][i + cols]);
+          output[j][i + col] = PIXELRANGE(fabs(input_dcts[j][i + cols] - orig_dcts[j][i + cols]) * m);
+    }
+
+    if (!print_psnr_only) {
+      for (i = 0; i < NJPEG; i++)
+        pgm_writepgmrow(out, output[i], cols, maxval, 0);
+    }
+
+  }
+  fclose(in);
+  fclose(orig);
+  if (!print_psnr_only)
+    fclose(out);
+
+  pgm_freearray(input_image, NJPEG);
+  pgm_freearray(orig_image, NJPEG);
+  free_coeffs(input_dcts);
+  free_coeffs(orig_dcts);
+  free_grays(output);
+
+ if (print_psnr || print_psnr_only) {
+    double mse = error / (double) (cols * rows);
+    double rmse = sqrt(mse);
+    double psnr = 20.0 * log(255.0 / rmse) / log(10.0);
+    FILE *print = print_psnr_only ? out : stderr;
+    if (mse > 0.0)
+      fprintf(print, "PSNR: %lf dB\n", psnr);
+    else
+      fprintf(print, "PSNR: inf\n");
+    fprintf(print, "RMS: %lf\n", rmse);
+    fprintf(print, "MSE: %lf\n", mse);
+  }
+
+  exit(0);
+}