--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos-dir/CHANGES	Fri Dec 20 13:08:59 2024 +0100
@@ -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-dir/Makefile	Fri Dec 20 13:08:59 2024 +0100
@@ -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) $(LIBS)
+
+cast-hart$(EXE):  cast-hart$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ cast-hart$(O) common$(O) $(PGMLIBS) $(LIBS)
+
+cast-sub$(EXE):  cast-sub$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ cast-sub$(O) common$(O) $(PGMLIBS) $(LIBS)
+
+test-pv$(EXE):  test-pv$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ test-pv$(O) common$(O) $(PGMLIBS) $(LIBS)
+
+test-hart$(EXE):  test-hart$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ test-hart$(O) common$(O) $(PGMLIBS) $(LIBS)
+
+test-sub$(EXE):  test-sub$(O) common$(O)
+	$(CC) $(LDFLAGS) -o $@ test-sub$(O) common$(O) $(PGMLIBS) $(LIBS)
+
+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-dir/README	Fri Dec 20 13:08:59 2024 +0100
@@ -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-dir/README_VASSILIS	Fri Dec 20 13:08:59 2024 +0100
@@ -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-dir/cast-hart.c	Fri Dec 20 13:08:59 2024 +0100
@@ -0,0 +1,113 @@
+/* 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"
+#include "netpbm/pgm.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, 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);
+  exit(EXIT_SUCCESS);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos-dir/cast-pv.c	Fri Dec 20 13:08:59 2024 +0100
@@ -0,0 +1,135 @@
+/* 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"
+#include "netpbm/pgm.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);
+
+  exit(EXIT_SUCCESS);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos-dir/cast-sub.c	Fri Dec 20 13:08:59 2024 +0100
@@ -0,0 +1,250 @@
+/* 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"
+#include "netpbm/pgm.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);
+
+  exit(EXIT_SUCCESS);
+}
+
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos-dir/common.c	Fri Dec 20 13:08:59 2024 +0100
@@ -0,0 +1,571 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include "netpbm/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 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 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-dir/common.h	Fri Dec 20 13:08:59 2024 +0100
@@ -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-dir/test-hart.c	Fri Dec 20 13:08:59 2024 +0100
@@ -0,0 +1,110 @@
+/* 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"
+#include "netpbm/pgm.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 z;
+  M = coeff_start;
+  L = wm_length;
+  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);
+
+  exit(EXIT_SUCCESS);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos-dir/test-pv.c	Fri Dec 20 13:08:59 2024 +0100
@@ -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"
+#include "netpbm/pgm.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 z;
+  M = start_coeff;
+  L = wm_length;
+  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);
+
+  exit(EXIT_SUCCESS);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Fotopoulos-dir/test-sub.c	Fri Dec 20 13:08:59 2024 +0100
@@ -0,0 +1,240 @@
+/* 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"
+#include "netpbm/pgm.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);
+
+  exit(EXIT_SUCCESS);
+}
+
+
+
+

--- a/Fotopoulos/CHANGES	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-removed #include <values.h> - it is not needed and MS VC++ does not have 
-it (Sarat Atluri)

--- a/Fotopoulos/Makefile	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-# 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) $(LIBS)
-
-cast-hart$(EXE):  cast-hart$(O) common$(O)
-	$(CC) $(LDFLAGS) -o $@ cast-hart$(O) common$(O) $(PGMLIBS) $(LIBS)
-
-cast-sub$(EXE):  cast-sub$(O) common$(O)
-	$(CC) $(LDFLAGS) -o $@ cast-sub$(O) common$(O) $(PGMLIBS) $(LIBS)
-
-test-pv$(EXE):  test-pv$(O) common$(O)
-	$(CC) $(LDFLAGS) -o $@ test-pv$(O) common$(O) $(PGMLIBS) $(LIBS)
-
-test-hart$(EXE):  test-hart$(O) common$(O)
-	$(CC) $(LDFLAGS) -o $@ test-hart$(O) common$(O) $(PGMLIBS) $(LIBS)
-
-test-sub$(EXE):  test-sub$(O) common$(O)
-	$(CC) $(LDFLAGS) -o $@ test-sub$(O) common$(O) $(PGMLIBS) $(LIBS)
-
-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/*

--- a/Fotopoulos/README	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,21 +0,0 @@
-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
-
-

--- a/Fotopoulos/README_VASSILIS	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-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

--- a/Fotopoulos/cast-hart.c	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,113 +0,0 @@
-/* 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"
-#include "pgm.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, 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);
-  exit(EXIT_SUCCESS);
-}

--- a/Fotopoulos/cast-pv.c	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,135 +0,0 @@
-/* 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"
-#include "pgm.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);
-
-  exit(EXIT_SUCCESS);
-}

--- a/Fotopoulos/cast-sub.c	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,250 +0,0 @@
-/* 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"
-#include "pgm.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);
-
-  exit(EXIT_SUCCESS);
-}
-
-
-
-

--- a/Fotopoulos/common.c	Fri Dec 20 12:53:41 2024 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,571 +0,0 @@
-#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 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 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();
-}
-