Namespace for Geometrical Reasoning?

Hi there,

I'm a PhD student working in the field of computer vision and recently
used Perl for doing my research and am asking for an appropriate name 
for my Perl module(s).

I implemented a geometrical toolbox called SUGR[1] for constructing
and testing points, lines, planes and transformations in 2D and 3D.
The toolbox is based on projective geometry and a simple but effective
uncertainty model, though one can use the tool without statistics,
too. See BACKGROUND section in this post for more details.

So, the question of my post is: what name should be used for this Perl
module? Currently, SUGR is not categorized to any toplevel name. IMHO there
are several possibilities, I could categorize it to some computational geometry
related field (Math::Geometry::SUGR) or some statistical field (Statistics::SUGR).

Since I cannot decide for one option or the other, I'd like to use 
AI::SUGR since this toolbox can be used for reasoning with 
uncertain geometric objects as you could do reasoning with logical 
statements (plane $A is orthogonal to line $L, which in turn contains
point $X, without "choosing the epsilon", see BACKGROUND section).

So, what's the opinion of the community?
 
There is already a preview version of my library, it also
includes a special shell (based on the pdlshell) and a simple markup
language for offline computations. This is available from
http://www.ipb.uni-bonn.de/SUGR.html

-Stephan

Footnotes: 
[1]  SUGR is an acronym for "Statistically Uncertain Geometric
     Reasoning" 

############
# Details: #
############

 BACKGROUND
 ----------
 
   The (scientific) contribution of this work is the fact that the
   geometrical toolbox uses simple statistical description (second
   moments). This is helpful if you are not 100% sure about the exact
   values of your points, lines and planes.  For example if you
   measure the length of your notebook with a simple ruler, you will
   never know the length in - say - Angstrom (=1 hundred-millionth of
   a centimeter), so you will always have some uncertainty about the
   correct length.
   
   Using simple statistics has several advantages: (i) you can propagate
   the uncertainty to new geometrical objects. (ii) you get rid of the
   "choosing-the-epsilon-problem"[2] when testing geometrical relations
   such as "Does point X lie on the 3D-line L?". (iii) you can do a
   weighted least-squares estimation to do _any_ kind of constructions
   involving points, lines and planes in 2D and 3D.
 
 
   Footnotes:
   [2] The "Choosing-the-epsilon-problem" appears for example when you
       want to test whether a number is zero. It is usually not really
       zero, but close to it - so you choose a special small number
       called epsilon and test if your number is smaller than epsilon.
 
 INTERFACE
 ---------
 
              # create a new 3D point, with an homogeneous 4-vector and
              # a homogeneous 4x4 covariance matrix
              $X = new SUGR::Point([0,1,1,1],
                                   [[0.01,0   ,0   ,0],
                                    [0   ,0.01,0   ,0],
                                    [0   ,0   ,0.01,0],
                                    [0   ,0   ,0   ,0]]);
 
              # create two other points with
              # the same covariance matrix as the first point
              $Y = new SUGR::Point([0,2,3,1],$X->cov);
              $Z = new SUGR::Point([2,2,0,1],$X->cov);
 
              # construct a new 3D line using $X and $Y,
              # including error propagation
              $L = new SUGR::Line($X,$Y);
 
              # and a plane with the third point $Z
              $A = new SUGR::Plane($L,$Z);
 
              # create a projective camera $P with given
              # projection center $X0 (as a SUGR point!),
              # rotation matrix $R and focal length $c with its
              # variance $c_var
              $X0 = new SUGR::Point([10,10,10,1],$X->cov);
              $R  = new PDL::Matrix([[0,1,0],[1,0,0],[0,0,1]]);
              $P  = sugr_ProjectiveCamera({ "X0"    => $X0,
                                            "R"     => $R,
                                            "c"     => 1,
                                            "c_var" => 0.001,
                                          });
 
              # construct a new 2D point as an image of $X with
              # the projective camera $P
              $x = new SUGR::Point2d($X,$P);

              # test if two points $X and $Y are identical
              $X == $Y

              # test if a line $L is parallel to a plane $A in 3D 
              Parallel($A,$L)

 
-- 
Stephan Heuel                                 fon: +49 228 73 2711
Institute for Photogrammetry                  fax: +49 228 73 2712
University of Bonn, Nussallee 15          mailto:[email protected]
53115 Bonn - GERMANY             http://www.ipb.uni-bonn.de/~steve