From 189da15810deabd739d7c11c6e95fea55739fe60 Mon Sep 17 00:00:00 2001
From: Thomas White <taw@physics.org>
Date: Sat, 1 Aug 2020 15:13:49 +0200
Subject: Initial import from archive

---
 src/gsf.c | 669 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 669 insertions(+)
 create mode 100644 src/gsf.c

(limited to 'src/gsf.c')

diff --git a/src/gsf.c b/src/gsf.c
new file mode 100644
index 0000000..aa18da8
--- /dev/null
+++ b/src/gsf.c
@@ -0,0 +1,669 @@
+/*
+ * gsf.c
+ *
+ * Gerchberg-Saxton-Fienup iteration algorithms
+ *
+ * (c) 2006-2007 Thomas White <taw27@cam.ac.uk>
+ * (c) 2008 Alex Eggeman <ase25@cam.ac.uk>
+ *
+ *  synth2d - two-dimensional Fourier synthesis
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gtk/gtk.h>
+#include <fftw3.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+
+#include "main.h"
+#include "data.h"
+#include "displaywindow.h"
+#include "symmetry.h"
+#include "gtk-symmetry.h"
+#include "reflist.h"
+
+
+GtkWidget *gsfw_iterations = NULL;
+static int gsf_window_open = 0;
+static int gsf_running = 0;
+static int gsf_n_iterations = 0;
+static int gsf_centroid = 0;
+static int gsf_atomicity = 0;
+static int gsf_zerofzero = 1;
+static int gsf_fracsup = 0;
+static int gsf_threshsup = 1;
+static double gsf_fracsup_phi = 0.15;
+static double gsf_hio_beta = 0.15;
+static double gsf_threshsup_delta = 0;	/* i.e. all positive values are in the support */
+Symmetry gsf_symmetry = PLANEGROUP_P1;
+fftw_complex *gsf_drive = NULL;
+fftw_complex *gsf_drive_old = NULL;
+unsigned int *gsf_support = NULL;
+fftw_complex *gsf_in = NULL;
+fftw_complex *gsf_out = NULL;
+fftw_plan gsf_plan_i2d;
+fftw_plan gsf_plan_d2i;
+ReflectionList *gsf_reflections = NULL;
+static int gsf_antistag = 0;
+
+static void gsf_pin_centroid(fftw_complex *out, fftw_complex *drive, unsigned int width, unsigned int height) {
+
+	unsigned int x, y;
+	double xc = 0;
+	double yc = 0;
+	double total_int = 0;
+	signed int xs;
+	signed int ys;
+	fftw_complex *out_copy;
+
+	for ( x=0; x<width; x++ ) {
+		for ( y=0; y<height; y++ ) {
+			xc += (x+1) * out[y+height*x][0];
+			yc += (y+1) * out[y+height*x][0];
+			total_int += out[y+height*x][0];
+		}
+	}
+	xc = xc / total_int; xc--;
+	yc = yc / total_int; yc--;
+
+	/* Calculate displacements needed to put centroid at centre... */
+	xs = (width/2) - xc;
+	ys = (height/2) - yc;
+
+	out_copy = malloc(width*height*sizeof(fftw_complex));
+	memcpy(out_copy, out, width*height*sizeof(fftw_complex));
+	for ( x=0; x<width; x++ ) {
+		for ( y=0; y<height; y++ ) {
+		 	signed int xn = x-xs;
+			signed int yn = y-ys;
+			if ( xn < 0 ) { xn = width+xn; }
+			if ( yn < 0 ) { yn = height+yn; }
+			out[y+height*x][0] = out_copy[yn+height*xn][0];
+			out[y+height*x][1] = out_copy[yn+height*xn][1];
+		}
+	}
+
+	memcpy(out_copy, drive, width*height*sizeof(fftw_complex));
+	for ( x=0; x<width; x++ ) {
+		for ( y=0; y<height; y++ ) {
+		 	signed int xn = x-xs;
+			signed int yn = y-ys;
+			if ( xn < 0 ) { xn = width+xn; }
+			if ( yn < 0 ) { yn = height+yn; }
+			drive[y+height*x][0] = out_copy[yn+height*xn][0];
+			drive[y+height*x][1] = out_copy[yn+height*xn][1];
+		}
+	}
+
+	free(out_copy);
+
+}
+
+void gsf_mask(ReflectionList *reflections, fftw_complex *in, unsigned int width, unsigned int height) {
+
+	unsigned int i;
+	fftw_complex *in_new = malloc(width*height*sizeof(fftw_complex));
+	bzero(in_new, width*height*sizeof(fftw_complex));
+
+	for ( i=1; i<reflections->n_reflections; i++ ) {
+
+		signed int h = reflections->refs[i].h;
+		signed int k = reflections->refs[i].k;
+
+		if ( h < 0 ) { h = width+h; }
+		if ( k < 0 ) { k = height+k; }
+
+		in_new[k + height*h][0] = in[k + height*h][0];
+		in_new[k + height*h][1] = in[k + height*h][1];
+
+	}
+
+	memcpy(in, in_new, width*height*sizeof(fftw_complex));
+	free(in_new);
+
+}
+
+/* Perform a single GSF iteration */
+void gsf_iteration(int gsf_n_iterations) {
+
+	unsigned int x, y;
+	double mean;
+	double top;
+	unsigned int mean_n;
+	double fzero;
+	unsigned int i;
+	unsigned int width = data_width();
+	unsigned int height = data_height();
+
+	assert(gsf_drive_old != NULL);
+	assert(gsf_drive != NULL);
+	assert(gsf_in != NULL);
+	assert(gsf_out != NULL);
+
+	/* Copy this structure if required */
+	memcpy(gsf_drive_old, gsf_drive, width*height*sizeof(fftw_complex));
+
+	/* Transform back to reciprocal space and scale.  This time, the driving function is
+		being transformed. */
+	fftw_execute(gsf_plan_d2i);
+	for ( x=0; x<width; x++ ) {
+		for ( y=0; y<((height/2)+1); y++ ) {
+			gsf_in[y+((height/2)+1)*x][0] = gsf_in[y+((height/2)+1)*x][0] / (width*height);	/* Real */
+			gsf_in[y+((height/2)+1)*x][1] = gsf_in[y+((height/2)+1)*x][1] / (width*height);	/* Imaginary */
+		}
+	}
+
+	/* Impose observed intensities */
+	for ( i=0; i<gsf_reflections->n_reflections; i++ ) {
+
+		double re, im;
+		double am, ph;
+		signed int h, k;
+
+		h = gsf_reflections->refs[i].h;
+		k = gsf_reflections->refs[i].k;
+
+		if ( h < 0 ) { h = width+h; }
+		if ( k < 0 ) { k = height+k; }
+
+		re = gsf_in[k + height*h][0];
+		im = gsf_in[k + height*h][1];
+		ph = atan2(im, re);
+		am = gsf_reflections->refs[i].amplitude;
+
+		gsf_in[k + height*h][0] = am*cos(ph);
+		gsf_in[k + height*h][1] = am*sin(ph);
+
+	}
+
+	fzero = gsf_in[0][0];
+	gsf_mask(gsf_reflections, gsf_in, width, height);
+	if ( !gsf_zerofzero ) {
+		gsf_in[0][0] = fzero;
+	}
+
+	/* Impose Symmetry */
+
+	symmetry_symmetrise_array(gsf_in, width, height, gsf_symmetry);
+
+	/* Transform to real space */
+	fftw_execute(gsf_plan_i2d);
+
+	if ( gsf_centroid ) {
+		gsf_pin_centroid(gsf_drive, gsf_drive_old, width, height);
+	}
+
+	memcpy(gsf_out, gsf_drive, width*height*sizeof(fftw_complex));
+	displaywindow_switchview();
+
+	/* Determine the support */
+	if ( gsf_threshsup && !gsf_fracsup ) {
+
+		/* Threshold support */
+		for ( y=0; y<height; y++ ) {
+			for ( x=0; x<width; x++ ) {
+				if ( gsf_drive[y+height*x][0] > gsf_threshsup_delta ) {
+					gsf_support[y+height*x] = 1;
+				} else {
+					gsf_support[y+height*x] = 0;
+				}
+
+				if ( gsf_antistag && ((x+y)>width) ) {
+					gsf_support[y+height*x] = 0;
+				}
+
+			}
+		}
+
+	} else if ( gsf_fracsup ) {
+
+		/* 'Fractional' support */
+		double max;
+		unsigned int max_x, max_y;
+		int n, target, i;
+
+
+		n = height*width;
+		target = n * gsf_fracsup_phi;
+		i = 0;
+
+		while ( i < target ) {
+			max_x = 0; max_y = 0; max = -1e10;
+			for ( y=0; y<height; y++ ) {
+				for ( x=0; x<width; x++ ) {
+					double am = sqrt(gsf_out[y+height*x][0] * gsf_out[y+height*x][0] + gsf_out[y+height*x][1] * gsf_out[y+height*x][1]);
+					if ( (!gsf_threshsup) || (am > 0) ) {
+						if ( ( am > max) && (!gsf_support[y+height*x]) ) {
+							max_x = x; max_y = y; max = am;
+						}
+					}
+				}
+			}
+			gsf_support[max_y+height*max_x] = 1;
+			i++;
+		}
+
+	} else {
+
+		/* No options selected for support - consider everything valid */
+		for ( y=0; y<height; y++ ) {
+			for ( x=0; x<width; x++ ) {
+				gsf_support[y+height*x] = 1;
+			}
+		}
+
+	}
+
+	/* Impose non-negativity, sharpen peaks and apply feedback */
+	mean = 0; mean_n = 0; top =0;
+	for ( y=0; y<height; y++ ) {
+		for ( x=0; x<width; x++ ) {
+			double re, im, am;
+			re = gsf_drive[y+height*x][0];
+			im = gsf_drive[y+height*x][1];
+			am = sqrt(re*re + im*im);
+			if ( am > 0 ) {
+				mean += am;
+				mean_n++;
+			if ( am > top ) top = am;
+
+			}
+		}
+	}
+
+	mean = mean / mean_n;
+	for ( y=0; y<height; y++ ) {
+		for ( x=0; x<width; x++ ) {
+
+			if ( !gsf_support[y+height*x] ) {
+
+				 gsf_drive[y+height*x][0] = gsf_drive_old[y+height*x][0] - gsf_hio_beta*gsf_drive[y+height*x][0];
+				 gsf_drive[y+height*x][1] = gsf_drive_old[y+height*x][1] - gsf_hio_beta*gsf_drive[y+height*x][1];
+
+			} else {
+
+				if ( gsf_atomicity ) {
+					double re, im, am, ph;
+					re = gsf_drive[y+height*x][0];
+					im = gsf_drive[y+height*x][1];
+					am = sqrt(re*re + im*im);
+					ph = atan2(im, re);
+					am = am * log(am/mean);
+					gsf_drive[y+height*x][0] = am*cos(ph);
+					gsf_drive[y+height*x][1] = am*sin(ph);
+				}
+
+			}
+
+		}
+	}
+
+}
+
+static gint gsf_atomicity_toggled() {
+	gsf_atomicity = 1-gsf_atomicity;
+	return 0;
+}
+
+static gint gsf_zerofzero_toggled() {
+	gsf_zerofzero = 1-gsf_zerofzero;
+	return 0;
+}
+
+static gint gsf_antistag_toggled() {
+	gsf_antistag = 1-gsf_antistag;
+	return 0;
+}
+
+static gint gsf_centroid_toggled() {
+	gsf_centroid = 1-gsf_centroid;
+	return 0;
+}
+
+GtkWidget *gsfw_fracsup_phi_label;
+static gint gsf_fracsup_toggled(GtkWidget *widget, GtkWidget *gsfw_fracsup_phi) {
+	gsf_fracsup = 1-gsf_fracsup;
+	if ( gsf_fracsup ) {
+		gtk_widget_set_sensitive(gsfw_fracsup_phi, TRUE);
+		gtk_widget_set_sensitive(gsfw_fracsup_phi_label, TRUE);
+	} else {
+		gtk_widget_set_sensitive(gsfw_fracsup_phi, FALSE);
+		gtk_widget_set_sensitive(gsfw_fracsup_phi_label, FALSE);
+	}
+	return 0;
+}
+
+static gint gsf_fracsup_phichanged(GtkWidget *gsfw_fracsup_phi) {
+	gsf_fracsup_phi = gtk_range_get_value(GTK_RANGE(gsfw_fracsup_phi));
+	return 0;
+}
+
+
+GtkWidget *gsfw_hio_beta_label;
+
+static gint gsf_hio_betachanged(GtkWidget *gsfw_hio_beta) {
+	gsf_hio_beta = gtk_range_get_value(GTK_RANGE(gsfw_hio_beta));
+	return 0;
+}
+
+GtkWidget *gsfw_threshsup_delta_label;
+static gint gsf_threshsup_toggled(GtkWidget *widget, GtkWidget *gsfw_threshsup_delta) {
+	gsf_threshsup = 1-gsf_threshsup;
+	if ( gsf_threshsup ) {
+		gtk_widget_set_sensitive(gsfw_threshsup_delta, TRUE);
+		gtk_widget_set_sensitive(gsfw_threshsup_delta_label, TRUE);
+	} else {
+		gtk_widget_set_sensitive(gsfw_threshsup_delta, FALSE);
+		gtk_widget_set_sensitive(gsfw_threshsup_delta_label, FALSE);
+	}
+	return 0;
+}
+
+static gint gsf_threshsup_deltachanged(GtkWidget *gsfw_threshsup_delta) {
+	gsf_threshsup_delta = gtk_range_get_value(GTK_RANGE(gsfw_threshsup_delta));
+	return 0;
+}
+
+void gsf_finalise() {
+
+	free(gsf_drive);	gsf_drive = NULL;
+	free(gsf_drive_old);	gsf_drive_old = NULL;
+	free(gsf_support);	gsf_support = NULL;
+	free(gsf_in);		gsf_in = NULL;
+	free(gsf_reflections);	gsf_reflections = NULL;
+	/* Don't free gsf_out, since it is now backing up the display */
+
+	fftw_destroy_plan(gsf_plan_i2d);
+	fftw_destroy_plan(gsf_plan_d2i);
+
+}
+
+
+static void gsf_window_close(GtkWidget *widget, gint arg1, gpointer data) {
+
+	gsf_window_open = 0;
+	gsf_running = 0;
+	gtk_widget_destroy(widget);
+
+	gsf_finalise();
+
+}
+
+static void gsf_update_iterations() {
+
+	char *text = malloc(40);
+	snprintf(text, 39, "Iterations performed so far: %i", gsf_n_iterations);
+	gtk_label_set_text(GTK_LABEL(gsfw_iterations), text);
+	free(text);
+
+}
+
+void gsf_reset(ReflectionList *reflections) {
+
+	unsigned int i;
+	unsigned int width = data_width();
+	unsigned int height = data_height();
+
+	gsf_n_iterations = 0;
+	gsf_update_iterations();
+
+	for ( i=0; i<gsf_reflections->n_reflections; i++ ) {
+
+		double am, ph;
+		signed int h, k;
+
+		h = gsf_reflections->refs[i].h;
+		k = gsf_reflections->refs[i].k;
+
+		if ( h < 0 ) { h = width+h; }
+		if ( k < 0 ) { k = height+k; }
+
+		am = gsf_reflections->refs[i].amplitude;
+		ph = (((double)random())/RAND_MAX) * (2*M_PI);
+
+		gsf_in[k + height*h][0] = am*cos(ph);
+		gsf_in[k + height*h][1] = am*sin(ph);
+
+	}
+	fftw_execute(gsf_plan_i2d);
+
+	memcpy(gsf_out, gsf_drive, width*height*sizeof(fftw_complex));
+	displaywindow_switchview();
+
+}
+
+void gsf_initialise(ReflectionList *reflections) {
+
+	gsf_drive_old = fftw_malloc(data_width()*data_height()*sizeof(fftw_complex));
+	gsf_drive = fftw_malloc(data_width()*data_height()*sizeof(fftw_complex));
+	gsf_support = fftw_malloc(data_width()*data_height()*sizeof(unsigned int));
+	gsf_in = fftw_malloc(data_width()*data_height()*sizeof(fftw_complex));
+	memset(gsf_in, 0, data_width()*data_height()*sizeof(fftw_complex));
+	if ( !gsf_out ) gsf_out = fftw_malloc(data_width()*data_height()*sizeof(fftw_complex));
+
+	gsf_plan_i2d = fftw_plan_dft_2d(data_width(), data_height(), gsf_in, gsf_drive, FFTW_BACKWARD, FFTW_MEASURE | FFTW_PRESERVE_INPUT);
+	gsf_plan_d2i = fftw_plan_dft_2d(data_width(), data_height(), gsf_drive, gsf_in, FFTW_FORWARD, FFTW_MEASURE | FFTW_PRESERVE_INPUT);
+
+	gsf_reflections = malloc(sizeof(ReflectionList));
+	memcpy(gsf_reflections, reflections, sizeof(ReflectionList));
+
+	displaywindow_set_realspace(gsf_out, DWR_GSF);
+	gsf_reset(reflections);
+
+}
+
+static gint gsf_window_go(GtkWidget *gsf_go) {
+
+	if ( gsf_running ) {
+		return 0;
+	}
+
+	gsf_running = 1;
+	while ( gsf_running ) {
+		gsf_n_iterations++;
+		gsf_update_iterations();
+		gsf_iteration(gsf_n_iterations);
+		while ( gtk_events_pending() ) gtk_main_iteration();
+	}
+	return 0;
+
+}
+
+static gint gsf_window_stop(GtkWidget *widget, gpointer data) {
+	gsf_running = 0;
+	return 0;
+}
+
+static gint gsf_window_reset(GtkWidget *widget) {
+	gsf_running = 0;
+	main_gsf_reset();
+	return 0;
+}
+
+static gint gsf_symmetry_changed(GtkWidget *widget, gpointer data) {
+	gsf_symmetry = gtk_symmetry_get_symmetry(GTK_SYMMETRY(widget));
+	return 0;
+}
+
+void gsf_dialog_open() {
+
+	GtkWidget *gsfw_window;
+	GtkWidget *gsfw_go;
+	GtkWidget *gsfw_stop;
+	GtkWidget *gsfw_reset;
+	GtkWidget *gsfw_gostop_hbox;
+	GtkWidget *gsfw_centroid;
+	GtkWidget *gsfw_atomicity;
+	GtkWidget *gsfw_zerofzero;
+	GtkWidget *gsfw_antistag;
+	GtkWidget *gsfw_fracsup;
+	GtkWidget *gsfw_fracsup_phi;
+	GtkWidget *gsfw_fracsup_hbox;
+	GtkWidget *gsfw_hio_beta;
+	GtkWidget *gsfw_hio_hbox;
+	GtkWidget *gsfw_threshsup;
+	GtkWidget *gsfw_threshsup_delta;
+	GtkWidget *gsfw_threshsup_hbox;
+	GtkWidget *vbox;
+	GtkWidget *hbox;
+	GtkWidget *sym_define;
+	GtkWidget *gsfw_support_label;
+	GtkWidget *gsfw_process_label;
+	char *text;
+
+	if ( gsf_window_open ) {
+		return;
+	}
+	gsf_window_open = 1;
+
+	gsfw_window = gtk_dialog_new_with_buttons("Projection Iteration", GTK_WINDOW(displaywindow_gtkwindow()),
+		GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
+
+	vbox = gtk_vbox_new(FALSE, 0);
+	hbox = gtk_hbox_new(TRUE, 0);
+	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(gsfw_window)->vbox), GTK_WIDGET(hbox), FALSE, FALSE, 7);
+	gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), FALSE, FALSE, 5);
+
+	gsfw_iterations = gtk_label_new("");
+	text = malloc(40);
+	snprintf(text, 39, "Iterations performed so far: %i", gsf_n_iterations);
+	gtk_label_set_text(GTK_LABEL(gsfw_iterations), text);
+	free(text);
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_iterations), FALSE, FALSE, 5);
+
+	sym_define = gtk_symmetry_new(2, 2, TRUE);
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(sym_define), FALSE, FALSE, 5);
+	g_signal_connect(G_OBJECT(sym_define), "changed", G_CALLBACK(gsf_symmetry_changed), NULL);
+	gsf_symmetry = PLANEGROUP_P1;
+
+	gsfw_centroid = gtk_check_button_new_with_label("Pin centroid");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_centroid), FALSE, FALSE, 5);
+	if ( gsf_centroid ) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_centroid), TRUE);
+	} else {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_centroid), FALSE);
+	}
+	gsfw_atomicity = gtk_check_button_new_with_label("Atomicity");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_atomicity), FALSE, FALSE, 5);
+	if ( gsf_atomicity ) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_atomicity), TRUE);
+	} else {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_atomicity), FALSE);
+	}
+	gsfw_zerofzero = gtk_check_button_new_with_label("Zero F(00)");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_zerofzero), FALSE, FALSE, 5);
+	if ( gsf_zerofzero ) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_zerofzero), TRUE);
+	} else {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_zerofzero), FALSE);
+	}
+	gsfw_antistag = gtk_check_button_new_with_label("Anti-stagnation");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_antistag), FALSE, FALSE, 5);
+	if ( gsf_antistag ) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_antistag), TRUE);
+	} else {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_antistag), FALSE);
+	}
+
+	gsfw_support_label = gtk_label_new("");
+	gtk_label_set_markup(GTK_LABEL(gsfw_support_label), "<span weight=\"bold\">Dynamic Support</span>");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_support_label), FALSE, FALSE, 10);
+
+	gsfw_fracsup = gtk_radio_button_new_with_label(NULL, "Fraction of most positive points");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_fracsup), FALSE, FALSE, 5);
+	if ( gsf_fracsup ) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_fracsup), TRUE);
+	} else {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_fracsup), FALSE);
+	}
+	gsfw_fracsup_hbox = gtk_hbox_new(FALSE, 0);
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_fracsup_hbox), FALSE, FALSE, 5);
+	gsfw_fracsup_phi_label = gtk_label_new("Φ:");
+	gtk_box_pack_start(GTK_BOX(gsfw_fracsup_hbox), GTK_WIDGET(gsfw_fracsup_phi_label), FALSE, FALSE, 5);
+	gsfw_fracsup_phi = gtk_hscale_new_with_range(0, 1, 0.05);
+	gtk_scale_set_value_pos(GTK_SCALE(gsfw_fracsup_phi), GTK_POS_RIGHT);
+	gtk_box_pack_start(GTK_BOX(gsfw_fracsup_hbox), GTK_WIDGET(gsfw_fracsup_phi), TRUE, TRUE, 5);
+	gtk_range_set_value(GTK_RANGE(gsfw_fracsup_phi), gsf_hio_beta);
+	if ( gsf_fracsup) {
+		gtk_widget_set_sensitive(gsfw_fracsup_phi, TRUE);
+		gtk_widget_set_sensitive(gsfw_fracsup_phi_label, TRUE);
+	} else {
+		gtk_widget_set_sensitive(gsfw_fracsup_phi, FALSE);
+		gtk_widget_set_sensitive(gsfw_fracsup_phi_label, FALSE);
+	}
+
+	gsfw_threshsup = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(gsfw_fracsup), "Points above threshold");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_threshsup), FALSE, FALSE, 5);
+	if ( gsf_threshsup ) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_threshsup), TRUE);
+	} else {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gsfw_threshsup), FALSE);
+	}
+	gsfw_threshsup_hbox = gtk_hbox_new(FALSE, 0);
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_threshsup_hbox), FALSE, FALSE, 5);
+	gsfw_threshsup_delta_label = gtk_label_new("δ:");
+	gtk_box_pack_start(GTK_BOX(gsfw_threshsup_hbox), GTK_WIDGET(gsfw_threshsup_delta_label), FALSE, FALSE, 5);
+	gsfw_threshsup_delta = gtk_hscale_new_with_range(-100, 100, 1);
+	gtk_scale_set_value_pos(GTK_SCALE(gsfw_threshsup_delta), GTK_POS_RIGHT);
+	gtk_box_pack_start(GTK_BOX(gsfw_threshsup_hbox), GTK_WIDGET(gsfw_threshsup_delta), TRUE, TRUE, 5);
+	gtk_range_set_value(GTK_RANGE(gsfw_threshsup_delta), gsf_threshsup_delta);
+	if ( gsf_threshsup ) {
+		gtk_widget_set_sensitive(gsfw_threshsup_delta, TRUE);
+		gtk_widget_set_sensitive(gsfw_threshsup_delta_label, TRUE);
+	} else {
+		gtk_widget_set_sensitive(gsfw_threshsup_delta, FALSE);
+		gtk_widget_set_sensitive(gsfw_threshsup_delta_label, FALSE);
+	}
+
+	gsfw_process_label = gtk_label_new("");
+	gtk_label_set_markup(GTK_LABEL(gsfw_process_label), "<span weight=\"bold\">Points Outside Support</span>");
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_process_label), FALSE, FALSE, 10);
+
+	gsfw_hio_hbox = gtk_hbox_new(FALSE, 0);
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_hio_hbox), FALSE, FALSE, 5);
+	gsfw_hio_beta_label = gtk_label_new("β:");
+	gtk_box_pack_start(GTK_BOX(gsfw_hio_hbox), GTK_WIDGET(gsfw_hio_beta_label), FALSE, FALSE, 5);
+	gsfw_hio_beta = gtk_hscale_new_with_range(0, 1, 0.05);
+	gtk_scale_set_value_pos(GTK_SCALE(gsfw_hio_beta), GTK_POS_RIGHT);
+	gtk_box_pack_start(GTK_BOX(gsfw_hio_hbox), GTK_WIDGET(gsfw_hio_beta), TRUE, TRUE, 5);
+	gtk_range_set_value(GTK_RANGE(gsfw_hio_beta), gsf_hio_beta);
+
+	gsfw_gostop_hbox = gtk_hbox_new(FALSE, 0);
+	gsfw_go = gtk_button_new_with_label("Run");
+	gtk_button_set_image(GTK_BUTTON(gsfw_go), gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_BUTTON));
+	gsfw_stop = gtk_button_new_from_stock(GTK_STOCK_MEDIA_STOP);
+	gsfw_reset = gtk_button_new_with_label("Reset");
+	gtk_button_set_image(GTK_BUTTON(gsfw_reset), gtk_image_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS, GTK_ICON_SIZE_BUTTON));
+	gtk_box_pack_start(GTK_BOX(gsfw_gostop_hbox), GTK_WIDGET(gsfw_reset), FALSE, FALSE, 5);
+	gtk_box_pack_start(GTK_BOX(gsfw_gostop_hbox), GTK_WIDGET(gsfw_stop), FALSE, FALSE, 5);
+	gtk_box_pack_start(GTK_BOX(gsfw_gostop_hbox), GTK_WIDGET(gsfw_go), FALSE, FALSE, 5);
+	gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(gsfw_gostop_hbox), FALSE, FALSE, 5);
+	g_signal_connect(G_OBJECT(gsfw_go), "clicked", G_CALLBACK(gsf_window_go), NULL);
+	g_signal_connect(G_OBJECT(gsfw_stop), "clicked", G_CALLBACK(gsf_window_stop), NULL);
+	g_signal_connect(G_OBJECT(gsfw_reset), "clicked", G_CALLBACK(gsf_window_reset), NULL);
+
+	g_signal_connect(G_OBJECT(gsfw_window), "response", G_CALLBACK(gsf_window_close), NULL);
+	g_signal_connect(G_OBJECT(gsfw_window), "delete-event", G_CALLBACK(gsf_window_stop), NULL);
+	g_signal_connect(G_OBJECT(gsfw_centroid), "toggled", G_CALLBACK(gsf_centroid_toggled), NULL);
+	g_signal_connect(G_OBJECT(gsfw_atomicity), "toggled", G_CALLBACK(gsf_atomicity_toggled), NULL);
+	g_signal_connect(G_OBJECT(gsfw_zerofzero), "toggled", G_CALLBACK(gsf_zerofzero_toggled), NULL);
+	g_signal_connect(G_OBJECT(gsfw_fracsup), "toggled", G_CALLBACK(gsf_fracsup_toggled), gsfw_fracsup_phi);
+	g_signal_connect(G_OBJECT(gsfw_fracsup_phi), "value-changed", G_CALLBACK(gsf_fracsup_phichanged), NULL);
+	g_signal_connect(G_OBJECT(gsfw_threshsup), "toggled", G_CALLBACK(gsf_threshsup_toggled), gsfw_threshsup_delta);
+	g_signal_connect(G_OBJECT(gsfw_threshsup_delta), "value-changed", G_CALLBACK(gsf_threshsup_deltachanged), NULL);
+	g_signal_connect(G_OBJECT(gsfw_hio_beta), "value-changed", G_CALLBACK(gsf_hio_betachanged), NULL);
+	g_signal_connect(G_OBJECT(gsfw_antistag), "toggled", G_CALLBACK(gsf_antistag_toggled), NULL);
+	g_signal_connect(G_OBJECT(displaywindow_gtkwindow()), "delete-event", G_CALLBACK(gsf_window_stop), NULL);
+
+	main_gsf_initialise();
+	displaywindow_forceview(DWV_REALSPACE);
+
+	gtk_widget_show_all(gsfw_window);
+
+}
-- 
cgit v1.2.3