s/reflectioncontext/reflectionlist/

git-svn-id: svn://cook.msm.cam.ac.uk:745/diff-tomo/dtr@137 bf6ca9ba-c028-0410-8290-897cf20841d1

1 files changed, 50 insertions, 50 deletions

diff --git a/src/reflections.c b/src/reflections.c
index 3fa1b6d..a0ff76d 100644
--- a/src/reflections.c
+++ b/src/reflections.c
@@ -22,34 +22,34 @@
 #include "reflections.h"
 #include "utils.h"
 
-static void reflection_addfirst(ReflectionContext *reflectionctx) {
+static void reflection_addfirst(ReflectionList *reflectionlist) {
 	/* Create first items on lists - saves faffing later.  Corresponds to a central marker.
 		Reflections are only stored if they have non-zero value. */
-	reflectionctx->reflections = malloc(sizeof(Reflection));
-	reflectionctx->reflections->next = NULL;
-	reflectionctx->reflections->x = 0;
-	reflectionctx->reflections->y = 0;
-	reflectionctx->reflections->z = 0;
-	reflectionctx->reflections->type = REFLECTION_CENTRAL;
-	reflectionctx->last_reflection = reflectionctx->reflections;
-	reflectionctx->n_reflections = 1;
-	reflectionctx->list_capped = 0;
+	reflectionlist->reflections = malloc(sizeof(Reflection));
+	reflectionlist->reflections->next = NULL;
+	reflectionlist->reflections->x = 0;
+	reflectionlist->reflections->y = 0;
+	reflectionlist->reflections->z = 0;
+	reflectionlist->reflections->type = REFLECTION_CENTRAL;
+	reflectionlist->last_reflection = reflectionlist->reflections;
+	reflectionlist->n_reflections = 1;
+	reflectionlist->list_capped = 0;
 }
 
-ReflectionContext *reflection_init() {
+ReflectionList *reflection_init() {
 
-	ReflectionContext *reflectionctx = malloc(sizeof(ReflectionContext));
-	reflectionctx->n_reflections = 0;
-	reflection_addfirst(reflectionctx);
-	reflectionctx->list_capped = 0;
+	ReflectionList *reflectionlist = malloc(sizeof(ReflectionList));
+	reflectionlist->n_reflections = 0;
+	reflection_addfirst(reflectionlist);
+	reflectionlist->list_capped = 0;
 	
-	return reflectionctx;
+	return reflectionlist;
 
 }
 
-void reflection_clear_markers(ReflectionContext *reflectionctx) {
+void reflection_clear_markers(ReflectionList *reflectionlist) {
 
-	Reflection *reflection = reflectionctx->reflections;
+	Reflection *reflection = reflectionlist->reflections;
 	Reflection *prev = NULL;
 	int del = 0;
 	
@@ -64,7 +64,7 @@ void reflection_clear_markers(ReflectionContext *reflectionctx) {
 			if ( prev ) {
 				prev->next = next;
 			} else {
-				reflectionctx->reflections = next;
+				reflectionlist->reflections = next;
 			}
 		} else {
 			prev = reflection;
@@ -74,48 +74,48 @@ void reflection_clear_markers(ReflectionContext *reflectionctx) {
 	
 	} while ( reflection );
 	
-	reflectionctx->n_reflections -= del;
-	reflectionctx->last_reflection = prev;
+	reflectionlist->n_reflections -= del;
+	reflectionlist->last_reflection = prev;
 	
 }
-void reflection_clear(ReflectionContext *reflectionctx) {
+void reflection_clear(ReflectionList *reflectionlist) {
 
-	Reflection *reflection = reflectionctx->reflections;
+	Reflection *reflection = reflectionlist->reflections;
 	do {
 		Reflection *next = reflection->next;
 		free(reflection);
 		reflection = next;
 	} while ( reflection );
 	
-	reflectionctx->n_reflections = 0;
-	reflectionctx->list_capped = 0;
-	reflection_addfirst(reflectionctx);
+	reflectionlist->n_reflections = 0;
+	reflectionlist->list_capped = 0;
+	reflection_addfirst(reflectionlist);
 
 }
 
-void reflection_free(ReflectionContext *reflectionctx) {
-	reflection_clear(reflectionctx);
-	free(reflectionctx->reflections);
-	free(reflectionctx);
+void reflection_free(ReflectionList *reflectionlist) {
+	reflection_clear(reflectionlist);
+	free(reflectionlist->reflections);
+	free(reflectionlist);
 }
 
-Reflection *reflection_add(ReflectionContext *reflectionctx, double x, double y, double z, double intensity, ReflectionType type) {
+Reflection *reflection_add(ReflectionList *reflectionlist, double x, double y, double z, double intensity, ReflectionType type) {
 
 	Reflection *new_reflection;
 	Reflection *nearest;
 	
-	if ( reflectionctx->list_capped ) return NULL;
+	if ( reflectionlist->list_capped ) return NULL;
 	
-	if ( reflectionctx->n_reflections > 1e7 ) {
+	if ( reflectionlist->n_reflections > 1e7 ) {
 		fprintf(stderr, "More than 10 million reflections on list.  I think this is silly.\n");
 		fprintf(stderr, "No further reflections will be stored.  Go and fix the peak detection.\n");
-		reflectionctx->list_capped = 1;
+		reflectionlist->list_capped = 1;
 	}
 	
-	nearest = reflection_find_nearest_type(reflectionctx, x, y, z, type);
+	nearest = reflection_find_nearest_type(reflectionlist, x, y, z, type);
 	if ( nearest && distance3d(x, y, z, nearest->x, nearest->y, nearest->z) < 0.1e9 ) return NULL;
 	
-	reflectionctx->n_reflections++;
+	reflectionlist->n_reflections++;
 	
 	new_reflection = malloc(sizeof(Reflection));
 	new_reflection->next = NULL;
@@ -126,8 +126,8 @@ Reflection *reflection_add(ReflectionContext *reflectionctx, double x, double y,
 	new_reflection->type = type;
 	new_reflection->found = 0;
 	
-	reflectionctx->last_reflection->next = new_reflection;
-	reflectionctx->last_reflection = new_reflection;
+	reflectionlist->last_reflection->next = new_reflection;
+	reflectionlist->last_reflection = new_reflection;
 	
 	return new_reflection;
 	
@@ -216,23 +216,23 @@ void reflection_add_from_dp(ControlContext *ctx, double x, double y, ImageRecord
 	refl.intensity = intensity;
 	
 	if ( !reflection_map_to_space(&refl, &nx, &ny, &nz, &twotheta) ) {
-		reflection_add(ctx->reflectionctx, nx, ny, nz, intensity, REFLECTION_NORMAL);
+		reflection_add(ctx->reflectionlist, nx, ny, nz, intensity, REFLECTION_NORMAL);
 	}
 
 }
 
-void reflection_add_from_reflection(ReflectionContext *rctx, Reflection *r) {
+void reflection_add_from_reflection(ReflectionList *reflectionlist, Reflection *r) {
 	r->next = NULL;
-	rctx->last_reflection->next = r;
-	rctx->last_reflection = r;
+	reflectionlist->last_reflection->next = r;
+	reflectionlist->last_reflection = r;
 }
 
-double reflection_largest_g(ReflectionContext *reflectionctx) {
+double reflection_largest_g(ReflectionList *reflectionlist) {
 
 	double max = 0.0;
 	Reflection *reflection;
 	
-	reflection = reflectionctx->reflections;
+	reflection = reflectionlist->reflections;
 	while ( reflection ) {
 		if ( reflection->type == REFLECTION_NORMAL ) {
 			double mod;
@@ -246,13 +246,13 @@ double reflection_largest_g(ReflectionContext *reflectionctx) {
 
 }
 
-Reflection *reflection_find_nearest(ReflectionContext *reflectionctx, double x, double y, double z) {
+Reflection *reflection_find_nearest(ReflectionList *reflectionlist, double x, double y, double z) {
 
 	double max = +INFINITY;
 	Reflection *reflection;
 	Reflection *best = NULL;
 	
-	reflection = reflectionctx->reflections;
+	reflection = reflectionlist->reflections;
 	while ( reflection ) {
 		if ( reflection->type == REFLECTION_NORMAL ) {
 			double mod;
@@ -269,13 +269,13 @@ Reflection *reflection_find_nearest(ReflectionContext *reflectionctx, double x,
 
 }
 
-Reflection *reflection_find_nearest_longer(ReflectionContext *reflectionctx, double x, double y, double z, double min_distance) {
+Reflection *reflection_find_nearest_longer(ReflectionList *reflectionlist, double x, double y, double z, double min_distance) {
 
 	double max = +INFINITY;
 	Reflection *reflection;
 	Reflection *best = NULL;
 	
-	reflection = reflectionctx->reflections;
+	reflection = reflectionlist->reflections;
 	while ( reflection ) {
 		if ( (reflection->type == REFLECTION_NORMAL) && (!reflection->found) ) {
 			double mod;
@@ -292,13 +292,13 @@ Reflection *reflection_find_nearest_longer(ReflectionContext *reflectionctx, dou
 
 }
 
-Reflection *reflection_find_nearest_type(ReflectionContext *reflectionctx, double x, double y, double z, ReflectionType type) {
+Reflection *reflection_find_nearest_type(ReflectionList *reflectionlist, double x, double y, double z, ReflectionType type) {
 
 	double max = +INFINITY;
 	Reflection *reflection;
 	Reflection *best = NULL;
 	
-	reflection = reflectionctx->reflections;
+	reflection = reflectionlist->reflections;
 	while ( reflection ) {
 		if ( reflection->type == type ) {
 			double mod;