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
-------------------------------------------------

* ALL CLEAR!


THESE TASKS SHOULD HAPPEN WITHIN TWO RELEASE ITERATIONS
-------------------------------------------------------

* explore the g_qa/plot issue

* release dm X get_color() memory

* vls name wrapping (reversible argv-to-vls, vls-to-argv).  look at
  src/libged/glob.c code, very similar.

* 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).


THESE ARE UNSCHEDULED BACKLOG TASKS
-----------------------------------

* the 'cp' command no longer draws the object that was copied --
  undoubtedly a libged change -- so restore previous functionality.
  as that behavior was not intentional and is undesirable for large
  objects, have some means to determine that something is "large and
  complex" or at a minimum, provide an option to not draw on copy.

* rt/rtedge command-line options for overriding object colors

* rtwizard enhancement to allow color overrides to be specified for
  selected objects.

* plate mode NURBS/BREP objects.  Similar, if not identical, to plate
  mode BoTs, 'brep' objects need the ability to have a thickness
  described so you could automatically handle non-solid NURBS and
  sheet-metal style geometry without requiring surface solidity.

* fix archer/libdm labels/axes to not use pointer printing

* annotation primitive.  specifically a means to create an object in
  the database that can optionally be associated with an object and/or
  location that a label refers to.  there are various styles such as
  a single line from a point to text and two lines (e.g., indicating
  measurement) to text.  the object should allow for different line
  styles including having no lines.  there should also be support for
  view-fixed or view-independent annotation placement (which requires
  a change to plot()'s and possibly prep()'s signature).  it would
  also be useful to allow an optional "thickness" so that the
  annotations can represent physical geometry (so they raytrace).

* investigate tessellation failures (Stryker, et al), possibily due to
  recent tolerance checks.

* add support for a custom unit conversion factor to the units command
  (e.g. 'units 9.3120223' or 'units metertons 9.3120223')

* fix forum links to point to the sourceforge forums, not the nabble
  forums

* write up a brief DSP overview on the wiki

* merge conv-vg2g into dbupgrade

* 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.

* update the msvc build to not use installTree.tcl -- the build
  shouldn't really be reliant upon tclsh or be all contained within
  the tclsh project.  sub-projects should build and install by
  themselves (e.g. tkhtml3 should generate its htmltokens.h file).
  the "brlcad" project, if any, can build up the installation tree and
  generate the final installation exe.

* implement namespacing for attributes as a means to group attributes
  together.  this can predominantly be a naming convention, but
  requires awareness in the attribute-searching routines to search
  without the namespace unless one is specified, and to reserve :: in
  attribute names unless they're quoted.

* clean up default attributes to be consistent and upgrade old
  attributes to their new names.  includes likes of region, region_id,
  material_id, air, los, rgb, oshader, and inherit.  see
  doc/docbook/system/man5/en/attributes.xml for more detailed listing.

