This is a list of succinct tasks that are expected to take most people less than two hours to complete. It's a great starting point for anyone interested in contributing to BRL-CAD.

The tasks are all roughly the same complexity with no prior BRL-CAD experience expected. A description is provided along with a list of references and files you'll probably need to edit. Can we make it any easier?

Getting Started

Please do contact us (via IRC or brlcad-devel mailing list) if you have any questions, corrections, comments, or ideas of your own that you'd like to suggest.

We've made a really awesome virtual disk image that has everything you need included, preconfigured, and ready to be edited. Here's what you do:

Download our BRL-CAD Virtual Machine (VM) image.
Download, install, and run VirtualBox.
Import the BRL-CAD VM, start it, and log in (the password is "Brlcad!" without the quotes).
Run "svn up brlcad.svn" and get started compiling!

When You're Done

For non-code, just send us your file(s). For code changes, you will be expected to provide a patch file. Make sure you read your patch file before submitting it. Make sure your patch file will apply cleanly to an unmodified checkout of BRL-CAD:

svn co https://brlcad.svn.sourceforge.net/svnroot/brlcad/brlcad/trunk brlcad.edit
cd brlcad.edit
# make changes
svn diff > ~/my.patch
# read ~/my.patch file with text editor
cd ..
svn co https://brlcad.svn.sourceforge.net/svnroot/brlcad/brlcad/trunk brlcad.fresh
cd brlcad.fresh
patch -p0 < ~/my.patch
# submit your patch file to our patches tracker

Code

Tasks related to writing or refactoring code

See the When You're Done section above for details on submitting your changes.

Implement runtime detection of SSE

BRL-CAD will optionally leverage SSE instructions for some operations but SSE-support is set at compile-time. If you attempt to perform SSE instructions on non-SSE hardware, it'll basically halt the application with an illegal instruction exception. That's a fancy way of saying it crashes.

This task involves implementing a function (that will go into our LIBBU utility library) to reports whether SSE support is available at runtime. The most prevalent method for doing this is demonstrated by the Mesa folks where you set up an exception handler for SIGILL and attempt an SSE instruction. That's obviously a non-solution for Windows platforms, but is better than nothing and more useful than a Windows-only solution. Even better if you can handle both or implement a cross-platform solution. You'll implement a bu_sse_init() function that returns an error if SSE is not available at runtime.

Code:

include/bu.h
src/libbu/sse.c

Fix bounding box function for our polygonal mesh (BoT) primitive

BRL-CAD provides functions for its geometric primitives that define a bounding box - a box that completely encloses the volume described by the primitive. Ideally, these boxes are as small as possible while still enclosing the primitive. Currently the routine for BoTs is incorrect. You can use stl-g, obj-g, or any of our other *-g converters to import BoT geometry for testing.

This task involves studying the current code for the function rt_bot_bbox() and determining what is causing the current inaccuracies (the mged 'bb' command is a good way to visualize primitive bounding boxes). Make changes to produce a more optimal bounding box. Reimplement it from scratch if you like. The raytracing prep code in rt_bot_prep does prepare a better bounding box, so that is one place to check.

Code:

src/librt/primitives/bot/bot.c

Make mged 'tables' command not call system()

BRL-CAD's geometry editor (MGED) provides hundreds of functions that users can call on the command line. One of our oldest commands writes data out to text files and calls the unix "sort" command to sort a list of items.. That's really bad.

This task involves replacing the three calls to system() with a call to quicksort() or any other simple in-memory sorting mechanism.

Code:

src/libged/tables.c

Separate LIBNURBS files into one class per file

BRL-CAD has a recently implemented a new library that isn't very well organized. The files for that library are a haphazard collection of classes and functions. It's a bit of a mess.

This task involves making sure there is no more than one struct or class per source file. Class/struct declarations should be in header files. Class/struct method and functions should be in source files. Headers should be fully self-sufficient and include proper #ifdef wrappers (see include/*.h for examples). Make sure new files are named to match their enclosing class/struct. Be sure to update the CMakeLists.txt build file too and test compilation.

