From fa080de7afc95aa1c19a6e6fc0e0708ced2eadc4 Mon Sep 17 00:00:00 2001 From: Joseph Hunkeler 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