 trunk/TODO 2011/05/09 18:56:15 1162
+++ trunk/TODO 2011/06/15 16:54:05 1349
@@ 5,13 +5,15 @@
SHORT TERM ============= (*needed* for streamlines & tractography)
========================
[GLK:3] Add sequence types (needed for evals & evecs)
+Remove CL from compiler
+
+[GLK:2] Add sequence types (needed for evals & evecs)
syntax
types: ty '{' INT '}'
value construction: '{' e1 ',' … ',' en '}'
indexing: e '{' e '}'
[GLK:4] evals & evecs for symmetric tensor[2,2] and
+[GLK:3] evals & evecs for symmetric tensor[2,2] and
tensor[3,3] (requires sequences)
ability to emit/track/record variables into dynamically resized
@@ 23,20 +25,15 @@
SHORTISH TERM ========= (to make using Diderot less annoying to
======================== program in, and slow to execute)
valuenumbering optimization
+valuenumbering optimization [DONE]
+
+Allow ".ddro" file extensions in addition to ".diderot"
[GLK:1] Add a clamp function, which takes three arguments; either
three scalars:
 clamp(lo, hi, x) = max(lo, min(hi, x))
or three vectors of the same size:
 clamp(lo, hi, [x,y]) = [max(lo[0], min(hi[0], x)),
 max(lo[1], min(hi[1], y))]
This would be useful in many current Diderot programs.
One question: clamp(x, lo, hi) is the argument order used in OpenCL
and other places, but clamp(lo, hi, x) is much more consistent with
lerp(lo, hi, x), hence GLK's preference
+Be able to output values of type tensor[2,2] and tensor[3,3];
+(currently only scalars & vectors). Want to add some regression tests
+based on this and currently can't
[GLK:2] Proper handling of stabilize method
+[GLK:1] Proper handling of stabilize method
allow "*" to represent "modulate": percomponent multiplication of
vectors, and vectors only (not tensors of order 2 or higher). Once
@@ 46,17 +43,17 @@
implicit type promotion of integers to reals where reals are
required (e.g. not exponentiation "^")
[GLK:5] Save Diderot output to nrrd, instead of "mip.txt"
+[GLK:4] Save Diderot output to nrrd, instead of "mip.txt"
For grid of strands, save to similarlyshaped array
For list of strands, save to long 1D (or 2D for nonscalar output) list
For ragged things (like tractography output), will need to save both
complete list of values, as well as list of start indices and lengths
to index into complete list
[GLK:6] Use of Teem's "hest" commandline parser for getting
any input variables that are not defined in the source file
+[GLK:5] Use of Teem's "hest" commandline parser for getting
+any "input" variables that are not defined in the source file.
[GLK:7] ability to declare a field so that probe positions are
+[GLK:6] ability to declare a field so that probe positions are
*always* "inside"; with various ways of mapping the known image values
to nonexistant index locations. One possible syntax emphasizes that
there is a index mapping function that logically precedes convolution:
@@ 87,8 +84,10 @@
"initially" supports lists
"initially" supports lists of positions output from
different initalization Diderot program
+"initially" supports lists of positions output from different
+initalization Diderot program (or output from the same program;
+e.g. using output of iso2d.diderot for one isovalue to seed the input
+to another invocation of the same program)
Communication between strands: they have to be able to learn each
other's state (at the previous iteration). Early version of this can
@@ 108,16 +107,12 @@
Allow integer exponentiation ("^2") to apply to square matrices,
to represent repeated matrix multiplication
Alow X *= Y, X /= Y, X += Y, X = Y to mean what they do in C,
provided that X*Y, X/Y, X+Y, XY are already supported.
Nearly every Diderot program would be simplified by this.