Code:

src/libnurbs/*

Implement mutex locking for Windows

BRL-CAD implements support for running in parallel on computers with multiple CPUs or cores. However, there are lots of ways to run in parallel. BRL-CAD runs on Windows, but presently only in a single-threaded mode. To make it work in parallel, we need to define how threads acquire a mutex lock.

This task involves implementing the necessary logic to acquire and release a mutex or semaphore on Windows. You can use either, but probably want to call CreateMutex(). This requires a very minor source code modification to just one file, but make sure it works with a simple test program. Make your test program call bu_semaphore_init()+bu_semaphore_acquire()+bu_semahpore_release(), see include/bu.h for API docs.

References:

http://msdn.microsoft.com/en-us/library/windows/desktop/ms686927(v=vs.85).aspx
http://msdn.microsoft.com/en-us/library/windows/desktop/ms686946(v=vs.85).aspx
Mark Walmsley: "Multi-Threaded Programming in C++", Springer, 2000 (although it has C++ in its title the basic functionality there is pure C)
include/bu.h

Code:

src/libbu/semaphore.c

Implement thread creation for Windows

BRL-CAD implements support for running in parallel on computers with multiple CPUs or cores. However, there are lots of ways to run in parallel. BRL-CAD runs on Windows, but presently only in a single-threaded mode. To make it work in parallel, we need to define how threads are created.

This task involves implementing the necessary logic to create a new thread in bu_parallel(). This requires a very minor source code modification to just one file, but make sure it works with a simple test program. Make your program call bu_parallel(), see include/bu.h for API docs.

References:

http://msdn.microsoft.com/en-us/library/windows/desktop/ms682453(v=vs.85).aspx
Mark Walmsley: "Multi-Threaded Programming in C++", Springer, 2000 (although it has C++ in its title the basic functionality there is pure C)
include/bu.h

Code:

src/libbu/parallel.c

Decouple LIBDM from LIBGED

BRL-CAD has a 3D display manager library (LIBDM) and a geometry editor command library (LIBGED). For clean encapsulation and library management, it's desirable to keep library dependencies to a minimum. LIBGED presently makes direct calls to LIBDM for a "screengrab" command. Properly fixed, it should be possible to remove the LIBDM linkage from LIBGED's build file and the command still work as expected.

This task involves breaking the dependency of LIBGED on LIBDM by making LIBGED not directly call any LIBDM functions. To do this, LIBGED will need to introduce a callback mechanism in the "ged" struct so that the screengrab command can capture an image without directly calling a LIBDM function. This task is a little tricky, so you'll need to be somewhat proficient with C if you want any chance of completing this within a couple hours.

Code:

include/ged.h
include/dm.h
src/libged/screengrab.h
src/libged/CMakeLists.txt

Implement a function to convert triangle meshes to solid polygon mesh

BRL-CAD implements numerous "primitive" 3D entity types. The Bag of Triangle (BoT) primitive implements simple triangle mesh geometry. Our N-manifold geometry (NMG) primitive implements solid polygonal mesh geometry. While we have a routine that converts an NMG to a BoT (mk_bot_from_nmg()), we do not have the reverse (mk_nmg_from_bot()).

This task implements the missing mk_nmg_from_bot() function so that the input triangle mesh is converted into the NMG data structures and stitched together appropriately.

References:

src/librt/primitives/nmg
src/librt/primitives/bot

Code:

src/libwdb/nmg.c

Close MGED when both windows are closed

BRL-CAD has an interactive geometry editor called MGED. It's often the starting point for beginners and allows creation and manipulation of models using commands. When mged is run, it creates 2 windows: a text-console command window and an interactive graphics window. When the user closes one of those windows, there is a bug. Closing the graphics window closes the command window.

This task involves fixing this behavior so that ONLY closing both windows terminates the process properly and that closing either window does not take the other along with it.

Code:

src/mged/mged.c
src/tclscripts/mged/openw.c

Add MGED key-binding to reopen the command window

BRL-CAD has an interactive geometry editor called MGED. It's often the starting point for beginners and allows creation and manipulation of models using commands. When MGED is invoked, it creates 2 windows: a text-console command window and an interactive graphics window. If the user closes the text-console command window, they are left with the interactive graphics window. There is presently no way (correct us if we're wrong) to get the text-console back without restarting mged. A good way to test this is to run in classic mode and run the 'gui' command:

sushi:~ morrison$ mged -c test.g
BRL-CAD Release 7.22.0  Geometry Editor (MGED)
    Fri, 24 Aug 2012 00:02:42 -0400, Compilation 6
    morrison@sushi.local:/usr/brlcad/rel-7.22.0

attach (nu|X|ogl)[nu]?   
mged> gui

This task involves adding some mechanism, perhaps a simple key binding, to the graphics window so that you can get the command window back on-demand.

Code:

src/mged/mged.c
src/tclscripts/mged/openw.c

Implement a primitive surface area function

BRL-CAD provides more than two dozen types of geometry "primitives" such as ellipsoids, boxes, and cones. Every primitive is described by a collection of callback functions, for example rt_ell_bbox() returns the bounding box dimensions for an ellipsoid. Wikipedia, Wolfram Mathworld, and various other math sites (and research papers) around the web include the equations for most of our basic primitives while others are a little more tricky to compute.

This task involves writing a new callback function that takes an rt_db_internal object and calculates the surface area (units are mm^2). There are numerous examples in our code where we compute surface area for other primitives. The primitives that do not already have a centroid callback are itemized in following.

References:

http://en.wikipedia.org/wiki/Surface_area
http://mathworld.wolfram.com/
http://www.dtic.mil/cgi-bin/GetTRDoc?AD=AD0274936
include/raytrace.h: See ft_surf_area callback defined in the rt_functab structure

... surface area function for elliptical hyperboloids (EHY)

Code:

src/librt/primitives/ehy/ehy.c

... surface area function for hyperboloids of one sheet (HYP)

Code:

src/librt/primitives/hyp/hyp.c

... surface area function for polyhedron with 4 to 8 sides (ARB8)

Code:

src/librt/primitives/arb8/arb8.c

... surface area function for N-faced polysolid (ARBN)

Code:

src/librt/primitives/arbn/arbn.c

... surface area function for extruded bitmaps (EBM)

Code:

src/librt/primitives/ebm/ebm.c

... surface area function for gridded volumes (VOL)

Code:

src/librt/primitives/vol/vol.c

... surface area function for super ellipsoids (SUPERELL)

Code:

src/librt/primitives/superell/superell.c

... surface area function for polygonal meshes (NMG)

Code:

src/librt/primitives/nmg/nmg.c

... surface area function for triangle meshes (BOT)

Code:

src/librt/primitives/bot/bot.c

... surface area function for NURBS objects (BREP)

Code:

src/librt/primitives/brep/brep.cpp

Implement a primitive volume function

BRL-CAD provides more than two dozen types of geometry "primitives" such as ellipsoids, boxes, and cones. Every primitive is described by a collection of callback functions, for example rt_ell_bbox() returns the bounding box dimensions for an ellipsoid. Wikipedia, Wolfram Mathworld, and various other math sites (and research papers) around the web include the equations for most of our basic primitives while others are a little more difficult to compute.

This task involves writing a new callback function that takes an rt_db_internal object and calculates the volume (units are mm^3). There are numerous examples in our code where we compute volume for other primitives. The primitives that do not already have a volume callback are itemized in following.

References:

http://en.wikipedia.org/wiki/Volume
http://mathworld.wolfram.com/
http://www.dtic.mil/cgi-bin/GetTRDoc?AD=AD0274936
include/raytrace.h: See ft_volume callback defined in rt_functab structure

... volume function for right hyperbolic cylinders (RHC)

Code:

src/librt/primitives/rhc/rhc.c

... volume function for elliptical hyperboloids (EHY)

Code:

src/librt/primitives/ehy/ehy.c

... volume function for hyperboloids of one sheet (HYP)

Code:

src/librt/primitives/hyp/hyp.c

... volume function for superellipsoids (SUPERELL)

Code:

src/librt/primitives/superell/superell.c

... volume function for extruded bitmaps (EBM)

Code:

src/librt/primitives/ebm/ebm.c

... volume function for gridded volumes (VOL)

Code:

src/librt/primitives/vol/vol.c

... volume function for triangle meshes (BOT)

Code:

src/librt/primitives/bot/bot.c

... volume function for solid polygonal meshes (NMG)

Code:

src/librt/primitives/nmg/nmg.c

... volume function for extruded sketches (EXTRUDE)

Code:

src/librt/primitives/extrude/extrude.c

Implement a primitive centroid function

BRL-CAD provides more than two dozen types of geometry "primitives" such as ellipsoids, boxes, and cones. Every primitive is described by a collection of callback functions, for example rt_ell_bbox() returns the bounding box dimensions for an ellipsoid. Wikipedia, Wolfram Mathworld, and various other math sites (and research papers) around the web include the equations for most of our basic primitives while others are a little more tricky to compute.

This task involves writing a new callback function that takes an rt_db_internal object and calculates its centroid (as a point_t 3D point). There are numerous examples in our code where we compute centroids for other primtiives. The primitives that do not already have a centroid callback are itemized in following.

References:

http://en.wikipedia.org/wiki/Centroid
http://mathworld.wolfram.com/
include/raytrace.h: See ft_centroid callback defined in the rt_functab structure

Code:

src/librt/primitives/table.c
src/librt/primitives/[PRIMITIVE]/[PRIMITIVE].c

... centroid function for elliptical hyperboloids (EHY)

... centroid function for right hyperbolic cylinders (RHC)

... centroid function for gridded volumes (VOL)

... centroid function for N-faced polysolids (ARBN)

... centroid function for extruded sketches (EXTRUDE)

... centroid function for superellipsoids (SUPERELL)

... centroid function for solid polygonal meshes (NMG)

Implement a primitive UV-mapping callback

BRL-CAD provides more than two dozen types of geometry "primitives" such as ellipsoids, boxes, and cones. Every primitive is described by a collection of callback functions, for example rt_ell_bbox() returns the bounding box dimensions for an ellipsoid. One of those functions describes a UV mapping of the object's surface, which is used for things like texture and bump mapping. An example of this is rt_ell_uv() in the src/librt/primitives/ell/ell.c source file for an ellipsoid. Several of our more complex primitive types (such as BoT, NMG, and BREP/NURBS) do not presently implement a UV-mapping function leading to unexpected runtime behavior.

This task involves implementing a UV-mapping callback for any of the primitives that do not already have a functional UV-callback defined. Note that this is an advanced task that might take you more than a couple hours if you don't have solid coding skills, but it's ultimately just a few lines of code. See other primitives that already implement a UV-mapping callback for reference.

References:

http://en.wikipedia.org/wiki/UV_mapping
src/librt/primitives/[PRIMITIVE]/[PRIMITIVE].c, read the rt_*_uv() function

... UV-mapping for extruded sketches (EXTRUDE)

Code:

src/librt/primitives/extrude/extrude.c
src/librt/primitives/table.c
include/rtgeom.h

Documentation and Training

Tasks related to creating/editing documents and helping others learn more about BRL-CAD

Add missing documentation (for any ONE command)

BRL-CAD is an extensive system with more than 400 commands and more than a million pages of documentation, but there are approximately 120 commands that are entirely undocumented:

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

This task involves writing basic documentation for JUST ONE of those commands in the Docbook XML format. The command documentation should provide a one-sentence description, a detailed paragraph description (200+ words), explanation of all available command-line options, and one or more examples on how to use the command.

Code:

doc/docbook/system/man1/en/Makefile.am
doc/docbook/system/man1/en/*.xml

Write a tutorial on compiling BRL-CAD with XCode on Mac OS X

BRL-CAD uses the CMake build system to generate outputs for a variety of platforms. It will output Makefiles, Microsoft Visual Studio build files, XCode project files, Eclipse build files and more.

This task involves generating an XCode project with our build and verifying that it successfully compiles all of BRL-CAD. Document the process on our wiki as a tutorial. Include screen shot images when referring to visual actions within XCode.

References:

Write a tutorial on compiling BRL-CAD with Eclipse on Linux

BRL-CAD uses the CMake build system to generate outputs for a variety of platforms. It will output Makefiles, Microsoft Visual Studio build files, XCode project files, Eclipse build files and more.

This task involves generating an Eclipse project with our build and verifying that it successfully compiles all of BRL-CAD. Document the process on our wiki as a tutorial. Include images/screen shots when referring to visual actions within Eclipse.

References:

Document MGED's 'saveview' command options

BRL-CAD's primary geometry editor (MGED) provides hundreds of commands. Two of those commands are the savewview and loadview commands that write current view settings out to a text file and read them back in. The saveview command provides -e -i -l and -o options, but they are not documented.

This task involves writing documentation for those missing options. Consult the source code to see what they do and add the corresponding sections into our Docbook XML doc just like we do in our other documentation files. Test compilation to make sure your XML syntax is correct.

References:

src/libged/saveview.c
doc/docbook/system/mann/en/*.xml

Code:

doc/docbook/system/mann/en/saveview.xml

Write "MGED Interface" reference document

BRL-CAD's primary geometry editor is called MGED. MGED's documentation is extensive but incomplete without a concise 1 or 2 page document that details MGED's interface.

This task involves writing an interface reference document that gives a brief descriptive overview of the key bindings, mouse bindings, and primary GUI elements. The shift grips reference should be incorporated, albeit much more concisely and organized. It should minimally include the command window, the graphics window, the raytrace control panel, the combination editor, the geometry tree view, and overview graphics window key bindings.

References:

Examples:

Convert 43 src/conv man pages to valid Docbook

BRL-CAD is in the process of converting its documentation in order to enable automatic generation of output in different formats (html, pdf, man) from a single source. We need to convert our existing UNIX man pages to the Docbook XML format. There is a doclifter conversion tool available to help automatically convert files, then just a little bit of cleanup is needed. This will find all of them:

find src/conv -name \*.1

The simplest way to confirm the files are successfully converted is to incorporate them into BRL-CAD's build logic (edit CMakeLists.txt) and view the output using brlman and an html viewer. It is recommended to use the Emacs editor with the nxml mode in order to more easily identify and fix errors, but this is not a requirement.

This task involves using the doclifter tool to perform a rough conversion to Docbook of all man pages in the src/conv subdirectory of the BRL-CAD source tree (about 43 files), then performing whatever manual corrections are needed to the autogenerated XML files to make them valid Docbook (some conversions have already been done and can serve as guides). Add new files to the doc/docbook/system/man1/en directory (via svn add), edit the CMakeLists.txt file in that same directory, verify no errors by compiling, and make a patch.

References:

doc/docbook/system/
Doclifter conversion tool: http://www.catb.org/~esr/doclifter/
Docbook documentation: http://www.docbook.org/tdg/en/html/docbook.html
Emacs editor: http://www.gnu.org/software/emacs/emacs.html
nxml Emacs mode: http://www.thaiopensource.com/nxml-mode/

Code:

src/conv/*.1
doc/docbook/system/man1/en/CMakeLists.txt
doc/docbook/system/man1/en/

Convert 38 src/fb man pages to valid Docbook

BRL-CAD is in the process of converting its documentation in order to enable automatic generation of output in different formats (html, pdf, man) from a single source. We need to convert our existing UNIX man pages to the Docbook XML format. There is a doclifter conversion tool available to help automatically convert files, then just a little bit of cleanup is needed. This will find all of them:

find src/fb -name \*.1

The simplest way to confirm the files are successfully converted is to incorporate them into BRL-CAD's build logic (edit CMakeLists.txt) and view the output using brlman and an html viewer. It is recommended to use the Emacs editor with the nxml mode in order to more easily identify and fix errors, but this is not a requirement.

This task involves using the doclifter tool to perform a rough conversion to Docbook of all man pages in the src/fb subdirectory of the BRL-CAD source tree (about 38 files), then performing whatever manual corrections are needed to the autogenerated XML files to make them valid Docbook (some conversions have already been done and can serve as guides). Add new files to the doc/docbook/system/man1/en directory (via svn add), edit the CMakeLists.txt file in that same directory, verify no errors by compiling, and make a patch.

References:

Current Docbook man pages: http://brlcad.svn.sourceforge.net/viewvc/brlcad/brlcad/trunk/doc/docbook/system/
Docbook documentation: http://www.docbook.org/tdg/en/html/docbook.html
Doclifter conversion tool: http://www.catb.org/~esr/doclifter/
Emacs editor: http://www.gnu.org/software/emacs/emacs.html
nxml Emacs mode: http://www.thaiopensource.com/nxml-mode/

Code:

src/fb/*.1
doc/docbook/system/man1/en/CMakeLists.txt
doc/docbook/system/man1/en/

Convert 24 other man pages to valid Docbook

BRL-CAD is in the process of converting its documentation in order to enable automatic generation of output in different formats (html, pdf, man) from a single source. We need to convert our existing UNIX man pages to the Docbook XML format. There is a doclifter conversion tool available to help automatically convert files, then just a little bit of cleanup is needed. This will find all of them:

find src/[glnrt]* -name \*.1

The simplest way to confirm the files are successfully converted is to incorporate them into BRL-CAD's build logic (edit CMakeLists.txt) and view the output using brlman and an html viewer. It is recommended to use the Emacs editor with the nxml mode in order to more easily identify and fix errors, but this is not a requirement.

This task involves using the doclifter tool to perform a rough conversion to Docbook of all man pages in the src/gtools, src/lgt, src/nirt, src/remrt, src/rt, src/rttherm, and src/tab subdirectories of the BRL-CAD source tree (about 24 files), then performing whatever manual corrections are needed to the autogenerated XML files to make them valid Docbook (some conversions have already been done and can serve as guides). Add new files to the doc/docbook/system/man1/en directory (via svn add), edit the CMakeLists.txt file in that same directory, verify no errors by compiling, and make a patch.

References:

Current Docbook man pages: http://brlcad.svn.sourceforge.net/viewvc/brlcad/brlcad/trunk/doc/docbook/system/
Docbook documentation: http://www.docbook.org/tdg/en/html/docbook.html
Doclifter conversion tool: http://www.catb.org/~esr/doclifter/
Emacs editor: http://www.gnu.org/software/emacs/emacs.html
nxml Emacs mode: http://www.thaiopensource.com/nxml-mode/

Code:

src/fb/*.1
doc/docbook/system/man1/en/CMakeLists.txt
doc/docbook/system/man1/en/

Write a "BRL-CAD Commands Quick Reference" document

There is already a command quick reference for BRL-CAD's MGED geometry editing tool, but there is not a similar document for BRL-CAD's 400+ command-line commands.

This task involves writing a quick reference document similar to the MGED quick reference but for BRL-CAD commands. The sheet should minimally include the following commands:

mged, rt*, *-g, g-*, fb*, *fb, nirt, remrt, rtsrv, asc2g, g2asc, dbupgrade, pix*, *pix, *-*, brlman, benchmark

References:

http://brlcad.org/wiki/Documentation
http://brlcad.org/w/images/5/52/MGED_Quick_Reference_Card.pdf
$latexsheet-0.png$

Doxygen cleanup

BRL-CAD uses Doxygen for most API documentation but the comment blocks are not optimally set up for Doxygen output.

This task involves cleaning up the Doxygen comments in the library so that useful reports and API documentation automatically generated (correctly, completely, and cleanly). Verify/fix any Doxygen syntax. Verify/fix groups so that functions are organized neatly and all contained within a group. Provide patches that give clean (PDF) output from Doxygen.

References:

... doxygen cleanup for LIBBU

There are approximately 300 documented API function calls in LIBBU.

Code:

include/bu.h
src/libbu
misc/Doxyfile

... doxygen cleanup for LIBBN

There are approximately 300 documented API function calls in LIBBN.

Code:

include/bn.h
include/plot3.h
include/vmath.h
src/libbn
misc/Doxyfile

... doxygen cleanup for LIBWDB

There are approximately 100 documented API function calls in LIBWDB.

Code:

include/wdb.h
include/raytrace.h
src/libwdb
misc/Doxyfile

... doxygen cleanup for LIBRT

There are approximately 1000 documented API function calls in LIBRT.

Code:

include/raytrace.h
src/librt
src/librt/primitives
src/librt/comb
src/librt/binunif
misc/Doxyfile

Write a "BRL-CAD Ray Tracing Shaders" tutorial

BRL-CAD includes numerous shaders that let you specify different optical effects during ray tracing.

This task involves writing a brief tutorial that describes what shaders are and how one specifies them for geometry. How shaders are specified is already described in detail in the Introduction to MGED document.

Code:

src/liboptical/sh_*.c (for available shader names and corresponding options)

References:

NURBS BibTeX reference file

BRL-CAD maintains a bibliography file that keeps track of published articles and reports pertaining to BRL-CAD, but it would be useful to have similar files that keep track of other topics. There are commonly two ways to create and maintain a .bib file. One way is manually (using any text editor) and the other is using a GUI such as JabRef. The rule of thumb is generally to use the text editor approach when building a .bib file of references that are pre-packaged (such as those often provided by publishers of journal articles) and to use a tool like JabRef when you have to create the entire entry from scratch.

This task involves creating a NURBS.bib file that documents BRL-CAD's various paper references contained in the bibliographics of the following papers (include these papers and what they reference):

Practical Ray Tracing of Trimmed NURBS Surfaces http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.35.7126

Direct and Fast Ray Tracing of NURBS Surfaces http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.90.7500

Watertight Trimmed NURBS http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.146.3590

The best route is probably assembly of pre-existing .bib entries from either the citeseerx website or from the sites of the journal actually publishing the article.

References:

Code:

doc/NURBS.bib

Outreach and Research

Tasks related to community management, outreach/marketing, studying problems, and recommending solutions

Write solicitation for new website designer

The BRL-CAD website is in need of a design overhaul.

This task involves writing up a brief article soliciting new contributor(s) to work on designing a new website. The article needs to be detailed and specific to our particular website requirements (Drupal+Mediawiki+CSS) to ensure the contributor can design the appropriate stylesheet(s), updated graphics, and new layout. Provide a title, an image, a short summary (<200 words), and the detailed write-up (>400 words).

References:

http://brlcad.org

Model a "B" using BRL-CAD

Create an uppercase letter "B" geometry model using BRL-CAD. You can use the mged or archer geometry editor tools or write a script. The model should be roughly 1000mm tall, about 500mm wide, and about 100mm deep. Create it using CSG or other methods, but it cannot be an imported model, polygonal mesh (BOT, NMG), or extruded bitmap (EBM).