forked from BRL-CAD/brlcad
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathTODO
2760 lines (2085 loc) · 111 KB
/
TODO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
-*- coding: utf-8 -*-
BRL-CAD To Do List
==================
This document contains a collection of desirable BRL-CAD development
tasks. Included is a list of the tasks expected for the current
monthly development release iteration, tasks that will hopefully be
completed within two iterations, and a remaining "backlog" of
unscheduled development tasks.
This is not an official list of tasks that will be completed. Instead
it's more like a developer scratch pad for recording ideas and
coordinating release tasks. At the beginning of each month,
developers add the tasks they expect to complete and then remove those
tasks as they are completed.
THESE TASKS SHOULD HAPPEN BEFORE THE NEXT RELEASE
-------------------------------------------------
* On some Windows machine Tcl script commands using "puts" to write to
stdout are intermittently failing with:
Error: error writing "stdout": invalid argument
THESE TASKS SHOULD HAPPEN WITHIN TWO RELEASE ITERATIONS
-------------------------------------------------------
* dbconcat corrupted database / failed. created a top-level comb with
invalid "1_[subcomb]/" to be created that result in error messages
during any db listing (e.g., tops). workaround was to manually edit
the comb and remove the 1_ and / on the entries.
* The following will be removed from MGED's menu bar (unused
features, can be accomplished another way, or will be exposed
only as lower level settings when there are sensible defaults
that are seldom changed.)
Modes->Display Lists
Misc->Keystroke Forwarding
Misc->Depth Cueing
Misc->Z Buffer
Misc->Lighting
* implement uv-mapping callback so we can texture-map BoT, NMG, and
NURBS geometry
* modify libfb's default memory buffer allocation to be dynamic
* create a BRL-CAD .g with all possible object types embedded.
integrate into testing. e.g., scene with all object types plus a
lookup check to ensure none are missing.
* fix pipe subtractions shaded display issue in archer
* attribute normalization is drastically slowing down
region creation - need to fix or back out
* add regression test for directional light sources
* bundle primary rays in rt front end into postage stamps, shoot via
rt_shootrays(), modify to pass all rays down through the spatial
partitioning simultaneously
* readd support for vrml v1 to g-vrml so that users can select whether
they want v2 (default) or previous v1 output format via a
command-line switch. see http://brlcad.svn.sf.net/viewvc/brlcad/brlcad/trunk/conv/g-vrml.c?view=diff&pathrev=22798&r1=16900&r2=16901
* metaball in command input needs sanity checks and better validation.
* integrate gen-registered-attributes-html output into website
* brlcad-config build helper script is not working (not reporting
-llibs, reporting semicolon list for 'brlcad' lib). Example working output:
$ /usr/brlcad/rel-7.18.0/bin/brlcad-config brlcad
-L/usr/brlcad/rel-7.18.0/lib -m64 -L/usr/local/lib64 -L/usr/local/lib -pipe -fno-strict-aliasing -fno-common -fexceptions -ggdb3 -D_FORTIFY_SOURCE=2 -O3 -w -L/usr/brlcad/rel-7.18.0/lib -lbrlcad -lged -lwdb -lrt -lbn -lbu -ltcl8.5 -ldl -lm -lpng14 -lz -lc -lpthread -lregex -lsysv -lopenNURBS -lanalyze
$ /usr/brlcad/rel-7.18.0/bin/brlcad-config rt
-L/usr/brlcad/rel-7.18.0/lib -m64 -L/usr/local/lib64 -L/usr/local/lib -pipe -fno-strict-aliasing -fno-common -fexceptions -ggdb3 -D_FORTIFY_SOURCE=2 -O3 -w -L/usr/brlcad/rel-7.18.0/lib -lrt -lbn -lbu -ltcl8.5 -ldl -lm -lpng14 -lz -lc -lpthread -lregex -lsysv -lopenNURBS
* OpenCL for enhanced performance boolweave sorting
* create boolweave+boolfinal unit tests to validate weaving behavior
and performance.
* make sure we can run db_dirbuild() multiple times without creating
duplicate entries.
* tree command shouldn't infinite loop when encountering a cyclic
path - need to print a warning and stop walking. Requries full
path awareness in tree command walk.
Consider implementing a corollary to FTS instead of dirent for
simplified tree traversal with cyclic awareness.
https://keramida.wordpress.com/2009/07/05/fts3-or-avoiding-to-reinvent-the-wheel/
* bounding box reduction command
* consolidate dbconcat, clone, make_name, and any other .g I/O
routines that need to autogenerate names to use the new
bu_vls_incr/bu_vls_simplify functions.
* g-obj not exporting colors
* heap unit test needs to actually compare performance against system
allocation, not just do some work
* mged> nirt -? needs to provide help
* mged> nirt -f fmt doesn't seem to work at all
* move the rt_*_timer timing facilities to libbu and rework to allow
contexts, allowing for more than one timer to be active. Make sure
the old librt API can be obsoleted cleanly.
* investigate problems with struct parsing running the MGED
"vars" command - most visible on OpenBSD, but Linux valgrind can
also see issues.
THESE ARE UNSCHEDULED BACKLOG TASKS
-----------------------------------
* dbconcat option to override / merge over existing objects
* gdiff in mged appears to be broken? get "no primitives found" on
second comb when specifying two combs (gdiff comb1 comb2).
UPDATE - this appears to be a consequence of how gdiff internally
implements its raytrace diffing. The "fix" would be to separately
raytrace each object and post-process the line segments, rather
than drawing up everything at once - the latter has problems if
part or all of comb2 is shared with comb1. A workaround is to
keep out comb2 and dbconcat it back in, then gdiff comb1 with the
imported tree.
* pixscale doesn't seem to handle stdin (due to bu_seek) for very
long
* The embedded framebuffer for the X display manager is not working
with Tcl/Tk 8.6 - it brings down mged with an Xerror when it tries
to XFlush after X24_blit. Better solution is to replace the X
dm/fb with a cross platform software rasterizing solution of some
sort.
* extract a skin or other exterior surface for a given model. 3 options:
1. Implement a "shrinkwrap" feature that calculates a concave hull
2. Shoot rays from outside, construct exterior mesh based on hits
(akin to marching cubes, a surface reconstruction)
3. Shoot rays from outside at exterior vertices, retain all mesh faces
and objects encountered (i.e., not reconstructed, but extracted)
* RTAREA
* add an option to rtarea for onehit. this is probably best as an
option that reports the requested objects only and then has a
verbose option for the more detailed hiearchical report that is
currently produced.
* verify rtarea. There are reports that the rtarea
command may have a bug in its calculations. This needs to be
investigated.
* review and fix rtarea's taxonomy for describing
presented/projected areas. users expect presented area to
represent what is currently referred to as exposed area. may make
more sense to introduce a different terms for other shotline
encounters.
* make rtarea display a cross-hair and perhaps coordinates for the
center of area if run from within mged.
* add an option to rtarea for onehit. this is probably best as an
option that reports the requested objects only and then has a
verbose option for the more detailed hiearchical report that is
currently produced.
* verify rtarea. There are reports that the rtarea
command may have a bug in its calculations. This needs to be
investigated.
* review and fix rtarea's taxonomy for describing
presented/projected areas. users expect presented area to
represent what is currently referred to as exposed area. may make
more sense to introduce a different terms for other shotline
encounters.
* make rtarea display a cross-hair and perhaps coordinates for the
center of area if run from within mged.
* bot -V check solid bot.s visualizations don't show up if bot.s is
first drawn in MGED - should properly "overlay" them so the user
doesn't have to first erase the solid from the scene visual.
* MGED's startup directory is inconsistent and sometimes problematic.
If the current working directory is read-only (e.g., a default
system install and opening one of the sample .g files), then
numerous commands the write out to the current path will fail (e.g.,
"idents file.log"). Review startup path behavior and consider using
$HOME or some other system path, unless started on the command-line.
* rtwizard's reopening of the database is causing db_dircheck
"Duplicate of..." errors when opening read-only .g files.
* procedural studio box generation allowing for specification of size,
shape, material, and lighting characteristics
* verify all of the src/util utilities behave correctly on Windows
with respect to mode (i.e. correctly using setmode/O_BINARY when
performing file I/O.)
* the osgl libdm backend has what appears to be an off-by-one-pixel
error in the x and y directions with respect to mouse placement.
Using kmag, can see tha putting the mouse cursor over the center
yellow dot and center clicking (which should be a no-op, and is
with ogl) results in the scene shifting slightly.
* replace los references/terminology with span, len, dist, factor, etc
accordingly since los is ambiguous and a source of user confusion.
* enhance env command to handle debug variables, use sysctl style
groupings of variables, and in general make the setup simpler
and more uniform (ideally we'll fold the debug command's
capabilities into env in some form.) Need to have a usability
brainstorming session, but after discussion with Sean general
outlines are to:
Switch all debug variable management to staging through
environment variables rather than directly setting hex values
on the globals, but leave the globals as the low level mechanism
for performance reasons (getenv is much more expensive, don't
want it in core code.) Something like:
LIBRT_DEBUG_HF (env variable) -> debug.rt_hf (env cmd) -> rt_debug hex val (library)
* overlay command needs to accept multiple file arguments
* Bounding Boxes
* make the bb command default to calculating a tighter-fitting
bounding box using plot points and knowledge of the subtraction
objects (e.g., perform inside/outside test against arb8s).
* implement a faster raytraced AABB function that calls ft_plot(),
shoots a ray through each point, and computes the resulting box.
* g-shell-rect appears to be the only command that will give a
raytraced AABB. we need to refactor that feature into either the
gqa -Ab (which merely reports the prep box) or the analyze command
(or both).
* add option(s) to 'bb' for reporting different types of boxes:
1) unevaluated, without subtractions (current fast result)
2) unevaluated, with subtractions
3) evaluated, coarse (use plot points)
4) evaluated, precise (use ray tracing)
5) evaluated, exact (requires Implicit+CSG->BREP+CSG->BREP-CSG)
option dimensionality #1: sphere v aabb v obb v 8dop v cxhull
#2: unevaluated v evaluated booleans
#3: without v with subtractions
#4: coarse v precise v exact
* investigate why the new bbox() routines for ARS and BoT result in
bounding boxes that are way too big.
* implement prep optimzation to the default fast bbox approximation
specifically for arb8/rpp since we know the exact extent of their
bounds and can chop away at a box with a box.
* make gqa -Ab use sample points for reporting an evaluated AABB.
* make bb report an evaluated AABB by default.
* provide option for displaying object bounding boxes while
rotating. visualization feature to help with rotation operations,
showing global object alignment with respect to its own coordinate
space.
* Extract bounding box code from both autoview.c and get_autoview.c
into a general bounding rpp function in librt and use accordingly
(particularly in libged). Should combine autoview.c with
get_autoview.c (perhaps as a flag) and utilize the general
function in lots of places (e.g., the ged_arb() function).
* add unit tests for primitive callback routines (e.g., bbox).
* put bu_num_print() to use
* use bu_gettime() in rt -l8 heatgraph visualization mode
* fully implement analyze for all geometry objects
* implement general analyze estimate (perhaps just raytrace it) for
primitives where values like surface area, volume, or bb are very
difficult to calculate.
* move analyze logic into libanalyze (with respective primitive logic
into src/librt/primitives/*).
* extend analyze output formatting to user-specified formats ala nirt
* calculate products of inertia in 'analyze' and/or gqa output
* calculate radii of gyration in 'analyze' and/or gqa output
* implement make, ted, edsol, mirror, and analyze for revolve
primitive. implement tess() too.
* go_open inmem to db command
* optimize mged interactive loop command processing. creating 10k
objects: 40 sec, via inmem: 2 sec
* rtwizard unit test legitimately failing on mac/windows
* implement a bu_exec wrapper and investigate something like capnproto
to build up a process-isolated command execution system for libged.
Possibly useful resources:
- https://github.com/s-u/multicore/blob/master/src/forknt.c
- https://github.com/diacritic/BoxFort
- https://yuhui-lin.github.io/blog/2017/08/01/serialization
* Implement a bu alarm(2)-style interface so we can abort library
routines gracefully from application code. A quick initial attempt
at this didn't succeed very well (r71644 has what was tried).
* cppclean audit
* add a multiview rt script to regression testing (e.g., see rtwalk output)
* finish implementing pnts:
- ray trace pnts
- make color and vectors on pnts work
* handling of geometry with names like "--_25" fails in archer
* drawing with origin, axes, and overall dimensions for rt/rtedge/etc.
* gather v&v docs on configuration management process, user manuals,
process documentation, software documentation, model descriptions.
* STIX 2.0 fonts are released, using OpenType - check to see whether
we can upgrade to these for our DocBook processing
* Fedora doesn't have the old fonts mged assumes: dm-X: Can't open font '9x15' or '-adobe-courier-medium-r-normal--10-100-75-75-m-60-iso8859-1'
* Investigate using https://github.com/weiss/c99-snprintf to guarantee
snprintf cross-platform. There are potential drawbacks to the current
MSVC approach pre Visual Studio 2015 (_snprintf doesn't null terminate
on overflow, and _snprintf_s returns -1 on overflow...)
* lay out filesystem and URI models for database storage and access -
these design decisions are fundamental and have broad implications for many
other design decisions. Issues to consider include where and how versioning,
how to access attribute data from URIs, what the filesystem analogies are
(combs -> directories, objects -> hard links, etc...), where they break down
(comb boolean expressions don't map cleanly to the notion of directory
contents, for example) and how to handle the various cases, how to present
a "db_glob" API etc. Need a proper document laying all of this out.
Potentially relevant/useful links:
URI specification: https://tools.ietf.org/html/rfc3986
Minimal URI parser: https://github.com/cloderic/curi
Larger URI parser: https://github.com/bnoordhuis/uriparser2
Fast parser, has deps: https://github.com/toffaletti/libguri
OpenBSD glob with function callbacks (rework/simplify
to be *only* a callback API to make this properly generic,
then have OS or .g specific functions...):
https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/include/glob.h
https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/lib/libc/gen/glob.c
* look at components of the Screened Poisson code and figure out where/how
they would map into BRL-CAD components. (this is partially to see whether
we can (re)implement this logic in our framework and partially an exercise
in BRL-CAD library scoping)
* replace guts of bu_ptbl to see if we can improve performance -
implications for removal if an appropriate substitute is found,
needs to be deprecated if we remove all API but we can update guts.
Try moodycamel https://github.com/cameron314/concurrentqueue
* check state of adaptagrams work - turn on? if not, delete?
* brlman - need remote text display in MGED, maybe run non-graphical brlman
in MGED console mode? A last resort fallback could be console text output
via mandoc...
* add ability to capture any command's output to a file, ideally with
options for specifying stdout and/or stderr. of priority are the
attr and rtcheck/gqa commands. this should probably be handled by a
libged command wrapper so it's consistent and available to any
command.
* mater command does not validate its arguments - fix that. Also
properly document using "." to skip specifying something - not in
the man page currently.
* bullet integration - need to expose restitution as an
object parameter so we can configure behavior:
http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=&f=&t=3248
* afl on libged/mged/rt/...
* moodycamel as libbu queue/list/ptbl implementation
* define geometry URL and VFS behavior
* change _mged_ command prefix to a simple '.' prefix to hide/protect
the built-in commands.
* sync tgc/rec shot() behavior, sort results for proper normal.
inspect t62 grazing with r653,r735 (tgc on an arb8) looking at ae0,0
and z=1524 (was hit/overlap, now misses).
* havoc.g s.nos5g reliably exhibits the grazing edge bug where only
one hit point is being returned. to reproduce:
e s.nos5g ; ae 35 25 ; units mm ; center 26912.4 7089.08 7168.96 ; nirt
* obsd stack crashers
* closing the graphics window brings down X11 on Mac due to a bad
context. fix or revert recent close window behavior.
* evaluate OpenMesh (http://www.openmesh.org) and OpenFlipper
(http://www.openflipper.org) for smoothing, decimation, and
additional GCV conversion formats.
* GCT decimation assumes no edge is shared by two triangles except
once in the reversed order (AB, BA). Needs basic check to avoid
failures/crashing.
* V&V bwcrop, pixembed are behaving correctly, as documented
* need routine that returns a color given a path, similar to
rt_comb_get_color() but full path so that inheritance is taken into
account and colors set correctly.
* implement unit tests for bu dirent / stat API
* convert src/util/terrain.c to src/shapes/terrain.c writing out the
datafile to a binunif along with a referencing dsp. perhaps add
command line option to skip .g to retain prior datafile capability.
need to review command line options to simplify complexity and
control randomization better.
* get_eyemodel returns an eye_pt entry, but feeding the results to
archer's eye_pt command results in get_eyemodel returning a different
eye_pt, even when the units are all in mm. is this expected?
intuitively, I would expected feeding the results of get_eyemodel to
eye_pt to result in no change, modulo unit conversions.
* make rt -b accept a pixel index in addition to x,y pixel coordinates
* teach pixdiff and other tools that can/should support the capability
to read/write (as appropriate) pixel index values or x,y coordinates
and reproduce the ray fired to create that pixel. currently does -l
index but not xy coordinates.
* make mged work without a batch script
* Need to rethink libbu hash API - ideally should be much simpler and
expose much less to the user.
* The current libbu mime API needs to be retired in favor of something
more powerful. It was a mistake to use enums generated from the
mime types - they are static, cannot be enriched at runtime (say,
by icv plugins) and the separation of the context from the type
itself (image/png -> BU_MIME_IMAGE and BU_MIME_IMAGE_PNG for example)
is both cumbersome and unnecessary. Instead, grab a subset of the
capabilities of libmagic (https://github.com/file/file) and define
a new libbu mime/data-typing subsystem that is runtime populated by
a default set of pseudo-libmagic style file definitions (may want
to adjust their format slightly, to require a mime type for each
entry, and we need an way to define entries where we don't (yet)
know how to inspect the file contents to identify them...)
This approach will let us define the types that are of interest to
BRL-CAD, while also letting plugins "educate" the system to support
processing of formats the base system (and the "standard" mime type
lists) know nothing about.
* investigate merging functionality from the sig tools into libicv
and removing the tools themselves. Also, need some documentation
for the sig functionality (currently none??)
* investigate updating our fnmatch code to use OpenBSD's non-recursive
implementation, added starting at revision 1.16:
http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/lib/libc/gen/fnmatch.c
* start making use of the CMakePushCheckState macros - we are doing
this manually in several places
* expand libbu parallelism with thread-level control, i.e., the
ability to start/stop/wait on individual threads in addition to the
existing bu_parallel() call. bu_parallel() gets updated to call the
new thread-level control under the hood, but allows for more
expressive threading structures (e.g., a function similar to
bu_parallel() that is non-blocking).
One consideration would be to implement something similar to Intel's
Cilk API:
+ bu_spawn() specifies that a function call to execute
asynchronously, without requiring the caller to wait for it to
return. This allows for parallelism but does not mandate it (so
code will function as expected if it does block).
+ bu_sync() specifies that all spawned calls must complete before
execution continues. This allows for synchronization of data at
different phases of a computation.
+ bu_for() specifies iterations of a loop body to be executed in
parallel. This would be a way to easily parallelize existing code
without needing to create wrapper functions for bu_parallel().
* convert usages of Tcl_InitHashTable() and friends to libbu
containers (see src/conv/enf-g.c for example usage)
* importer for LS-DYNA .k keyword files. they support a variety of
geometry constructs. their spec is freely available online. no
existing libs are known.
* implement gdiff support for reporting the amount of spatial
difference between two objects. primarily for calculating amount of
error introduced via bot, nmg, and brep nurbs format
conversion. also useful for knowing relative difference between two
versions (e.g., which is bigger).
* air regions (aircode > 0) are removed/skipped during prep, but there
is no message to the user that this has occurred. this can result
in unexpected behavior (bad usability) if/when air regions are the
only geometry being displayed (or are a substantial portion of the
current display. prep needs to return a catalog so summary
reporting can be facilitated (of all objects, successful or not).
* look into whether db_dirbuild should call db_update_nref
* evaluate replacing libfft with the KISS FFT library
(http://kissfft.sourceforge.net, BSD) or the OpenCL-based clFFT
(https://github.com/clMathLibraries/clFFT, Apache2). we need to
test correctness, precision, and performance via dfft.
May also be worth looking at https://github.com/anthonix/ffts (has a
CMakeified version at https://github.com/henrygouk/ffts)
Priit Laes converted our tools to FFTW (circa 2010, see
brlcad-devel), but FFTW is not license-compatible. there is an sf
patch containing this conversion, untested.
* import CTRI material information in fast4-g as per-face data.
* Integrate ADRT into Archer as a visualization mode.
* Document a GUI feature list (prioritized).
* Document a CLI feature list (prioritized).
* high-performance VOL for medical data visualization. consider
leveraging OpenVDB, PCL, Paraview/VTK, etc.
* establish the Basic Application Runtime (BAR), only consisting of
libbu and libbn, as a stand-alone self-contained project. provide
an API that supports most C/C++ application development and
documents our facilities that help simplify code portability,
performance, and maintainability. the scope is basic application
utility and numerics only. this scope is particularly tailored
towards 3D and scientific application development.
the basic utility routines encapsulate platform-specific constructs
portably. the basic numeric routines provide general math
facilities common to scientific application development with a
particular emphasis on being platform agnostic, high performance,
and validated.
the Apache Portable Runtime (APR) and GIMP Toolkit (GTK) are similar
alternatives (particularly to BAR's basic utility routines) but have
different emphases, scope, and development philosophies.
BAR API design aims to be minimally intrusive on application
developers, not requiring them to be aware of or adapt types or
functions until it provides some clear advantage (e.g., portability,
performance, and/or maintainability).
* rename the "joint2" articulation command (possibly also rename the
"joint" command) worked on when joint objects were implemented.
joint2 interfaces with the old text-file based articulation
interface, but conceivably should get updated when joint objects can
describe everything in the old text files.
* create a joint articulation (manually is good, automatic is better)
for the tin woodsman so he can move his arms, legs, neck, and head.
* create a joint articulation (manually is good, automatic is probably
impossible) for ktank so the turret can spin and the gun barrel may
be raised up/down within a given range.
* need ability to report the smallest feature in a given hierarchy
(smallest edge?) and/or largest error in a given boundary model
(largest edge gap or distance between two points that should be
coincident).
* geometry compiler. provides different levels of "optimization"
(ways of reducing the geometry complexity with or without
introducing 3D changes. provides different stages of compilation
(e.g., similar to preprocessing, compilation, AST reduction,
optimization, encoding transformation, etc.). name ideas: bcg, cg
* geometry debugger. low-level geometry database tool with minimal/no
run-time dependencies on our own libraries. the idea is a tool that
can inspect/repair a potentially corrupted/invalid .g file or help
debug library robustness issues. using headers for identifiers and
codes in the implementation is okay (as are library functions, but
just don't rely on any). name ideas: gdbg, dbadmin, dbtool, dbmaint
* BU_SETJUMP/BU_UNSETJUMP into macros
* convert all calls to BU_SETJUMP/BU_UNSETJUMP into familiar try/catch
logic layout using if/else.
* re-do the sh/enumerate.sh script for CMake
* get bu_extern out of bu/parse.h into its own header file.
* geometry symbolic links (hard and soft links)
* investigate INFINITY spatial partitioning issue.
* kill material_head static global in src/librt/mater.c
* add an mk_extrude() routine to libwdb.
* Teach CMake to respect and use user-defined CMAKE_C_FLAGS and
other options supplied at the command line and in environment
variables. See whether we can pass a variable into CMAKE_C_FLAGS
that will allow specification of build flags at make time.
Relevant link: https://cmake.org/Bug/view.php?id=12928
* investigate the possibility of allowing functions to define
their own custom filters for some version of the db_search API.
If we can figure out a programmatic approach of some kind, why
not allow code to define their own "filters" that don't have
a corresponding mapping to the MGED command string? As long
as the functions satisfy the API templates used by the db_plan
structures, wouldn't custom functions work?
* implement rt_volume() API for computing geometry volume (gqa style
for complex, direct for primitives)
* rework fbcolor, fbzoom, and fbpoint to not use termlib, instead just
using regular printing and input reading in a loop.
* See if it is possible to simplify btclsh/bwish code when it comes
to relying on libtermio - linenoise can do the basics, and for fancier
keybinding/word based navigation see if launching in Emacs can suffice:
;; per https://emacs.stackexchange.com/q/18672
(defun btclsh ()
(interactive)
(require 'term)
(let* ((cmd "btclsh")
(termbuf (apply 'make-term "btclsh console" cmd nil nil)))
(set-buffer termbuf)
(term-mode)
(term-line-mode)
(switch-to-buffer termbuf)))
* Need to mark or otherwise disambiguate grazing hit segments so we
can consistently retain or remove hits without introducing overlaps.
Consider the case of a tgc stacked on top of an arb8, perfectly
tangent, and shoot a ray at that point:
----- z=2.0
|tgc|
shoot a ray through here ---> -------- z=1.0 <--- or here
| arb8 |
-------- z=0.0
Here are the primary concerns:
A) solidity: a ray should never pass through the two without one or
both evaluating to a hit,
B) usability: a convention that precludes forcing the user to
"nudge" them apart by some arbitrary epsilon is desired (it's
intuitive and common for users to model two objects with "perfect
tangency"),
C) deterministic: firing a ray should give the same result every
time that same ray is fired, and,
D) bidirectional: a ray fired in one direction should evaluate to
the same result if fired from the opposite direction along the same
path (view independence).
If we hit both, an overlap will ensue unless these objects are
unioned. This is undesirable. If we miss both, slipping through
the hairline "crack", it can be devastating for analysis and result
in raytrace speckling.
In order to only hit one, a consistent grazing policy must be
applied such that grazing points on one "side" of an object are
always kept and grazing hits on the other "side" are always thrown
away. The proposed method, similar to handling special case
grazings with a Breseham line painter algorithm, is to consistently
consider grazes with a procedure:
1) Calculate the ray intersection, detect whether the hit is grazing
(defined as a hit being barely in/on the surface either through a
point, edge or even down a surface).
2) Calculate a hit normal. It may be desirable to average both the
in/out hit points to get more of a "practical" surface normal.
3) Calculate the ray of reflection. Use the surface normal and ray
of intersection to calculate our reflection direction.
4) Determine which plane of a globally bounding rpp the reflected
ray would intersect with.
5) If the reflected ray hits the front, right, or bottom face, the
grazing is kept, but if it reflects onto the back, left, or top
face, the grazing is ignored. In ray-view projected 2D, this
corresponds with keeping the grazing if the reflection is pointing
up or to the left and discarding if pointing down or to the right.
discard top/left/rear
rear keep bottom/right/front
.____________.
|\ |\ t discard
| \ | \ o ._________.
l | \ | \ p |/////////|
e | o____________o d|//view// |
f | | | | i|//of/// |
t | | | | r s|//ray/ |k
b .___|________. | i c|////+ |e
o \ | \ | g a|//// |e
t \ | \ | h r|/// |p
t \ | \| t d|// |
o \o____________o ./________.
m front keep
This should result in consistent grazing behavior that addresses the
above case: we consistently hit the tgc but not the arb8 and there
are no overlaps requiring modeler intervention. The main problem
with this approach, however, is calculating an appropriate surface
normal for edge and face grazings can be difficult for some objects.
In the case above, we do not get a hit on the tgc's bottom ellipse,
for example, instead getting two hits near the edge of the side.
Similarly, we hit the left and right arb8 faces, not the top face
even though that is what we are conceptually grazing through.
One possibility to address that difficulty is to simply report all
grazing hits, but mark them as grazing, and let rt_shootray() sort
it out by sampling a 3x3 pattern that determines if we're grazing
the "top/left" or "bottom/right" side of a surface.
* fix the redblack tree callback function signatures. they're
declared and handled as taking (void) but they actually take a
pointer and an int. need to create a proper void* data parameter or
change the interface to not require so much cast spagettery.
* decouple libwdb from librt, particularly the headers and relevant
structures that cross over to both such as the rtgeom.h types.
* Translate logic from clipper polygon clipping library
(http://www.angusj.com/delphi/clipper.php) into libbg and use it
as a pre-processing step for poly2tri's algorithm along the lines
of what bitfighter did: https://github.com/raptor/clip2tri
Some useful notes here: http://stackoverflow.com/a/16115775
* Translate the poly2tri routines into libbg C code
* Implement Shamos-Hoey test for checking whether a polygon is simple
in libbg: http://geomalgorithms.com/a09-_intersect-3.html
* figure out what in f_matpick (or possibly some other related function)
is causing ipathpos to get incremented to a number larger than the
number of objects in the full path it's supposed to be referencing.
* refactor rt_mirror (src/librt/primitives/mirror.c) into the functab
* refactor rt_functab accessors to go through an api call or calls so
that the array is not accessed directly. either an rt_eval() style
interface with data-driven keys to tell it with function(s) to call,
or simply have an rt_*() for each function (e.g., rt_mirror(),
rt_shot(), rt_describe(), etc.).
* review proc-db for promotion to src/shapes
* provide a viable FindBRLCAD.cmake
* fix nurbs_ssi and nurbs_tester unit tests
* get rid of the -P#processors user option (except rt* tools) common
on utilities. call bu_avail_cpus() and provide an environment
variable override used by the library.
* In tree.c line 531, the initialization of the local storage of the
full path in stp->st_path is conditionalized on the specifics of
the tree structure. Why? Could we get away with always initializing
(or never initializing, if it is not used) the st_path? Current
behavior is odd - if a region has a solid unioned under it the st_path
is not set, but if it has a comb unioned in the path is set - is this
an optimization, and if so is it necessary?
* investigate integrating Blender's (OSL-based) Cycles engine:
http://code.blender.org/index.php/2013/08/cycles-render-engine-released-with-permissive-license/
* investigate integrating Pixar's OpenSubdiv for subdivision surfaces:
http://graphics.pixar.com/opensubdiv/
* investigate the possibility of using Appleseed (http://appleseedhq.net/)
to perform visual image rendering using librt shotline data for input.
* the scale structure in bn_cmd_noise_slice (bn_tcl.c) was never
initialized. it looks like somebody has planned to extend the
function but never carried out
* implement a null spatial partitioning method so we can determine
what other intersection hits are being masked (and what impact a
given method has on performance)
* [hn]to[hn]* conversion functions were usurped by windows 8 so we
need to either wrap them or undeprecate our xdr API or see if a
simple config header fix might work (ideal)
* The sph wireframe drawing routine doesn't seem to like drawing very
small spheres far from the origin:
in test_2.s sph 1, 2, 1 0.0007 (draws a sphere wireframe correctly)
in test_1.s sph 10000 -15000 3000 0.0007 (incorrect wireframe)
* use spatial partitioning during boolean processing of polygonal
meshes. good approach might be to generalize TIE's kd-tree to
polygons or even create a new scheme (e.g., an integer-indexed grid
layout). data coherence would be nice (but not essential). current
approach is at least O(N^2) with large constant time. New should be
O(N*log(N)).
* rework the database object hash to push the iteration up into librt
as API instead of expecting callers to use RT_DBNHASH and
RT_DBHASH() manually. consider using bu_hash or other container.
* temp colors and temp matrices during ray tracing, rt, rtwizard.
need a command-line and mged method to override parameters.
* fix 64b detection across platforms. Fix rhel 32/64 confusion
* test/fix patch-g on windows. the input file read loops assume
unix-style files resulting in parser errors.
* merge conv-vg2g into dbupgrade
* add option to rtedge to also show back-facing hidden edges
* add option to push/xpush to stop at the region level, to stop before
primitives, to stop after N levels, to stop before N levels.
* make rt_dirbuild()+rt_dirbuild() work without vomiting error
messages about duplicate geometry. should be able to open the same
database multiple times without running into rt_uniresource
directory duplication
* convert teapot to use nurbs surfaces instead of bspline
* create a FASTGEN sample geometry with all entities defined and a
corresponding regression test to make sure outputs don't change.
* investigate bu_vls_encode/decode failures on g-dot.c (see that
file for FIXME note); add tests for both functions (note only
g-dot.c wants to use the functions at the moment)
* eliminate dbi_filepath (perhaps replace with dbi_filedir) as we
shouldn't need to search. we were told where the database was.
* check libbu implementation of red-black trees (see note in bu.h
referencing an error in the Cormen book used as a basis)
* make libfb parallel-safe. use bu memory management. remove
semaphore locks in src/rt/main.c and elsewhere.
* eliminate the need for bu_semaphore_init(). allocate up to the
index requested on demand (so we can retain O(1) lookups) and
reserve the first N semaphores for BRL-CAD library use. change
index to a uint8_t or uint16_t type.
* make libbn/plot3.c functions parallel-safe so callers do not have to
manually wrap with bu_semaphore_acquire().
* rendering of the 'part' primitive is wrong for cases where H is less
than r1 (i.e., smaller cap is partially or fully within the larger
cap's radius). It ends up rendering the larger sphere.
* update mged to not call wdb_init_obj and wdb_create_cmd, trace down
other vestiges of wdb_obj for removal
* add support to rt tools and gtools for specifying az/el in radians
or degrees, propagate throughout mged commands that take angles too.
probably best implemented as a general libbn string to val function.
perhaps an explicit 'rad' suffix and an implicit 'deg' suffix, e.g.
rt -a 0.3rad -e 0.5rad and aet 0.3rad 45deg 0
* change fbserv usage to require a flag for its non-daemon mode, make
the device type optional for both daemon and non-daemon mode
* work on vdeck/comgeom-g converters needed:
- primitives recognized by comgeom-g but not vdeck:
ehy, epa, eto, rhc, rpc
- primitives recognized by comgeom-g (but not vdeck) but
with possible equivalent versions in BRL-CAD:
haf (half), rvw (right vertical wedge), raw (arb8), wed (DoE name
for 'raw'), wir (pipe), arw (arbitrary wedge [ERIM?])
- generate new comgeom-g tests with tgms from old GIFT docs
* test tgf-g conversion with "ring-mode" geometry
* fix metaball/adjust.. wipes out all metaball values with:
adjust metaball 1 1 1
just gives usage with:
adjust metaball 1 1
* test for -msse3 requirement for __SSE.*__ definition
* improve sse run-time detection so illegal instruction crashes are
avoided. presently, adding -msse* to compilation will result in a
crash if that binary is run on non-sse hardware (e.g., Pentium M)
* add support for a zoom/viewsize and twist options to rt so you can
adjust the image without having to feed a view script.
* provide pkgIndex.tcl files for bu, bn, rt, fb, dm so we can properly
package require the libs without an explicit 'load'
* struct rt_bot_internal should be using "size_t *" instead of "int *"
for the faces and face_normals members
* fix the "(type)(size_t)val" hacks (using ints like ptrs, etc.)
* pixdiff reports bytes, but reports incorrect (off-by-one) bytes for
.bw input files. cause is due to tool assuming input is rgb triplets
(even though output is bytes, wtf?). should probably report pixels
and/or have a -b option for handling byte/bw input.
* investigate why epa primitive is so sensitive to coarse absolute
value changes (run csgbrep, tol abs=1, facetize and get 321k poly)
* implement http network transfer tool for crash reports and benchmark
analyses (via libfetch)
* reimplement benchmark suite in C/C++
* include defaults about the compiler in the benchmark suite output
including the compiler name and version at a minimum, plus hopefully
describing the CFLAGS that were used too. ideally would include all
of the versioning details (such as described from "gcc -v" if we
compiled with gcc) too.
* make bu_dirname not allocation memory. have caller pass
buffer in as a parameter with size ala snprintf/memcpy.
* make mged not have a garbled display manager window if the
framebuffer is enabled and the window is resized. initialize and
refresh the new memory and zap the framebuffer.
* make the right-hand path to oed optional
* deprecate dbcp and merge functionality (and improved
double-buffering) with the buffer tool.
* vls name wrapping (reversible argv-to-vls, vls-to-argv). look at
src/libged/glob.c code, very similar.
* update g-xxx_facets to use libgcv
* bu_cv_optimize() should be using bu_byteorder().
* render annotated images to the OpenDocument format. this is
particularly useful for rtedge-style renderings with object
annotations where we can leverage layout components and scalable
vector graphics.
* investigate OpenEXR (BSD licensed HDE image format)
* usage statistics. similar to the eclipse Usage Data Collector, keep
track of which BRL-CAD command-line commands and MGED/libged
commands are run. Give the user the option of uploading those
statistics (now, always, later, off). Provide terms of use
explaining the ways that their data will be used and shared.
aggregate, this can help us focus development resources towards
improving workflows, documentation, robustness, and new development
areas.
* automatic anti-aliasing as a second render pass on the edges
encountered (possibly using bilinear filtering scheme, improve upon
rtedge's current simple filter)
* make loadview still load the view if the database doesn't match the