Put small 1D and 2D fields, when reconstructed specifically by tent
and when differentiation is not needed, into faster texture buffers.
test/illustvr.diderot is good example of program that uses multiple
such 1D fields basically as lookuptablebased function evaluation
expand trace in mid to low translation
+expand trace in mid to low translation [DONE]
extend norm (exp) to all tensor types [DONE for vectors and matrices]
@@ 156,7 +151,7 @@
(but we should only duplicate over the liverange of the result of the
conditional.
[GLK:8] Want: nontrivial field expressions & functions.
+[GLK:7] Want: nontrivial field expressions & functions.
scalar fields from scalar fields F and G:
field#0(2)[] X = (sin(F) + 1.0)/2;
field#0(2)[] X = F*G;
@@ 175,6 +170,15 @@
There is value in having these, even if the differentiation of them is
not supported (hence the indication of "field#0" for these above)
+Introduce region types (syntax region(d), where d is the dimension of the
+region. One useful operator would be
+ dom : field#k(d)[s] > region(d)
+Then the inside test could be written as
+ pos ∈ dom(F)
+We could further extend this approach to allow geometric definitions of
+regions. It might also be useful to do inside tests in world space,
+instead of image space.
+
co vs contra index distinction
Permit field composition:
@@ 190,15 +194,19 @@
field#2(3)[] F = bspln3 ⊛ img;
or, as a tensor product of kernels, one for each axis, e.g.
field#0(3)[] F = (bspln3 ⊗ bspln3 ⊗ tent) ⊛ img;
This is especially important for things like timevarying data, or
other multidimensional fields where one axis of the domain is very
different from the rest, and hence must be treated separately when
it comes to convolution. What is very unclear is how, in such cases,
we should notate the gradient, when we only want to differentiate with
respect to some subset of the axes. One ambitious idea would be:
+This is especially important for things like timevarying fields
+and the use of scalespace in field visualization: one axis of the
+must be convolved with a different kernel during probing.
+What is very unclear is how, in such cases, we should notate the
+gradient, when we only want to differentiate with respect to some
+subset of the axes. One ambitious idea would be:
field#0(3)[] Ft = (bspln3 ⊗ bspln3 ⊗ tent) ⊛ img; // 2D timevarying field
 field#0(2)[] F = lambda([x,y], Ft([x,y,42.0])) // restriction to time=42.0
 vec2 grad = ∇F([x,y]); // 2D gradient
+ field#0(2)[] F = lambda([x,y], Ft([x,y,42.0])) // restriction to time=42.0
+ vec2 grad = ∇F([x,y]); // 2D gradient
+
+Tensors of order 3 (e.g. gradients of diffusion tensor fields, or
+hessians of vector fields) and order 4 (e.g. Hessians of diffusion
+tensor fields).
representation of tensor symmetry
(have to identify the group of index permutations that are symmetries)
@@ 207,10 +215,35 @@
outer works on all tensors
+Help for debugging Diderot programs: need to be able to uniquely
+identify strands, and for particular strands that are known to behave
+badly, do something like printf or other logging of their computations
+and updates.
+
+Permit writing dimensionally general code: Have some statement of the
+dimension of the world "W" (or have it be learned from one particular
+field of interest), and then able to write "vec" instead of
+"vec2/vec3", and perhaps "tensor[W,W]" instead of
+"tensor[2,2]/tensor[3,3]"
+
+Traits: all things things that have boilerplate code (especially
+volume rendering) should be expressed in terms of the unique
+computational core. Different kinds of streamline/tractography
+computation will be another example, as well as particle systems.
+
Einstein summation notation
"tensor comprehension" (like list comprehension)
+Fields coming from different sources of data:
+* triangular or tetrahedral meshes over 2D or 3D domains (of the
+ source produced by finiteelement codes; these will come with their
+ own specialized kinds of reconstruction kernels, called "basis
+ functions" in this context)
+* Large point clouds, with some radial basis function around each point,
+ which will be tuned by parameters of the point (at least one parameter
+ giving some notion of radius)
+
======================
BUGS =================
======================
@@ 220,3 +253,4 @@
// uncaught exception Size [size]
// raised at ctarget/ctarget.sml:47.1547.19
//field#4(3)[] F = img ⊛ bspln5;
+