* automatic anti-aliasing as a second render pass on the edges
  encountered (possibly using bilinear filtering scheme, improve upon
  rtedge's current simple filter)

* kdtree spatial partitioning option in librt

* implement rt_volume() API for computing geometry volume (g_qa style
  for complex, direct for primitives)

* implement parallel prep

* improve compile-time version management -- port brlcad-version to
  windows, reconsider providing compile-time header constants.

* fix gqa spewing of massive amounts of plot data with th -Av -v
  options:
  ../src/gtools/g_qa -u m,m^3,kg -g 0.25m-0.5mm -p -Av -v gqa.g closed_box.r
  -rw-rw-r--  1 morrison users 41572569618 Apr 23 15:14 volume.pl

* replace SCLstring with std::string

* all of the rt* tracers share common code and common options, but do
  not share common documentation.  refactor documentation to use
  include directives so that there is one place where all of the
  common options are documented.  update usage statements to reflect
  commonality as well.

* document the saveview/loadview options.  migrate them to libged if
  they're not already.

* improve rtedge documentation, explain how it computes its "centroid"
  (as it's not exactly the center of bounding box of all objects -- it
  depends on the booleans).

* add a force option to the tracers to support overwriting the current
  output file (so long as we're going to make it read-only by default).

* improve min/max bounding box routines for BREP/NURBS

* convert non-planar arb's to brep objects for ray-tracing.  see how
  well it works to see if we can remove an arb limitation.

* the 'l' and 'analyze' commands now require an object be specified
  and won't use the currently highlighted solid.  undoubtedly related
  to libged refactoring.  this is related to sf request 2954409.

* alias objects.  this is an object handle in a geometry database that
  refers to another geometry database object.  in effect, it
  encapsulates the idea of a symbolic reference for database objects.

  alias objects should be very lightweight, corresponding to basically
  a simple named reference to another object.  this allows for
  geometry objects to have multiple names, all referencing a given
  primary name.  whenever an alias is referenced, it returns the
  object pointed to instead of the alias object itself (this includes
  the rt_db_internal()).  this prevents the creation of cyclic
  references.

  this directly supports geometry importers that contain object name
  mappings (e.g., part numbers to engineering names) as well as
  simply supporting multiple names per object that one might want to
  persist.  there is an issue of whether aliases show as top-level
  objects or even display by default without a listing option.

* a "batch" command for libged to apply a given command template to
  all lines in a given input text file.  could be very similar to exec
  but instead of inspecting the current .g, it walks lines in file(s).
  this would let you do things like:

  # same as mvall -f file.txt
  batch file.txt -exec "mvall \$*"
  
  # create an alternate hierarchy based on some mapping file
  batch file.txt -exec "g \$*"

  # for all lines in 3 files, kill first symbol, rename second to it
  batch A.txt B.txt C.txt -exec "kill \$1" -exec "mv \$2 \$1"

  # keep all objects in an edcodes file with region ID > 1000
  batch A.txt -field 2 -ne 1000 -exec "keep subset.g \$5"

  # for all regions, if they are listed in file.txt, add them to a
  # parent assembly and set a specified material ID
  search . -name "*.r" -exec batch file.txt -field 1 -eq {} -exec "g \$1 {}" -exec "mater {} \$3" \;

  # run awk, get 4th column, run sed to change name, 
  batch file.txt -awk '{print $4}' -sed 's/^r\.(.*)/\1\.r/g' -exec "mv \$1 \$$"

  # outside of MGED, the above would have been similar to:
  cat file.txt | awk '{print $4}' | sed 's/^r\.(.*)/r\.\1 \1\.r/g' | xargs mged test.g mv

  The command becomes more of a stream processor on the input file, as
  if piped on the shell line.  To embed awk, sed, cut, see qse:
          http://code.google.com/p/qse/

  The search and batch commands probably can't nor shouldn't use the
  same replacement markers, with batch using $*, $1, $2, etc, to
  represent file columns (in a poor man's awk fashion) and search
  simply using "{}" as the the object name replacement marker.

* fix !!! in src/libged/tables.c where a temporary file is getting
  used.  needs to call bu_temp_file().

* make the 'tree' command accept a full path, not just a combination

* clean up new rt -l8 heat graph lighting model so that it works in
  parallel and with no "splotches"

* make rt_prep_timer() take or return a context that gets subsequently
  passed to rt_get_timer() calls for returning the elapsed time.  this
  will allow multiple overlapping timers instead of just one global
  timers.  move the timing facilities to libbu as part of the process
  so API can be obsoleted cleanly.

* separation of stderr from stdout within libbu, particularly for
  MGED, so that there is a clean separation of result output from
  diagnostic output.  this is a fairly separate idea from having log
  levels (ala syslog) but is somewhat related to the concept of having
  definable output streams.  idea in mind is to have a bu facility to
  obtain a bu_log()-style callback function returned from a
  logger registration function.

* finish obj-g importer.  need to test more inputs and make sure all
  geometry is preserved on import in some form.

* fix metaball "shelling" but that causes the primitive to invert and
  just give paper thin surface (something wrong in the intersection).

* deprecate dbfind - ensure functionality is fully captured by the
  search command, make it report a deprecation statement on use and
  utilize search under the hood.

* investigate impact of using lookup tables for root solving.
  implement lookup tables for a range of linear, quadratic, cubic, and
  quartic polynomial coefficients.  compare performance to root
  solving without lookups.  evaluate memory use.  non-imaginary roots
  are relatively sparse, may need to consider linked lists, hash
  tables, or some hybrid storage arrangement.  Idea inspired by:
  http://math.ucr.edu/home/baez/roots/

* make the 'tables' ged command not call system() on the "sort" unix
  command.  It should perform all sorting on the data directly in
  memory, at least without creating another process.

* make libwdb routines not free user-allocated memory.  notably
  mk_nmg() and mk_sketch() but probably others as well.

* libbn's tri_specific structure requires user-provided memory for
  normals.. this certainly saves memory if the triangles don't have
  normals but at a rather expensive malloc cost (which is being seen
  on large BoT models) during prep.

* need a simplified means to programmatically create and edit BoT
  meshes via the command line without resorting to get/put.

* make fbclear and raytrace control panel obey a -F advanced option,
  i.e., better remote framebuffer support.

* MINOR: rename bu_ptbl(), nmg_struct_counts()
  (c++ portability, hides struct constructor)

* MINOR: add tolerance parameters to the bn_*() functions that have
  near-zero tests.

* verify/improve kicking off an EDITOR in mged so that we don't lock
  up mged in vim/emacs/jove/whatever without a controlling terminal,
  without breaking the ability to set a GUI editor like TextEdit,
  Wordpad, etc.

* Simple GUI for repairing BoT normals.  Basically make it easier to
  make all normals consistent and outward facing through some form of
  MGED integration of bot_sync and bot_flip.

* Machine-independent dbupgrade.  Make it so that dbupgrade will work
  on an old v4 without being on a machine of the same original
  architecture type.

* complete conversion of existing manual pages into docbook format

* expose all manual page documentation from within mged through
  searchable viewer interface (GUI)

* add an option to bot_dump for outputting surface normals.  Make sure
  all supported dump formats (obj, dxf, etc) optionally write out
  normals.  Consider adding an option to smoothly interpolate normals
  (per face or vertex).

* add option to push/xpush to stop at the region level.

* consolidate push/xpush together

* verify/fix/improve rtarea.  There are reports that the rtarea
  command may have a bug in its calculations.  This needs to be
  investigated along with a review of the taxonomy used by rtarea for
  describing presented/projected areas.

* obliterate verbose compilation warnings

* modify g_qa to search for >1 region flag in a tree path.

* the binary windows installer is missing headers for our external
  dependencies (Tcl, zlib, and OpenNURBS in particular as the likes of
  bu.h and raytrace.h requires them)

* make rtarea display a cross-hair and perhaps coordinates for the
  center of area if run from within mged.

* optimization of NMG ray tracing.  the hitmiss bookkeeping presently
  used has a malloc/free occuring per shot().  allocations need to
  occur during prep only.  the presently render more than an order of
  magnitude slower than tracing that nmg converted to an equivalent
  BoT due to malloc/free calls being made during shot(). Confirmable
  with a simple test case of a sphere converted to an nmg:

    make sph sph ; facetize -n sph.nmg sph

* implement a "select" command in LIBGED that creates a selection set
  based on specified sampling parameters or object lists.  example
  could be "select -point 12.3 23.1 31.2 -dist 100.0" to
  select objects within a given distance of a point; "select foo bar"
  to select specific objects and create/return a temporary reference
  name. this provides a command-line mechanism for implementing band
  selection in the GUI, area-based selections, and object highlighting
        - can replace unpublished 'sphgroup' command with this

* make gqa overlap reporting suck less.  uselessly reports the same
  objects multiple times instead of keeping track of uniquely
  overlapping pairs of objects (rtcheck used to have this problem but
  not now).  also reports overlaps even when not requested (e.g. -Aa)

* refactor the libtclcad go_*() functions and invocation wrappers
  (also in mged) into libged where appropriate. the 'png' command
  comes to mind.

* refactor and manage libbn tolerance uses by providing an interface
  default (e.g., an init macro) and making everyone use that where it
  is hardcoded to 0.0005 presently (and a few places where it's
  inconsistently/incorrectly 0.005).

* add a default phong 'metal' shader.  annoying to keep making plastic
  more reflective or mirror less reflective when it's such a common
  material appearance to want.

* implement a new tool/command that reports summary information about
  a geometry file including number of objects, types of objects,
  classes of geometry representation types used, and potentially more.

* consider adding an option to reid/remat and edcodes (and others?) to
  ignore negative regions (regions subtracted from regions or
  intersected with them) since, while bad practice, are valid
  geometrically.

* implement some sort of archive/backup command in mged in order to
  save the currently open database out to a file.

* make sure there are no getenv() non-NULL assumptions within the
  code.  might want to see if there's a pattern of variables being
  checked such that a libbu interface would be warranted (e.g.,
  instead of checking HOME, having a bu_find_directory(BU_USER_HOME)
  routine or similar facility) for finding common resource locations.

* add support for a zoom/viewsize option to rt so you can adjust the
  image scale without having to feed a view script.

* make db_open modes behave the same as the fopen() modes (i.e.,
  create the .g if one doesn't exist when write mode)

* fix the shaders.sh regression test case, failing dues to changes
  with mged's view initialization.

* inside support for ARS

* add support to 'rtxray' for outputting inverted pixel values so that
  we have pixel values that are directly related to material thickness

* g_qa (gqa in mged) needs to be more informative when it runs - 
  needs a header letting you know what it's doing, and if possible
  a "progress report" for longer runs that provides some notion of
  how much of the total job is done.

* make color and vectors on pnts work

* mged inconsistently ignores signals.  initially allowing mged to be
  backgrounded, but then later ignores them.  needs to consistently
  ignore or not ignore them, ideally the latter.

* libfb needs to have the fb_open/close_existing functions refactored
  into the function table and hav the #ifdef sections removed.

* integrate library tester into regression suite that validates
  exported library symbols published in headers.  make sure they at
  least exist and maybe even try to ensure they will run with null
  arguments without crashing.

* 3D plot objects for v5 geometry files.  very closely related to
  other ideas about having 3d wireframe objects, but these would
  probably be non-geometric in nature.  basically the plot3 files that
  are stored out to disk being stored as objects in the database with
  support for the overlay command to import, export, display them.

  minimally should probably support the basic drafting elements
  (predominantly from collada, dxf, iges, and step specifications):

        point := x, y, z
        line := start point, end point
        polyline := various (closed, open, paired, modified, etc)
        circle := center point, radius
        ellipse := center point, major radius, minor radius
        hyperbola := center point, major radius, minor radius
        parabola := center point, focal length
        arc := center point, radius, start angle, end angle
        spline := degree, control points, knot values
        text := string, insertion point, size, style, alignment

* make _plot() callbacks fill in plot objects instead of returning
  line segments.

* image objects (tbd objects) for v5 geometry files

* material objects (non-geometric attribute-only objects) for v5
  geometry files.  instead of material attribute value becomes
  material object name.  material object encompasses hierarchical
  material traits.

* shader objects (non-geometric attribute-only objects) for v5
  geometry files.  allow shader string to refer to said objects for
  shader parameters.

* refactor wdb_obj and view_obj in libged.  with the de-tcl'ing of the
  base libs, it should disappear but shouldn't have wdb_*() funcs in
  libged regardless.  work in progress.

* make our C headers C++-convenient with proper extern "C" wrapping.

* reorganize the header files in include so it is clear which headers
  pertain to which libraries.

* break up library headers into subheaders so includes can be more
  specific (and help speed up compilation) and locally documented.

* implement a routine/command to convert from a bot to an nmg
  (similar/related to the nmg-bot tool, but the reverse).

* implement a jitter-style option to rt that makes it average the ray
  results to take a weighted light contribution for a given
  resolution.  saves more memory over rendering at 2x/4x/8x/whatever
  with or without jitter and then scaling down.  present jitter option
  doesn't average.

* refactor mged/bwish/g_diff initialization to all use the same routine

* rename all the g_* tools sans _ next minor update

* deprecate either orot or rotobj

* refactor mged's signal handling to make it possible to safely
  interrtupt long-running commands

* add a -color option to all mged commands that draw geometry (B, eid,
  and E come to mind)

* have mged record a timestamped command history by default

* implement -exec support for 'search' command

* implement -param support for 'search' command

* make ged command names aware of object arguments for automatic
  globbing and regular expression expansion:
	attr set t 1 [regex .*\.r]
	attr set t 1 [glob *.r]
	attr set t 1 *.r

* mged crashes on Mac if using system Tcl/Tk with our incrTcl.
  crashes with the following stack (same whether dm-X or dm-ogl):
	XQueryExtension
	...
	glxGetConfig
	ogl_choose_visual (dm-ogl.c:1359)
	ogl_open (dm-ogl.c:401)
	dm_open (dm-generic:82)

* review adding support for infix and postfix CSG operators for
  libged/mged.  be sure to revive or at least check out the previous
  effort in src/mged/comb_bool_parse.y that already has support that
  recognizes the classical infix notation.

* 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 

* VRML importer

* make Mac OS X universal binaries actually work.

* implement analyze for all primitives lacking an implementation

* implement general analyze estimate (perhaps just raytrace it) for
  primitives where values like surface area are very difficult to
  calculate.

* move analyze logic into librt (with their respective primitives).

* fix analyze output formatting, columns are pooched.

* extend analyze output formatting to user-specified formats ala nirt

* implement tessellation support for the new BREP primitive.

* implement make, ted, edsol, mirror, and analyze for revolve
  primitive.  implement tess() too.

* fix/change naming convention for presented/exposed area

* re-enable RISE client in ADRT

* test homovulgaris' root solver patch that puts coefficients in the
  right order

* review librt polynomial root solver (cubic and quadratic case)

* give bot-bldxf the axe (reconcile and merge with bot_dump)

* refactor all of the nmg processing (back) into its own library so
  that external users can manage mesh geometry without needing to pull
  in everything else in librt

* implement support for exporting sketch objects via g-iges

* implement mged object name globbing similar to tclsh's globbing
  (i.e. via a globbing command and quoting globs that use []).  testing
  shows db_glob doesn't seem to behave correctly, at least not like
  glob.  hook globbing into all commands so glob_compat_mode
  statefulness can go away.  a db_glob expression that doesn't match
  anything should not return the expression.

* Explore possibility of "level of detail" wireframe renderings,
  possibly using the previous "smooth" wireframe work as a start,
  to provide better visualization of models.

* come up with a new tool that automatically generates "inside"
  regions for a given model as a way to automatically model air.
  particularly useful for bot models where the inside air compartment
  is predominantly (but not entirely) a complex bot structure in
  itself.  idea is to use some sort of marching cubes/tets to find
  those volumes, perhaps use a libified g_qa.

* extend metaball control info beyond simple points (e.g., line
  segments)

* address the TODO items in src/mged/clone.c

* investigate why solids.sh fails on three pixels on some 64-bit
  platforms. it grazingly hits/misses a tgc causing a regression
  failure.

* develop a low-level tool for investigating, reporting statistics on,
  and repairing geometry database files.  the tool should nominally
  perform big/little endian conversions, report number and types of
  objects, allow deletion/undeletion/hiding/unhiding, provide some
  general means to manipulate the packed and unpacked .g file data for
  performing low-level modifications

* fix the "(type)(size_t)val" hacks (using ints like ptrs, etc)

* fix rt parallel crash
  (true ; while [ $? -eq 0 ] ; do rt -o /dev/null moss.g all.g ; done)

* fix parallel crash report generation (multiple BU_MAPPED_FILE's
  getting acquired)

* make closing both the command window and graphics window shut down
  mged (i.e., fix unintentional behavior)

* remove hit_normal and hit_point from struct hit.  add RT_HIT_POINT
  macro.  refactor all callers as needed.

* make bombardier actually send the report somewhere

* hook bombardier in for crash reporting

* windows smp support

* modify the new tree traversal code to be generic

* add high dynamic range image support to the framebuffers

* add alpha channel support to the framebuffers

* remote framebuffer timeout support (perhaps as ::key=val;key=val)

* develop a tool that applies a text overlay to a given rendered image
  (e.g., as an rt option) for things like adding an image title, the
  az/el, and objects displayed.

* bezier extrusions need to be optimized, really should not be
  performing dynamic memory allocation in the root solver

* better/consistent argument processing supporting both long and short
  option names, perhaps using argtable

* decouple libdm from librt -- just one file in libdm uses librt,
  including a whole nasty primitive switch statement.  need to push
  that back over into librt.

* Implement an optical shader for the new "pixelated" military
  camouflage style

* preserve an arb8 as an arb8 (instead of writing as arb6 or arb5) and
  similarly for the other arb# sizes

* validate primitives during export so that it is guaranteed that
  illegal primitives will not be written to file

* implement a region annointment command where the user can turn an
  assembly into a region and change all lower or higher regions into
  combinations

* enhance dxf-g to create more than just one combination per layer,
  creating multiple objects for the individual objects in the dxf file
  (instead of one conglomerate BoT)

* add an overlap depth reporting tolerance parameter to the
  ray-tracers (similar to -R).

* Generate plain .zip files for Windows binary releases

* fix the variety of ami.tcl and ampi.tcl tclscript warnings/errors

* run indent.sh on directories (one at a time, validating results)

* add support for arbitrary matrix transformations to torus primitive.
  store non-uniform scaling matrices as an attribute for
  backwards-compatible support until v6.

* configure support to enable/disable framebuffers, display
  managers, geometry converters, and image converters.  consider
  apache's module management as an example.

* review and merge in the rest of the GSI modifications

* make target and/or script to update ChangeLog and version
  information, possibly including checking for consistency, to
  facilitate release process.

* display the current mode in mged graphics window

* Optional compile-time support for using GMP or CLN for arbitrary
  exact precision arithmetic computation support

* inside/outside point and voxel testing capability in librt

* automatic geometry voxelizer (perhaps using arbs or vol primitive)

* turn geometry converters and image converters into libraries
  (started as libraries libgcv and libicv)

* add support for querying geometry properties to library including
  computing surface area and weight/mass.

* add verification and validation tests confirming behavior of the
  ray-tracer and computations of area, mass, volume, etc

* testing suite for all binaries: for cmd2 in $(for cmd in `find . -name Makefile.am | xargs cat | perl -pi -e 's/\\\\\n//g'| grep -E "PROGRAMS ?=" | sed 's/.*=//g'` ; do echo $cmd ; done | sort | uniq ) ; do echo command: $cmd2 ; done

* add geometry example of building 238

* Mac OS X SGI dial knobs support

* ability to "unpush" objects, translating them to a new position and
  applying the correct matrix (using either bounding box or center of
  mass, for example).  would be useful to optionally allow the
  creation of a parent combination that contains the unpushed matrix
  so you could return primitives to local coordinates.  See sf feature
  request 2826720 from cericole.

* ensure successful build on mingw

* test for USE_FORKED_THREADS in configure

* optimize CSG structures automatically: automatic simplification,
  tree contraction, null object detection.

* option to mged make command or new command that enters solid edit
  mode, "med", "smake", "makes", "msed", etc.  same for cp command.

* have libbu report memory allocation statistics so the exact amount
  of memory requirements for a geometry database can be computed on
  the fly via a pre-prep phase.

* support to the raytracers for multiple image file formats,
  recognizing an option and/or the file suffix of the -o filename.

* libfb + font rendering (perhaps through libbn's plot interface) for
  a posix terminal.

* gpgpu for enhanced performance boolweave sorting

* getexecname, "/proc/self/cmdline", program_invocation_short_name.
  separate out into new file.

* geometry viewing commands/visualizations of exploded levels

* librt-based path tracer

* system identifier application with sysctl-style information
  database, with some back-end functionality placed into libbu.

* add callback data parameters to libpkg hook functions

* add performance options for the intel compiler on Altix

* investigate performance impact of using sched_setaffinity and/or
  pthread_attr_setaffinity_np for linux threading affinity in librt.

* rtedge-style tracer that outputs tool paths (splines/segments, etc)
  for CNC/CAM style toolpath cutting descriptions (g-code files).

* rtedge shoots twice as many rays as it needs to (shoots the 'below'
  ray for each primary, only reusing current scanline cells.

* support for fillets and chamfers as object/combination operations

* make the DSP primitive use less memory when data is coming from
  a binunif. allocating 160 times binunif size is a bit extravagant
  (which comes from sizeof(struct dsp_bb)).

* add dynamic geometry support. i.e. the ability to modify the parsed
  in-memory geometry tree on the fly via api calls (e.g. to add holes)

* investigate why g-iges followed by iges-g on a single box results in
  permuted vertex lists

* add xml, nff, bzw, pov, blend geometry import and export support

* add support for filesystem-based geometry collections

* modify the raytracers to use common fb and file output code

* add missing manual pages (jra generated list on 04.2007):
	a-d archer asc2g asc2pix bot-bldxf bottest brep_cube brep_simple brickwall btclsh burst bw-a bw-d bwish c-d chan_add clutter contours d-a damdf dauto dauto2 d-bw dconv ddisp d-f dfft d-i dmod double-asc dpeak dsel dsp_add dstat d-u dwin euclid_format euclid_unformat fbgammamod f-d fence fhor f-i g-adrt g-euclid1 g-jack globe g-off i-a i-d i-f ihist imod istat jack-g kurt lowp molecule nmgmodel nmg-sgp off-g pipe pipetest pix2g pix3filter pixcount pixelswap pixembed pixfields pixfieldsep pixflip-fb pixpaste pix-spm pix-yuv plstat pyramid rawbot remapid rlesortmap rletovcr room rtcell rtexample rtfrac rtrad rtsil rtsrv script-tab sketch solshoot sphflake spltest spm-fb ssampview syn tea tea_nmg testfree texturescale torii ttcp tube txyz-pl u-a u-bw u-d u-f umod ustat vcrtorle vegitation wall wdb_example xbmtorle xyz-pl yuv-pix

* design plugin system to allow domain specific tools (say, for example,
  a tool to create propeller parts) to identify themselves and their
  features to BRL-CAD, and to allow BRL-CAD to incorporate those features
  as an integrated part of interaction environments.  

* SVG renderer.  go straight from 3D model to a 2D vector image for a
  given view.  similar to the plot/postscript wireframe view saves,
  this would need to store projected contours (ala rtedge) and filled
  color regions.

* see if it is possible to use tec/ehy primitives to create a proc-db
  for airfoil/wing shapes.  Interesting possibilities with boolean combinations
  of these primitives, provided their continuity at the ends ensures
  continuity all along "seams" - something to consider.

* implement a g-gcode exporter.  ideally this converts geometry to
  NURBS format, trims surfaces, evaluates boolean expressions, and
  then generates tool paths on resulting surfaces and interior paths.


RTGL ITEMS
__________

Need before enabling:

Blasting havoc_tail when raytracing havoc doesn't result in a re-set
of the raytracing - it just re-sizes the view to havoc_tail and continues
with the original raytrace.  Track down why - should clear everything
and start over.  (Appears on Linux, not on OSX).

Need general robustness testing - ensure no crashes when switching
display manager types multiple times in multiple locations.

For cleanup:

Move pattern raytracing logic into librt.

Need a way to cache point data so we don't re-raytrace unchanged geometry
over and over.

Job server should be reworked into a general mechanism, instead of being
rtgl specific.

Provide a generic mechanism in MGED run loop to hook in features like
point cloud rendering, instead of hard-coding it.


LIBPC
-----

* BNF Parser for generation of constraint objects from expressions

* Make better pc_pc_set, pc_param and pc_constraint structures
instead of the current ugly ones.

* Test constraint solution via Read->Generate->Solve->Update routine 

* Implement Non-deterministic solution techniques:  Backjumping,
Backmarking

* Implement Deterministic propagators: NC, AC1-7, PC1-5

* Check STL structures in public API ; wrapping with bu_list

* Boost constrained_value based functor integration for 'compiled' 
constraints

* Implement Hypergraph representation system

* Explore analytic and symbolic solution system


ODDITIES
--------

* 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


THESE BREAK PROTOCOL OR ARE BACKWARDS-INCOMPATIBLE
--------------------------------------------------

* support for features either as primitives or operations or both
  e.g. chamfer, fillet, round, cut, etc

* a cut feature edit.  implementation could be represented as the cube
  that bounds a geometry object.  eight points somewhere on the edges
  of the cube define an intersection volume on the object.  by
  default, the eight points could be positioned at the corners of the
  cube and would remain constrained to reside on one of the three
  adjoining edges for their respective corner.  this would provide a
  simple user interface where a face could be selected to move a cut
  plane through an object (moving four points along four edges), or an
  edge could be moved to move two points simultaneously, or each
  individual point could be moved along their edges to define the
  intersection object.  allowing the points to be deconstrained so
  they can move into the interior of the bounding volume or into the
  interior of a face could be an advanced option.

* fix the database I/O writing to properly support the addition of new
  primitive types.  this includes modifying the major/minor code or
  combinations/regions and binary objects

* add database support for constraints, expressions, parametric
  values, construction history, and timestamping.

* see doc/deprecation.txt for items that have been marked as
  deprecated or available to be removed as obsolete items.

* make struct rt_functab's ft_label bigger and/or dynamic (e.g. vls)

* remove the storage of the never-implemented keypoint parameter for
  extrude objects.

* have all primitives record a transformation matrix so that they may
  retain a local coordinate system even after pushed matrices.  this
  also will allow primitives like the torus to support non-uniform
  scaling.

* rename 'part' primitive to 'pill' or remove it entirely in favor of
  a more generalized metaprimitive primitive.

* binary objects need to write out their minor type during export, not
  relying on the raw wrapper to encode it, so that proper
  import/export can be performed without relying on minor_type hacks
  in the API.

* implement support for binary attributes.  the idea is to allow
  arrays of {u,s}int{8,16,32,64}, float, double, and strings, typed as
  such when written out to storage.  this idea overlaps with what
  binunif objects provide, so need to reconcile and consolidate into
  one attribute object entity that can do everything a binunif can do,
  then allow attributes on objects to provide that same flexibility.


FUNCTIONALITY NEEDED TO SPEED UP RAYTRACING
-------------------------------------------

* merge shot and vshot

* implement bundles shot - array of rays

* separate ray structs - make fit in cache line

* refactor primitive data -  make fit in cache line

* implement SIMD shots

* implement SAH for all primitives (routine that fires a ray at each primitive for initial estimate, caches result)

* write and use kdtree - make traversal cache coherent


DOCUMENTATION
-------------

* BRL-CAD Overview Diagram
	Completed, but not integrated

* BRL-CAD Industry Diagram
	Completed, but not integrated

* BRL-CAD Commands Quick Reference
	Partial

* MGED Quick Reference
	Completed, but not integrated

* MGED Interface Reference
	Keybindings, GUI elements, scripting

* Introduction to BRL-CAD Tutorial
	mged, rt, pix-png, rtcheck, rtarea, rtweight, g_qa, fbserv, nirt.  Succint overview of less than 10% of the core functionality in 10 pages or less (plus pictures).

* Technical Overview of BRL-CAD
        Describes everything in the package succinctly yet comprehensively.  Survey of all the major features, methodologies, and tools implemented in BRL-CAD with coverage on code maturity, library encapsulation, and tool aggregation.

* BRL-CAD Validation and Verification
        Overview of how contributions to BRL-CAD are reviewed and tested including regression, performance, and system integration testing as well as independent ARL configuration review.  This specifically addresses the issue of world-wide and potentially anonymous contributions to BRL-CAD and how those changes are managed.

* DoD V/L M&S Industry Diagram
	Similar to existing Industry Diagram.  Survey of all the major features, methodologies, and tools implemented in BRL-CAD with coverage on code maturity, library encapsulation, and tool aggregation.  This one is a particularly useful marketing and educational visual aid for describing how the various M&S codes interoperate in terms of features and scope.

* Commercial CAD Comparison Diagram
        Comparison of how BRL-CAD overlaps feature-wise with various major commercial CAD systems.

* Solid Geometry Representation Comparisons
        Describe the implications, tradeoffs, and conversion issues involved when converting between different geometry representations.  Includes describing implicit geometry, explicit polygonal boundary representations, explicit spline surface representations, volumetric models, wireframes, boolean operations, feature edit operations, and parametric modeling.

* BRL-CAD Primitives
        An overview of the various primitive object types in BRL-CAD, their range of features, and a description of their input parameters.

* BRL-CAD Ray Tracing Shaders
        An overview of the various shaders and shader options available in BRL-CAD.

* BRL-CAD Open Source
	An overview of how BRL-CAD is organized as an open source project and community describing the developer meritocracy, code reviews, development prioritization, and change management.  This introduces and explains the concept and philosophy of open source software, it's fundamental tenants, and the basic "why and how" it works.

* History of BRL-CAD
        Covers the 30-years development history of BRL-CAD, from 1979 to 2009, documenting the origins of the project, major development achievements, the conversion to open source, and lesson's learned.

* BRL-CAD Manifesto
	Vision & Scope

* BRL-CAD Taxonomy
        Description of the common terminology used throughout BRL-CAD, conventions employed, and tool categorization.

* Implementing a BRL-CAD Primitive
        How-To for creating a new primitive in BRL-CAD that can be ray-traced, tessellated, plotted, and transformed seamlessly.

* Procedural Geometry in BRL-CAD
        How-To for creating new tools that create geometry.

* BRL-CAD Ray Tracing Shader Development
        How-To for creating new shaders.

* Geometry Conversion with BRL-CAD
        Overview of the various geometry conversion facilities in BRL-CAD and how they related to solid geometry representations.

* A Developer's Introduction to BRL-CAD
        An overview of BRL-CAD from a developer perspective intended for new developers.  Provides overview of structure, important sections, operating procedures, and answers to FAQ development questions.

---
See the feature request and bug trackers for more tasks and future
planning efforts: https://sourceforge.net/tracker/?group_id=105292

TODO items should be formatted to column 70 (M-q in emacs), no tabs.
