1: 
(declare (fixnum))
2: 
3: 
;;; a display array has 15 slices in a volume concatenated, first left to right
4: 
;;; then top to bottom, 5 in each row, 3 in each column.  So we define these
5: 
;;; general functions; what goes in the display array is undetermined at this point.
6: 
7: 
(define display-domain
8: 
  (build-Interval '#(0 0)
9: 
		  '#(192 320)))
10: 
11: 
(define (convert-volume-to-display-order volume)
12: 
  (let ((accessor (Array-accessor volume)))
13: 
    (build-Array display-domain
14: 
		 (lambda (k l)
15: .01% 
		   (let ((k-slice (quotient  k 64))
16: .02% 
			 (k-index (remainder k 64))
17: .01% 
			 (l-slice (quotient  l 64))
18: .01% 
			 (l-index (remainder l 64)))
19: .04% 
		     (accessor (+ (* 5 k-slice) l-slice)
20: .02% 
			       (remainder (+ k-index 32) 64)
21: .02% 
			       (remainder (+ l-index 32) 64)))))))
22: 
23: 
;;; Here we build a display array containing the magnitudes of the complex image data
24: 
25: 
(define (volume->magnitude-display volume)
26: 
  (Array-lazy-map Complex-magnitude
27: 
		  (convert-volume-to-display-order volume)))
28: 
29: 
;;; And here we build a display array that contains either 1.0 or 0.0 depending on whether a pixel
30: 
;;; is in an active region.
31: 
32: 
(define (active-regions->display volume)
33: .02% 
  (Array-lazy-map (lambda (active?) (if active? 1.0 0.0))
34: 
		  (convert-volume-to-display-order volume)))
35: 
36: 
;;; We convert a complex volume to a magnitude pgm; we'll normalize the maximum grey level
37: 
;;; for the moment.
38: 
39: 
(define (normalize-magnitude-display magnitude-display)
40: 
  (declare (flonum))
41: 
  (let* ((max-magnitude-inverse (/ (f64vector-ref (Array-reduce (lambda (result y)
42: .01% 
								  (f64vector-set! result 0 (max (f64vector-ref result 0) y))
43: 0% 
								  result)
44: 
								(f64vector 0.0)
45: 
								magnitude-display)
46: 
						  0))))
47: 
    (Array-lazy-map (lambda (magnitude)
48: 0% 
		      (* 256.
49: 0% 
			 magnitude
50: 0% 
			 max-magnitude-inverse))
51: 
		    magnitude-display)))
52: 
53: 
(define (volume->magnitude-pgm volume)
54: 
  (f64->pgm 255 (normalize-magnitude-display (volume->magnitude-display volume))))
55: 
56: 
;;; and now we'll write a pgm file that has active pixels displayed.  I think we'll need to do a damn
57: 
;;; ppm file IO result later to merge these two somehow.
58: 
59: 
(define (active-regions->pgm volume)
60: 
  (f64->pgm 1 (active-regions->display volume)))
61: 
62: 
;;; Some functions to convert to fft and back.
63: 
64: 
(define (data-fft->image data)
65: 
  (fftw2d_create_plan_backward)
66: 
  (fftwc-data data))
67: 
68: 
(define (data-image->fft data)
69: 
  (fftw2d_create_plan_forward)
70: 
  (fftwc-data data))
71: 
72: 
;;; and some filters
73: 
74: 
(define slice-filters '((columns rows)
75: 
			(columns rows)
76: 
			(columns rows)
77: 
			(columns rows)))
78: 
79: 
(define volume-filters '((columns rows)
80: 
			 (columns rows slices)
81: 
			 (columns rows slices)
82: 
			 (columns rows slices)))
83: 
84: 
(define anisotropic-early-time-filters '((volumes)
85: 
					 (volumes)
86: 
					 (volumes)
87: 
					 (columns rows)
88: 
					 (columns rows slices volumes)
89: 
					 (columns rows slices)
90: 
					 (columns rows slices volumes)))
91: 
92: 
(define anisotropic-late-time-filters '((columns rows)
93: 
					(columns rows slices volumes)
94: 
					(columns rows slices)
95: 
					(columns rows slices volumes)
96: 
					(volumes)
97: 
					(volumes)
98: 
					(volumes)))
99: 
100: 
(define isotropic-early-time-filters '((volumes)
101: 
				       (columns rows volumes)
102: 
				       (columns rows slices volumes)
103: 
				       (columns rows slices volumes)
104: 
				       (columns rows slices volumes)))
105: 
106: 
(define isotropic-late-time-filters '((columns rows volumes)
107: 
				      (columns rows slices volumes)
108: 
				      (columns rows slices volumes)
109: 
				      (columns rows slices volumes)
110: 
				      (volumes)))
111: 
112: 
(declare (generic))