From fa080de7afc95aa1c19a6e6fc0e0708ced2eadc4 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Wed, 8 Jul 2015 20:46:52 -0400
Subject: Initial commit

---
 pkg/proto/vol/src/doc/concept.hlp | 177 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 177 insertions(+)
 create mode 100644 pkg/proto/vol/src/doc/concept.hlp

(limited to 'pkg/proto/vol/src/doc/concept.hlp')

diff --git a/pkg/proto/vol/src/doc/concept.hlp b/pkg/proto/vol/src/doc/concept.hlp
new file mode 100644
index 00000000..26a814b9
--- /dev/null
+++ b/pkg/proto/vol/src/doc/concept.hlp
@@ -0,0 +1,177 @@
+.help volumes
+
+[OUT OF DATE (Jan 89); this is an original pre-design document]
+
+.ce
+Conceptual Model for 2D Projections of Rotating 3D Images
+
+Consider the problem of visualizing a volume containing emissive and
+absorptive material.  If we had genuine 3D display tools, we could imagine
+something like a translucent 3D image display that we could hold in our
+hand, peer into, and rotate around at will to study the spatial distribution
+of materials inside the volume.
+
+Lacking a 3D display device, we can resort to 2D projections of the interior
+of the volume.  In order to render absorptive material, we need a light
+source behind the volume; this light gets attenuated by absorption as it
+passes through the volume toward the projection plane.  In the general case
+light emitted within the volume contributes positively to the projected
+light intensity, but it also gets attenuated by absorbing material between
+it and the projection plane.  At this point the projection plane has a range
+of intensities representing the combined absorption and emission of material
+along columns through the volume.  But looking at a single 2D projection,
+there would be no way to determine how deep in the original volume a particular
+emitting or absorbing region lay.  One way around this is to cause the volume
+to rotate, making a series of 2D projections.  Playing the projections back
+as a movie gives the appearance of seeing inside a translucent rotating
+volume.
+
+Modelling the full physics of light transmission, absorption, refraction,
+etc. with arbitrary projective geometries would be quite computationally
+intensive and could rival many supercomputer simulations.  However, it is
+possible to constrain the model such that an effective display can be
+generated allowing the viewer to grasp the essential nature of the spatial
+relationships among the volume data in reasonable computational time.  This
+is called volume visualization, which can include a range of display
+techniques approximating the actual physics to varying extents.  There is
+some debate whether visualization problems can best be attacked by simplified
+direct physical models or by different models, such as ones that might better
+enhance the \fBperception\fR of depth.  We will stick with direct physical
+models here, though simplified for computer performance reasons.
+
+For computational purposes we will constrain the projection to be orthogonal,
+i.e. the light source is at infinity, so the projection rays are all parallel.
+With the light source at infinity behind the volume (a datacube), we need not
+model reflection at all.  We will also ignore refraction (and certainly
+diffraction effects).
+
+We can now determine a pixel intensity on the output plane by starting
+at the rear of the column of voxels (volume elements) that project from
+the datacube onto that pixel.  At each successive voxel along that column
+we will attenuate the light we started with by absorption, and add to it
+any light added by emission.  If we consider emission (voxel intensity)
+alone, the projection would just be the sum of the contributing intensities.
+Absorption alone would simply decrease the remaining transmitted light
+proportionally to the opacity of each of the voxels along the column.
+Since we are combining the effects of absorption and emission, the ratio
+of the intensity of the original incident light to that of the interior
+voxels is important, so we will need a beginning intensity.
+
+The opacities have a physical meaning in the model.  However, we are more
+interested here in visualizing the volume interior than in treating it as
+a pure physical model, so we add an opacity transformation function.  This
+allows us to generate different views of the volume interior without having
+to modify all the raw opacity values in the datacube.  For maximum flexibility
+we would like to be able to modify the opacity function interactively, e.g.
+with a mouse, but this would amount to computing the projections in real
+time and is not likely at present.
+
+.nf
+
+Let:	i     = projected intensity before considering the current
+	        voxel
+	i'    = intensity of light after passing through the current
+	        voxel
+	I0    = initial light intensity (background iillumination
+		before encountering the volume)
+	Vo    = opacity at the current voxel, range 0:1 with
+	        0=transparent, 1=opaque
+	Vi    = intensity at the current voxel
+	f(Vo) = function of the opacity at the current voxel,
+		normalized to the range 0:1
+	g(Vi) = function of the voxel's intensity, normalized
+		to the range 0:1
+
+Then:	i' = i * (1 - f(Vo)) + g(Vi)
+		[initial i = Imax, then iterate over all voxels in path]
+
+.fi
+
+We want to choose the opacity and intensity transformation functions in such
+a way that we can easily control the appearance of the final projection.
+In particular, we want to be able to adjust both the opacity and intensity
+functions to best reveal the interior details of the volume during a
+rotation sequence.  For example, we might want to eliminate absorption
+"noise" so that we can see through it to details of more interest, so we
+need a lower opacity cutoff.  Likewise, we would want an upper opacity
+cutoff above which all voxels would appear opaque.  We will need the same
+control over intensity.
+
+.nf
+Let:	o1   = lower voxel opacity cutoff
+	o2   = upper voxel opacity cutoff
+	t1   = lower transmitted intensity cutoff
+	t2   = upper transmitted intensity cutoff
+	i1   = lower voxel intensity cutoff
+	i2   = upper voxel intensity cutoff
+	Imax = output intensity maximum for int transform function
+.fi
+
+Now all we need is the form of the opacity and intensity functions between
+their input cutoffs.  A linear model would seem to be useful, perhaps with
+logarithmic and exponential options later to enhance the lower or upper
+end of the range.  f(Vo) is constrained to run between 0 and 1, because
+after being subtracted from 1.0 it is the intensity attenuation factor
+for the current voxel.
+
+.nf
+
+		Opacity Transformation Function f(Vo):
+
+	        { Vo < o1       : 	    0.0		    }
+	        {					    }
+	        { o1 <= Vo < o2 : (t2 - (Vo - o1)(t2 - t1)) }
+	        {		  (	---------	  ) }
+	f(Vo) = {		  (	(o2 - o1)	  ) }
+	        {		  ------------------------- }
+	        {			    I0	    }
+	        {					    }
+	        { o2 <= Vo      : 	    1.0		    }
+
+
+backg. int.  I0-|
+		|
+	     t2-|------			Transmitted Intensity
+		|        `		as function of opacity
+	        |           `		(ignoring independent
+i * (1 - f(Vo))-|..............`	voxel intensity contri-
+                |               . `	bution)
+    		|               .    `
+		|               .       `
+	     t1-|		.	  |
+		|		.	  |
+		+____________________________________________
+		       |        |         |
+		       o1	Vo 	  o2
+			   Voxel Opacity
+
+       ------------------------------------------------------------
+
+		Intensity Transformation Function g(Vi):
+
+		{ Vi < i1       :    0.0
+		{
+		{ i1 <= Vi < i2 : (Vi - i1) * Imax
+		{		  ---------
+	g(Vi) = {		  (i2 - i1)
+		{
+		{ i2 <= Vi	:    Imax
+		{
+		{
+		{
+
+
+	        |
+		|
+	   Imax-|                       ---------------------
+		|                    /
+	  g(Vi)-|................./
+      		|              /  .
+		|           /     .
+		|        /        .
+	    0.0	+___________________________________________
+		     |            |     |
+		     i1	          Vi    i2
+			Voxel Intensity
+.fi
+
-- 
cgit 

