SCM Repository
Annotation of /trunk/TODO
Parent Directory
|
Revision Log
Revision 1389 - (view) (download)
1 : | glk | 1162 | NOTE: GLK's approximate ranking of 8 most important tagged with |
2 : | jhr | 1115 | [GLK:1], [GLK:2], ... |
3 : | |||
4 : | glk | 1156 | ======================== |
5 : | SHORT TERM ============= (*needed* for streamlines & tractography) | ||
6 : | ======================== | ||
7 : | jhr | 1115 | |
8 : | glk | 1338 | [GLK:2] Add sequence types (needed for evals & evecs) |
9 : | jhr | 1115 | syntax |
10 : | types: ty '{' INT '}' | ||
11 : | value construction: '{' e1 ',' … ',' en '}' | ||
12 : | indexing: e '{' e '}' | ||
13 : | |||
14 : | glk | 1338 | [GLK:3] evals & evecs for symmetric tensor[2,2] and |
15 : | glk | 1162 | tensor[3,3] (requires sequences) |
16 : | |||
17 : | glk | 1156 | ability to emit/track/record variables into dynamically re-sized |
18 : | glk | 1389 | runtime output buffer |
19 : | jhr | 1115 | |
20 : | jhr | 1388 | tensor fields: convolution on general tensor images (order > 1) |
21 : | jhr | 1115 | |
22 : | glk | 1156 | ======================== |
23 : | glk | 1162 | SHORT-ISH TERM ========= (to make using Diderot less annoying to |
24 : | ======================== program in, and slow to execute) | ||
25 : | jhr | 1115 | |
26 : | glk | 1167 | Allow ".ddro" file extensions in addition to ".diderot" |
27 : | |||
28 : | glk | 1204 | Be able to output values of type tensor[2,2] and tensor[3,3]; |
29 : | (currently only scalars & vectors). Want to add some regression tests | ||
30 : | based on this and currently can't | ||
31 : | glk | 1167 | |
32 : | glk | 1338 | [GLK:1] Proper handling of stabilize method |
33 : | jhr | 1115 | |
34 : | glk | 1162 | allow "*" to represent "modulate": per-component multiplication of |
35 : | vectors, and vectors only (not tensors of order 2 or higher). Once | ||
36 : | sequences are implemented this should be removed: the operation is not | ||
37 : | invariant WRT basis so it is not a legit vector computation. | ||
38 : | |||
39 : | implicit type promotion of integers to reals where reals are | ||
40 : | required (e.g. not exponentiation "^") | ||
41 : | |||
42 : | glk | 1338 | [GLK:4] Save Diderot output to nrrd, instead of "mip.txt" |
43 : | jhr | 1115 | For grid of strands, save to similarly-shaped array |
44 : | For list of strands, save to long 1-D (or 2-D for non-scalar output) list | ||
45 : | For ragged things (like tractography output), will need to save both | ||
46 : | complete list of values, as well as list of start indices and lengths | ||
47 : | to index into complete list | ||
48 : | |||
49 : | glk | 1389 | [GLK:5] ability to declare a field so that probe positions are |
50 : | glk | 1120 | *always* "inside"; with various ways of mapping the known image values |
51 : | to non-existant index locations. One possible syntax emphasizes that | ||
52 : | there is a index mapping function that logically precedes convolution: | ||
53 : | glk | 1162 | F = bspln3 ⊛ (img ◦ clamp) |
54 : | glk | 1120 | F = bspln3 ⊛ (img ◦ repeat) |
55 : | F = bspln3 ⊛ (img ◦ mirror) | ||
56 : | where "◦" or "∘" is used to indicate function composition | ||
57 : | jhr | 1115 | |
58 : | glk | 1162 | Level of differentiability in field type should be statement about how |
59 : | much differentiation the program *needs*, rather than what the kernel | ||
60 : | *provides*. The needed differentiability can be less than or equal to | ||
61 : | the provided differentiability. | ||
62 : | |||
63 : | glk | 1156 | Use ∇⊗ etc. syntax |
64 : | syntax [DONE] | ||
65 : | typechecking | ||
66 : | IL and codegen | ||
67 : | jhr | 1115 | |
68 : | glk | 1156 | Add type aliases for color types |
69 : | rgb = real{3} | ||
70 : | rgba = real{4} | ||
71 : | jhr | 1115 | |
72 : | glk | 1389 | Revisit how images are created within the language. |
73 : | The "load" operator should probably go away, and its strangs | ||
74 : | that strings are there only as a way to refer to nrrd filenames | ||
75 : | |||
76 : | jhr | 1115 | ============================== |
77 : | glk | 1156 | MEDIUM TERM ================== (*needed* for particles) |
78 : | jhr | 1115 | ============================== |
79 : | |||
80 : | run-time birth of strands | ||
81 : | |||
82 : | "initially" supports lists | ||
83 : | |||
84 : | glk | 1254 | "initially" supports lists of positions output from different |
85 : | initalization Diderot program (or output from the same program; | ||
86 : | e.g. using output of iso2d.diderot for one isovalue to seed the input | ||
87 : | to another invocation of the same program) | ||
88 : | jhr | 1115 | |
89 : | glk | 1156 | Communication between strands: they have to be able to learn each |
90 : | other's state (at the previous iteration). Early version of this can | ||
91 : | have the network of neighbors be completely static (for running one | ||
92 : | strand/pixel image computations). Later version with strands moving | ||
93 : | through the domain will require some spatial data structure to | ||
94 : | optimize discovery of neighbors. | ||
95 : | jhr | 1115 | |
96 : | glk | 1156 | ============================ |
97 : | MEDIUM-ISH TERM ============ (to make Diderot more useful/effective) | ||
98 : | ============================ | ||
99 : | jhr | 1115 | |
100 : | glk | 1156 | Python/ctypes interface to run-time |
101 : | jhr | 1115 | |
102 : | glk | 1156 | support for Python interop and GUI |
103 : | jhr | 1115 | |
104 : | glk | 1162 | Allow integer exponentiation ("^2") to apply to square matrices, |
105 : | to represent repeated matrix multiplication | ||
106 : | |||
107 : | glk | 1156 | Put small 1-D and 2-D fields, when reconstructed specifically by tent |
108 : | and when differentiation is not needed, into faster texture buffers. | ||
109 : | test/illust-vr.diderot is good example of program that uses multiple | ||
110 : | such 1-D fields basically as lookup-table-based function evaluation | ||
111 : | |||
112 : | extend norm (|exp|) to all tensor types [DONE for vectors and matrices] | ||
113 : | |||
114 : | determinant ("det") for tensor[3,3] | ||
115 : | |||
116 : | jhr | 1115 | add ":" for tensor dot product (contracts out two indices |
117 : | instead of one like •), valid for all pairs of tensors with | ||
118 : | at least two indices | ||
119 : | |||
120 : | glk | 1156 | test/uninit.diderot: |
121 : | documents need for better compiler error messages when output variables | ||
122 : | are not initialized; the current messages are very cryptic | ||
123 : | jhr | 1115 | |
124 : | want: warnings when "D" (reserved for differentiation) is declared as | ||
125 : | a variable name (get confusing error messages now) | ||
126 : | |||
127 : | glk | 1156 | ============================== |
128 : | LONG TERM ==================== (make Diderot more interesting/attractive from | ||
129 : | ============================== a research standpoint) | ||
130 : | jhr | 1115 | |
131 : | glk | 1389 | [GLK:6] Want code-generation working for tensors of order three. |
132 : | Order three matters for edge detection in scalar fields (to get | ||
133 : | second derivatives of gradient magnitude), second derivatives | ||
134 : | of vector fields (for some feature extraction), and first | ||
135 : | derivatives of diffusion tensor fields. | ||
136 : | |||
137 : | glk | 1156 | IL support for higher-order tensor values (matrices, etc). |
138 : | tensor construction [DONE] | ||
139 : | tensor indexing [DONE] | ||
140 : | tensor slicing | ||
141 : | jhr | 1115 | |
142 : | glk | 1156 | Better handling of variables that determines the scope of a variable |
143 : | based on its actual use, instead of where the user defined it. So, | ||
144 : | for example, we should lift strand-invariant variables to global | ||
145 : | scope. Also prune out useless variables, which should include field | ||
146 : | variables after the translation to mid-il. | ||
147 : | |||
148 : | test/vr-kcomp2.diderot: Add support for code like | ||
149 : | (F1 if x else F2)@pos | ||
150 : | This will require duplication of the continuation of the conditional | ||
151 : | (but we should only duplicate over the live-range of the result of the | ||
152 : | conditional. | ||
153 : | |||
154 : | glk | 1338 | [GLK:7] Want: non-trivial field expressions & functions. |
155 : | glk | 1162 | scalar fields from scalar fields F and G: |
156 : | field#0(2)[] X = (sin(F) + 1.0)/2; | ||
157 : | field#0(2)[] X = F*G; | ||
158 : | scalar field of vector field magnitude: | ||
159 : | glk | 1156 | image(2)[2] Vimg = load(...); |
160 : | field#0(2)[] Vlen = |Vimg ⊛ bspln3|; | ||
161 : | glk | 1162 | field of normalized vectors (for LIC and vector field feature extraction) |
162 : | field#2(2)[2] F = ... | ||
163 : | field#0(2)[2] V = normalize(F); | ||
164 : | scalar field of gradient magnitude (for edge detection)) | ||
165 : | glk | 1156 | field#2(2)[] F = Fimg ⊛ bspln3; |
166 : | field#0(2)[] Gmag = |∇F|; | ||
167 : | glk | 1162 | scalar field of squared gradient magnitude (simpler to differentiate): |
168 : | glk | 1156 | field#2(2)[] F = Fimg ⊛ bspln3; |
169 : | field#0(2)[] Gmsq = ∇F•∇F; | ||
170 : | glk | 1162 | There is value in having these, even if the differentiation of them is |
171 : | not supported (hence the indication of "field#0" for these above) | ||
172 : | glk | 1156 | |
173 : | jhr | 1195 | Introduce region types (syntax region(d), where d is the dimension of the |
174 : | region. One useful operator would be | ||
175 : | dom : field#k(d)[s] -> region(d) | ||
176 : | Then the inside test could be written as | ||
177 : | pos ∈ dom(F) | ||
178 : | We could further extend this approach to allow geometric definitions of | ||
179 : | regions. It might also be useful to do inside tests in world space, | ||
180 : | instead of image space. | ||
181 : | |||
182 : | glk | 1162 | co- vs contra- index distinction |
183 : | glk | 1156 | |
184 : | glk | 1162 | Permit field composition: |
185 : | glk | 1156 | field#2(3)[3] warp = bspln3 ⊛ warpData; |
186 : | field#2(3)[] F = bspln3 ⊛ img; | ||
187 : | field#2(3)[] Fwarp = F ◦ warp; | ||
188 : | glk | 1162 | So Fwarp(x) = F(warp(X)). Chain rule can be used for differentation. |
189 : | This will be instrumental for expressing non-rigid registration | ||
190 : | methods (but those will require co-vs-contra index distinction) | ||
191 : | glk | 1156 | |
192 : | glk | 1155 | Allow the convolution to be specified either as a single 1D kernel |
193 : | (as we have it now): | ||
194 : | field#2(3)[] F = bspln3 ⊛ img; | ||
195 : | or, as a tensor product of kernels, one for each axis, e.g. | ||
196 : | field#0(3)[] F = (bspln3 ⊗ bspln3 ⊗ tent) ⊛ img; | ||
197 : | glk | 1212 | This is especially important for things like time-varying fields |
198 : | and the use of scale-space in field visualization: one axis of the | ||
199 : | must be convolved with a different kernel during probing. | ||
200 : | What is very unclear is how, in such cases, we should notate the | ||
201 : | gradient, when we only want to differentiate with respect to some | ||
202 : | subset of the axes. One ambitious idea would be: | ||
203 : | glk | 1162 | field#0(3)[] Ft = (bspln3 ⊗ bspln3 ⊗ tent) ⊛ img; // 2D time-varying field |
204 : | glk | 1204 | field#0(2)[] F = lambda([x,y], Ft([x,y,42.0])) // restriction to time=42.0 |
205 : | vec2 grad = ∇F([x,y]); // 2D gradient | ||
206 : | glk | 1155 | |
207 : | glk | 1204 | Tensors of order 3 (e.g. gradients of diffusion tensor fields, or |
208 : | hessians of vector fields) and order 4 (e.g. Hessians of diffusion | ||
209 : | tensor fields). | ||
210 : | |||
211 : | glk | 1162 | representation of tensor symmetry |
212 : | jhr | 1115 | (have to identify the group of index permutations that are symmetries) |
213 : | |||
214 : | dot works on all tensors | ||
215 : | |||
216 : | outer works on all tensors | ||
217 : | |||
218 : | glk | 1204 | Help for debugging Diderot programs: need to be able to uniquely |
219 : | identify strands, and for particular strands that are known to behave | ||
220 : | badly, do something like printf or other logging of their computations | ||
221 : | and updates. | ||
222 : | |||
223 : | Permit writing dimensionally general code: Have some statement of the | ||
224 : | dimension of the world "W" (or have it be learned from one particular | ||
225 : | field of interest), and then able to write "vec" instead of | ||
226 : | "vec2/vec3", and perhaps "tensor[W,W]" instead of | ||
227 : | "tensor[2,2]/tensor[3,3]" | ||
228 : | |||
229 : | Traits: all things things that have boilerplate code (especially | ||
230 : | volume rendering) should be expressed in terms of the unique | ||
231 : | computational core. Different kinds of streamline/tractography | ||
232 : | computation will be another example, as well as particle systems. | ||
233 : | |||
234 : | jhr | 1115 | Einstein summation notation |
235 : | |||
236 : | "tensor comprehension" (like list comprehension) | ||
237 : | |||
238 : | glk | 1204 | Fields coming from different sources of data: |
239 : | * triangular or tetrahedral meshes over 2D or 3D domains (of the | ||
240 : | source produced by finite-element codes; these will come with their | ||
241 : | own specialized kinds of reconstruction kernels, called "basis | ||
242 : | functions" in this context) | ||
243 : | * Large point clouds, with some radial basis function around each point, | ||
244 : | which will be tuned by parameters of the point (at least one parameter | ||
245 : | giving some notion of radius) | ||
246 : | |||
247 : | jhr | 1115 | ====================== |
248 : | BUGS ================= | ||
249 : | ====================== | ||
250 : | |||
251 : | test/zslice2.diderot: | ||
252 : | // HEY (bug) bspln5 leads to problems ... | ||
253 : | // uncaught exception Size [size] | ||
254 : | // raised at c-target/c-target.sml:47.15-47.19 | ||
255 : | //field#4(3)[] F = img ⊛ bspln5; | ||
256 : | glk | 1336 |
root@smlnj-gforge.cs.uchicago.edu | ViewVC Help |
Powered by ViewVC 1.0.0 |