diff --git a/README.txt b/README.txt
index 7585bbf..34c2819 100644
--- a/README.txt
+++ b/README.txt
@@ -1,523 +1,523 @@
 Name
 
       qhull, rbox         2012.1     2012/02/18
   
 Convex hull, Delaunay triangulation, Voronoi diagrams, Halfspace intersection
  
       Documentation:
         html/index.htm
         http://www.qhull.org/html
 
       Available from:
         <http://www.qhull.org>
         <git@gitorious.org:qhull/qhull.git>
         <http://packages.debian.org/sid/libqhull5> [out-of-date]
  
       News and a paper:
         <http://www.qhull.org/news>
         <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.117.405>
 
      Version 1 (simplicial only):
         <http://www.qhull.org/download/qhull-1.0.tar.gz>
        
 
 Purpose
 
   Qhull is a general dimension convex hull program that reads a set 
   of points from stdin, and outputs the smallest convex set that contains 
   the points to stdout.  It also generates Delaunay triangulations, Voronoi 
   diagrams, furthest-site Voronoi diagrams, and halfspace intersections
   about a point.
 
   Rbox is a useful tool in generating input for Qhull; it generates 
   hypercubes, diamonds, cones, circles, simplices, spirals, 
   lattices, and random points.
   
   Qhull produces graphical output for Geomview.  This helps with
   understanding the output. <http://www.geomview.org>
 
 Environment requirements
 
   Qhull and rbox should run on all 32-bit and 64-bit computers.  Use
   an ANSI C or C++ compiler to compile the program.  The software is 
   self-contained.  It comes with examples and test scripts.
   
   Qhull's C++ interface uses the STL.  The C++ test program uses QTestLib 
   from Nokia's Qt Framework.  Qhull's C++ interface may change without 
   notice.  Eventually, it will move into the qhull shared library.
   
   Qhull is copyrighted software.  Please read COPYING.txt and REGISTER.txt
   before using or distributing Qhull.
 
 To cite Qhull, please use
 
   Barber, C.B., Dobkin, D.P., and Huhdanpaa, H.T., "The Quickhull 
   algorithm for convex hulls," ACM Trans. on Mathematical Software,
   22(4):469-483, Dec 1996, http://www.qhull.org.
 
 To contribute to Qhull
 
   Qhull is on Gitorious (http://gitorious.org:qhull, git@gitorious.org:qhull/qhull.git)
   
   For internal documentation, see html/qh-code.htm
 
 To install Qhull
 
   Qhull is precompiled for Windows, otherwise it needs compilation.
   
   Besides makefiles for gcc, qhull includes CMakeLists.txt for CMake, 
   vcproj/sln files for Microsoft Visual Studio, and .pro files for Qt Creator.
   It compiles with mingw.
   
   Install and build instructions follow.  
   
   See the end of this document for a list of distributed files.
 
 -----------------
 Installing Qhull on Windows 7 (32- or 64-bit), Windows XP, and Windows NT
 
   The zip file contains rbox.exe, qhull.exe, qconvex.exe, qdelaUnay.exe, 
   qhalf.exe, qvoronoi.exe, testqset.exe, user_eg*.exe, documentation files, 
   and source files.
   
   To install Qhull:
   - Unzip the files into a directory.  You may use WinZip32 <www.hotfiles.com>
   - Click on QHULL-GO or open a command window into Qhull's bin directory.
     
   To uninstall Qhull
   - Delete the qhull directory
   
   To learn about Qhull:
   - Execute 'qconvex' for a synopsis and examples.
   - Execute 'rbox 10 | qconvex' to compute the convex hull of 10 random points.
   - Execute 'rbox 10 | qconvex i TO file' to write results to 'file'.
   - Browse the documentation: qhull\html\index.htm
   - If an error occurs, Windows sends the error to stdout instead of stderr.
     Use 'TO xxx' to send normal output to xxx and error output to stdout
 
   To improve the command window
   - Double-click the window bar to increase the size of the window
   - Right-click the window bar
   - Select Properties
   - Check QuickEdit Mode
     Select text with right-click or Enter
     Paste text with right-click
   - Change Font to Lucinda Console
   - Change Layout to Screen Buffer Height 999, Window Size Height 55
   - Change Colors to Screen Background White, Screen Text Black
   - Click OK
   - Select 'Modify shortcut that started this window', then OK
 
   If you use qhull a lot, install MSYS (www.mingw.org),
     Road Bash (www.qhull.org/bash), or Cygwin (www.cygwin.com).
 
 -----------------
 Installing Qhull on Unix with gcc
 
   To build Qhull, static libraries, shared library, and C++ interface
   - Extract Qhull from qhull...tgz or qhull...zip
   - make
   - export LD_LIBRARY_PATH=$PWD/lib:$LD_LIBRARY_PATH
 
   Or, to build Qhull and libqhullstatic.a
   - Extract Qhull from qhull...tgz or qhull...zip
   - cd src/libqhull
   - make
 
   The Makefiles may be edited for other compilers.
   If 'testqset' exits with an error, qhull is broken
   
 -----------------
 Installing Qhull with CMake 2.6 or later
 
   To build Qhull, static libraries, shared library, and C++ interface
   - Extract Qhull from qhull...tgz or qhull...zip
   - cd build
   - cmake ..
   - make
   - make install
   
   On Windows, CMake installs to C:/Program Files/qhull
   See CMakeLists.txt for further build instructions
 
 -----------------
 Installing Qhull with Qt
 
   To build Qhull, static libraries, shared library, C++ interface, and C++ test
   - Extract Qhull from qhull...tgz or qhull...zip
   - cd src
   - qmake
   - make
   
 -----------------
 Installing Qhull with Autoconf [WARNING out-of-date]
 
   The tar.gz tarball contains documentation, source files, 
   and a config directory [R. Laboissiere].
 
   [Nov 2011] Qhull 2009.1.2 does not include the C++ interface
   
   To install Qhull
   - Extract the files
   - ./configure
   - make
   - make install
 
 -------------------
 Working with Qhull's C++ interface
 
   Qhull's C++ interface is likely to change.  Stay current with Gitorious.
 
   To clone Qhull's next branch from http://gitorious.org/qhull
     git init
     git clone git://gitorious.org/qhull/qhull.git
     cd qhull
     git checkout next
     ...
     git pull origin next
 
 ------------------
 Compiling Qhull with Microsoft Visual C++ 2005 or later
 
   To compile Qhull with Microsoft Visual C++
   - Extract Qhull from Gitorious, qhull...tgz, or qhull...zip
   - Load solution build/qhull.sln 
   - Build
   - Project qhulltest requires Qt for DevStudio (http://qt.nokia.com/downloads)
     Set the QTDIR environment variable to your Qt directory (e.g., c:/qt/4.7.4)
     If incorrect, precompile will fail with 'Can not locate the file specified'
 
 -----------------
 Compiling Qhull with Qt Creator
 
   Qt (http://qt.nokia.com) is a C++ framework for Windows, Linux, and Macintosh
 
   Qhull uses QTestLib to test qhull's C++ interface (qhulltest)
   
   To compile Qhull with Qt Creator
   - Extract Qhull from Gitorious, qhull...tgz, or qhull...zip
   - Download the Qt SDK from Nokia (http://qt.nokia.com/downloads)
   - Start Qt Creator
   - Load src/qhull-all.pro
   - Build
 
 -----------------
 Compiling Qhull with mingw on Windows
 
   To compile Qhull with MINGW
   - Extract Qhull from Gitorious, qhull...tgz, or qhull...zip
   - Install Road Bash (http://www.qhull.org/bash)
     or install MSYS (http://www.mingw.org/wiki/msys)
   - Install MINGW (http://www.mingw.org/).  Mingw is included with Qt SDK.  
   - make
   
 -----------------
 Compiling Qhull with cygwin on Windows
 
   To compile Qhull with cygwin
   - Extract Qhull from Gitorious, qhull...tgz, or qhull...zip
   - Install cygwin (http://www.cygwin.com)
   - Include packages for gcc, make, ar, and ln
   - make
 
 -----------------
 Compiling from Makfile without gcc
 
   The file, qhull-src.tgz, contains documentation and source files for
   qhull and rbox.  
   
   To unpack the gzip file
   - tar zxf qhull-src.tgz
   - cd qhull
   
   Compiling qhull and rbox with Makefile
   - in Makefile, check the CC, CCOPTS1, PRINTMAN, and PRINTC defines
       - the defaults are gcc and enscript
       - CCOPTS1 should include the ANSI flag.  It defines __STDC__
   - in user.h, check the definitions of qh_SECticks and qh_CPUclock.
       - use '#define qh_CLOCKtype 2' for timing runs longer than 1 hour
   - type: make 
       - this builds: qhull qconvex qdelaunay qhalf qvoronoi rbox libqhull.a
   - type: make doc
       - this prints the man page
       - See also qhull/html/index.htm
   - if your compiler reports many errors, it is probably not a ANSI C compiler
       - you will need to set the -ansi switch or find another compiler
   - if your compiler warns about missing prototypes for fprintf() etc.
       - this is ok, your compiler should have these in stdio.h
   - if your compiler warns about missing prototypes for memset() etc.
       - include memory.h in qhull_a.h
   - if your compiler reports "global.c: storage size of 'qh_qh' isn't known"
       - delete the initializer "={0}" in global.c, stat.c and mem.c
   - if your compiler warns about "stat.c: improper initializer"
       - this is ok, the initializer is not used
   - if you have trouble building libqhull.a with 'ar'
       - try 'make -f Makefile.txt qhullx' 
   - if the code compiles, the qhull test case will automatically execute
   - if an error occurs, there's an incompatibility between machines
       - If you can, try a different compiler 
       - You can turn off the Qhull memory manager with qh_NOmem in mem.h
       - You can turn off compiler optimization (-O2 in Makefile)
       - If you find the source of the problem, please let us know
   - to install the programs and their man pages:
       - define MANDIR and BINDIR
       - type 'make install'
 
   - if you have Geomview (www.geomview.org)
        - try  'rbox 100 | qconvex G >a' and load 'a' into Geomview
        - run 'q_eg' for Geomview examples of Qhull output (see qh-eg.htm)
 
 ------------------
 Compiling on other machines and compilers
 
   Qhull compiles with Borland C++ 5.0 bcc32.  A Makefile is included.
   Execute 'make -f Mborland'.  If you use the Borland IDE, set the ANSI
   option in Options:Project:Compiler:Source:Language-compliance.
   
   Qhull compiles with Borland C++ 4.02 for Win32 and DOS Power Pack.  
   Use 'make -f Mborland -D_DPMI'.  Qhull 1.0 compiles with Borland 
   C++ 4.02.  For rbox 1.0, use "bcc32 -WX -w- -O2-e -erbox -lc rbox.c".  
   Use the same options for Qhull 1.0. [D. Zwick]
   
   Qhull compiles with Metrowerks C++ 1.7 with the ANSI option.
   If you turn on full warnings, the compiler will report a number of 
   unused variables, variables set but not used, and dead code.  These are
   intentional.  For example, variables may be initialized (unnecessarily)
   to prevent warnings about possible use of uninitialized variables.  
 
   Qhull compiles on the Power Macintosh with Metrowerk's C compiler.
   It uses the SIOUX interface to read point coordinates and return output.
   There is no graphical output.  For project files, see 'Compiling a
   custom build'.  Instead of using SIOUX, Qhull may be embedded within an
   application.  
 
   Some users have reported problems with compiling Qhull under Irix 5.1.  It
   compiles under other versions of Irix. 
   
   If you have troubles with the memory manager, you can turn it off by
   defining qh_NOmem in mem.h.
 
 -----------------
 Distributed files
 
   README.txt           // Instructions for installing Qhull 
   REGISTER.txt         // Qhull registration 
   COPYING.txt          // Copyright notice 
   QHULL-GO.lnk         // Windows icon for eg/qhull-go.bat
   Announce.txt         // Announcement 
   CMakeLists.txt       // CMake build file (2.6 or later)
   File_id.diz          // Package descriptor
   index.htm            // Home page 
   Makefile             // Makefile for gcc and other compilers
   qhull*.md5sum        // md5sum for all files
 
   bin/*		       // Qhull executables and dll (.zip only)
   build/qhull.sln      // DevStudio solution and project files (2005 or later)
   build/*.vcproj
   config/*             // Autoconf files for creating configure (Unix only)
   eg/*                 // Test scripts and geomview files from q_eg
   html/index.htm       // Manual
   html/qh-faq.htm      // Frequently asked questions
   html/qh-get.htm      // Download page
   html/qhull-cpp.xml   // C++ style notes as a Road FAQ (www.qhull.org/road)
   src/Changes.txt      // Change history for Qhull and rbox 
   src/qhull-all.pro    // Qt project
 
 eg/ 
   q_eg                 // shell script for Geomview examples (eg.01.cube)
   q_egtest             // shell script for Geomview test examples
   q_test               // shell script to test qhull
   q_test-ok.txt        // output from q_test
   qhulltest-ok.txt     // output from qhulltest (Qt only)
 
 rbox consists of (bin, html):
   rbox.exe             // Win32 executable (.zip only) 
   rbox.htm             // html manual 
   rbox.man             // Unix man page 
   rbox.txt
 
 qhull consists of (bin, html):
   qhull.exe            // Win32 executables and dlls (.zip only) 
   qconvex.exe
   qdelaunay.exe
   qhalf.exe
   qvoronoi.exe
   qhull.dll
   qhull_p.dll
   qhull-go.bat         // command window
   qconvex.htm          // html manual
   qdelaun.htm
   qdelau_f.htm        
   qhalf.htm
   qvoronoi.htm
   qvoron_f.htm
   qh-eg.htm
   qh-code.htm
   qh-impre.htm
   index.htm
   qh-opt*.htm
   qh-quick.htm
   qh--*.gif            // images for manual
   normal_voronoi_knauss_oesterle.jpg
   qhull.man            // Unix man page 
   qhull.txt
 
 bin/
   msvcr80.dll          // Visual C++ redistributable file (.zip only)
 
 src/
   qhull/unix.c         // Qhull and rbox applications
   qconvex/qconvex.c    
   qhalf/qhalf.c
   qdelaunay/qdelaunay.c
   qvoronoi/qvoronoi.c
   rbox/rbox.c
 
   user_eg/user_eg.c    // example of using qhull_p.dll (requires -Dqh_QHpointer)
   user_eg2/user_eg2.c  // example of using qhull.dll from a user program
-  user_eg3/user_eg3.cpp // example of Qhull's C++ interface with libqhullstatic_p.a
+  user_eg3/user_eg3.cpp // example of Qhull's C++ interface with libqhullstatic_r.a
   qhulltest/qhulltest.cpp // Test of Qhull's C++ interface using Qt's QTestLib
   qhull-*.pri          // Include files for Qt projects
 
 src/libqhull
   libqhull.pro         // Qt project for shared library (qhull.dll)
   index.htm            // design documentation for libqhull
   qh-*.htm
   qhull-exports.def    // Export Definition file for Visual C++
   Makefile             // Simple gcc Makefile for qhull and libqhullstatic.a
   Mborland             // Makefile for Borland C++ 5.0
 
   libqhull.h           // header file for qhull
   user.h               // header file of user definable constants 
   libqhull.c           // Quickhull algorithm with partitioning
   user.c               // user re-definable functions 
   usermem.c
   userprintf.c
   userprintf_rbox.c
 
   qhull_a.h            // include files for libqhull/*.c 
   geom.c               // geometric routines 
   geom2.c
   geom.h     
   global.c             // global variables 
   io.c                 // input-output routines 
   io.h   
   mem.c                // memory routines, this is stand-alone code 
   mem.h
   merge.c              // merging of non-convex facets 
   merge.h
   poly.c               // polyhedron routines 
   poly2.c
   poly.h 
   qset.c               // set routines, this only depends on mem.c 
   qset.h
   random.c             // utilities w/ Park & Miller's random number generator
   random.h
   rboxlib.c            // point set generator for rbox
   stat.c               // statistics 
   stat.h
 
 src/libqhullp
   libqhullp.pro        // Qt project for shared library (qhull_p.dll)
   qhull_p-exports.def  // Export Definition file for Visual C++
 
 src/libqhullstatic/
   libqhullstatic.pro   // Qt project for static library     
      
 src/libqhullstaticp/
   libqhullstaticp.pro  // Qt project for static library with qh_QHpointer
      
 src/libqhullcpp/
   libqhullcpp.pro      // Qt project for static C++ library     
   Qhull.cpp            // Call libqhull.c from C++
   Qhull.h
   qt-qhull.cpp         // Supporting methods for Qt
   qhull_interface.cpp  // Another approach to C++
     
   Coordinates.cpp      // input classes
   Coordinates.h
   PointCoordinates.cpp
   PointCoordinates.h
   RboxPoints.cpp       // call rboxlib.c from C++
   RboxPoints.h
 
   QhullFacet.cpp       // data structure classes
   QhullFacet.h
   QhullHyperplane.cpp
   QhullHyperplane.h
   QhullPoint.cpp
   QhullPoint.h
   QhullQh.cpp
   QhullStat.cpp
   QhullStat.h
   QhullVertex.cpp
   QhullVertex.h
   
   QhullFacetList.cpp   // collection classes
   QhullFacetList.h
   QhullFacetSet.cpp
   QhullFacetSet.h
   QhullIterator.h
   QhullLinkedList.h
   QhullPoints.cpp
   QhullPoints.h
   QhullPointSet.cpp
   QhullPointSet.h
   QhullRidge.cpp
   QhullRidge.h
   QhullSet.cpp
   QhullSet.h
   QhullSets.h
   QhullVertexSet.cpp
   QhullVertexSet.h
 
   functionObjects.h    // supporting classes
   QhullError.cpp
   QhullError.h
   QhullQh.cpp
   QhullQh.h
   UsingLibQhull.cpp
   UsingLibQhull.h
 
 src/qhulltest/
   qhulltest.pro        // Qt project for test of C++ interface     
   Coordinates_test.cpp // Test of each class
   PointCoordinates_test.cpp
   Point_test.cpp
   QhullFacetList_test.cpp
   QhullFacetSet_test.cpp
   QhullFacet_test.cpp
   QhullHyperplane_test.cpp
   QhullLinkedList_test.cpp
   QhullPointSet_test.cpp
   QhullPoints_test.cpp
   QhullPoint_test.cpp
   QhullRidge_test.cpp
   QhullSet_test.cpp
   QhullVertexSet_test.cpp
   QhullVertex_test.cpp
   Qhull_test.cpp
   RboxPoints_test.cpp
   UsingLibQhull_test.cpp
 
 src/road/
   RoadError.cpp        // Supporting base classes
   RoadError.h
   RoadLogEvent.cpp
   RoadLogEvent.h
   RoadTest.cpp         // Run multiple test files with QTestLib
   RoadTest.h
 
 src/testqset/
   testqset.pro		// Qt project for test qset.c with mem.c
   testqset.c
   
 -----------------
 Authors:
 
   C. Bradford Barber                  Hannu Huhdanpaa (Version 1.0)
   bradb@shore.net                     hannu@qhull.org
   
   Qhull 1.0 and 2.0 were developed under NSF grants NSF/DMS-8920161 
   and NSF-CCR-91-15793 750-7504 at the Geometry Center and Harvard 
   University.  If you find Qhull useful, please let us know.
diff --git a/src/Changes.txt b/src/Changes.txt
index 0783df0..baf58e0 100644
--- a/src/Changes.txt
+++ b/src/Changes.txt
@@ -1,1661 +1,1669 @@
 
 .............This file lists all changes to qhull and rbox.....................
 
 ------------
 Need help
  - Qhull needs RPM and Debian builds (CMake's CPackRMP and CPackDeb).   
  - Add an Autotools build for everything
  - Set up debian build [octave-maintainers]
    Please keep debian files in config/ 
  - Qhull needs a mirror/archive site for old and new builds
  - The C++ interface needs work.  Give it a try and make it better.
    http://gitorious.org/qhull/
  - Document with Qt conventions using Doxygen (//! and //!<)
  - Produce conformant triangulations for merged facets using option 'Qt' 
 
 To do
  - Review email for doc changes before jun'10
  - Git: Create signed tags for Qhull versions
  - Wiki: Add FIXUP to QH11026 for known problems
  - Notes to compgeom on conformant triangulation and Voronoi volume
  - Set File Ver and Product Ver in dll
  - For the C++ interface, make qh_qh a parameter instead of a global static
    This replaces qh_QHpointer.  It simplifies multithreading.
  - Compute the convex hull of each Voronoi or Delaunay region
  - Performance test of qset and qhull
 
  - qh-get.htm:  List the Window OSs for Qhull [T. Winkler]
  - Reconsider Qhull version numbering (e.g., Traveler 4/5/12) 
 
 ------------
 Qhull
  - Rename debugging routines dfacet/dvertex to qh_dfacet/qh_dvertex 
  - Rename rbox routines to qh_roundi/qh_out1/qh_out2n/qh_out3n 
  - Rename dfacet and dvertex to qh_dfacet and qh_dvertex 
  - Replace 'qhmem .zzz' with 'qhmem.zzz'
  - Removed spaces between function and parentheses
  - Rename 'enum statistics' to 'enum qh_statistics'
- - Rename 'qh_rand_seed' to 'qh_last_random'
+ - Rename 'qh_rand_seed' to 'qh_last_random'.  Declare it as DATA
+ - Declare rbox as DATA in qhull-exports.def and qhull_p-exports.def
  - In comments, use 'qh.zzz' to reference qhT fields
  - In qh_fprintf, use qhmem.ferr to report errors
  - qh_fprintf may be called for errors in qh_initstatistics and qh_meminit
  - After qh_meminit, qhmem.ferr is non-zero
 
 qhullr
- - Removed qh_save_qhull(), qh_restore_qhull(), and qh.old_qhstat from global_r.c
- - Removed qh_freeqhull2() (global_r.c)
- - Removed old code from unix_r.c and rbox_r.c for __POWERPC__
- - qh_rand_seed is a global (random_r.c)
+ - Remove qh_save_qhull(), qh_restore_qhull(), and qh.old_qhstat from global_r.c
+ - Remove qh_freeqhull2() (global_r.c)
+ - Remove conditional code for __POWERPC__ from unix_r.c and rbox_r.c
+ - Move qh_last_random into qh->last_random (random_r.c)
  - Rename sources files with a '_r' suffix
  - Replace 'qh' macro with 'qh->'
  - Replace global qhT with parameter-0
  - Add qhmemT to beginning of qhT.  It may not be used standalone.
  - Add qhstatT to end of qhT
  - Remove qhull_inuse
  - Change qhmem.zzz to qh->qhmem.zzz
  - Replace qh_qhstat with qh->qhstat
  - Remove qh_freestatistics
  - Replace qh_last_random with qh->last_random
  - Replace rboxT with qh->rbox_errexit, rbox_isinteger, rbox_out_offset
  - Replace rbox.ferr/fout with qh->ferr/fout
  - No qh for qh_exit, qh_free, qh_malloc, qh_strtod, qh_strtol, qh_stddev
+ - New qmake include files qhull-app-c_r.pri, qhull-app-shared_r.pri, qhull-libqhull-src_r.pri
+
+C++ interface
+ - Reimplement C++ interface on reentrant libqhullr instead of libqhull
+ - Renamed libqhullcpp to libqhullpcpp
+ - Renamed qhulltest to qhullptest
+ - Renamed qhull-app-cpp.pri to qhull-app-cpp_p.pri
  
 Qhull 2012.1  2012/02/18 6.3.1.1494
  - Fix CMakeLists for libqhull with MATCHES [P. Gajdos]
 
 ------------
 Qhull 2012.1  2012/02/18 6.3.1.1490
 
 Code changes
  - Require option 'Qz' for Delaunay triangulation/Voronoi diagram 
    of cocircular/cospherical points [D. Sheehy]
  - qh_errexit: Do not call qh_printsummary or qh_printstats on qh_ERRinput
  - Change error QH6227 (all degenerate) from qh_ERRinput to qh_ERRprec
  - Change error QH6159 (ID overflow) from qh_ERRinput to qh_ERRqhull
  - eg/q_eg, q_egtest, q_test: Run if qconvex is in $PATH [M. Atzeri]
    
 Build changes [M. Atzeri]
  - Install to share/doc/qhull instead of share/doc/packages/qhull
  - On Unix systems, install to share/man/man1 instead of man/man1
  - CMakeLists: Remove the installation of user_eg* and testqset
  - CMakeLists: Remove VERSION from qhull executables and libraries
  - CMakeLists: Define qhull_SOVERSION instead of qhull_MAJOR 
  - CMakeLists: Set SOVERSION for shared libraries
  - Rename libraries to qhull, qhull_d, qhull_p, and qhull_pd
    libqhull6_p.vcproj is now libqhull_p.vcproj
    mingw builds as libqhull.dll
    cygwin builds as cygqhull-6.dll
    linux builds as libqhull.so.6.3.1 with symbolic link as libqhull.so
  - Developers using qhull 2011: 
    libqhull6.so is now libqhull_p.so.  Do not use libqhull.so.
    qhull6.dll is now qhull_p.dll.  Do not use qhull.dll. 
  - Merged road/ into libqhullcpp/ and qhulltest/
    Moved RoadLogEvent.* and RoadError.* to libqhullcpp
    Moved RoadTest.* to qhulltest (requires Qt)
    Installed RoadTest.h in libqhullcpp 
 
 Doc changes
  - index.htm: Mathworks uses qhull for n-d
  - qhull.htm: Fix qhull for qconvex
  - qdelaun.htm/qvoronoi.htm: Use option 'Qz' for circular/cospherical inputs
  - make help: Display targets
  - Makefile: Better messaging
 
 ------------
 Qhull 2012.1  2012/02/02 6.3.0.1483
 
 Bug fixes
  - Fixed qset.c for -fno-strict-aliasing. This gcc option is no longer needed
    (disallow two pointers of differing types to the same memory location)
  - Fixed error in qh_setappend_set if first set full and second set empty
  - qh_setdelnth, qh_setdelnth_sorted: fixed wording of error message
  - qh_setcheck: error message listed size and max backwards.
  - qh_setequal: Allow NULL set as documented
  - qh_setindex: Allow NULL set as documented
  - qh_settemppush: report error if NULL
 
 Code changes
  - Add testqset: low level test of qset.c with mem.c
  - qh_setendpointer: Implements QSet::endPointer()
  - Assigned unique error code for qh_gethash
 
 Build changes
  - Added qhull.dll(.so) for Octave and other Debian builds
    The global data structure qh_qh is statically defined (no qh_QHpointer)
    Linked user_eg2 with qhull.dll (libqhull.so) instead of qhullstatic
    Added qh_dllimport to libqhull.h for qhull.dll with MSVC 
    Changed qhull-app-shared.pri to use libqhull (without qh_QHpointer)
  - Renamed libqhull6.so to libqhull6_p.so
    Renamed qhull6.dll to qhull6_p.dll
    The _p libraries (e.g., libqhull6_p.so) require -Dqh_QHpointer
    Renamed qhull6.vcproj to libqhull6_p.vcproj
    Added libqhullp/libqhullp.pro for shared library (libqhull6_p.so)
    Added qhull-app-sharedp.pri for shared libraries with qh_QHpointer
  - Install libqhull/*.htm files into include/libqhull
  - Removed libqhull/qhull.h-deprecated [J. Eaton]
  - Other changes to Makefile builds
    Added 'make qtestall' as a smoketest of each qhull program
    src/libqhull/Makefile: Use 'ar -rs ...' instead of ranlib
    src/libqhull/Makefile: Fixed targets for cleanall
  - Other changes to DevStudio builds
    Moved pdb files for qhull libraries to lib/
    AdditionalIncludeDirectories: Removed ../src/libqhullcpp 
    Use build-cmake/ for the DevStudio CMake build
  - Other changes to Qt builds
    Renamed qhull-libsrc.pri to qhull-libqhull-src.pri
  - Added explicit d2u conversions to qhull-zip.sh
  - Fixed \n vs. \r\n issues for Windows source files
 
  Draft of Debian/AutoConf build (untested)
  - Adjusted the Makefile.am's for the new directory structure.
  - Added testqset to bin_PROGRAMS
  - config/bootstrap.sh copies program sources into src/libqhull
  - Kept qh_QHpointer=0 (static global data structure, qh_qh).  It is faster.
    Planning a new interface (qhull7?) which passes qh_qh as a parameter
  - Added config/changelog from the 2003.1 Debian build
  - Moved the debian/patches directory to config/
    Optional patches to change smoketest message and turn on qh_QHpointer
  - Deleted the debian directory.  It was the old Debian build from 2003.1
    Rafael Laboissiere's config directory replaced this build..
  - Deleted Make-conf.sh (also the old Debian build)
  
 Doc changes
  - FAQ: Updated notes on computing volume of a Voronoi region
  - Added direct link to ACM Digital Library for downloading the qhull paper
  - Added link to Qhull in R
  - qset.c: Updated notes about NULL sets
  - qh_setappend: clarify qh_setappend for NULL newelem
  - qh_setdellast: Fix head note
  - Add build/README.txt
  - Add uninstall instructions to README.txt and CMakeLists.txt
  - Added instructions to create build/*.vcproj to CMakeLists.txt
  - Update copyright to 2012
  - Updated page links.  Added Google books, patents, and blogs. 
 
 -----------
 Qhull 2009.1.3 2011/12/06
   configure: Add  -fno-strict-aliasing if $GCC,  Required for gcc 4.1+
 
 ------------
 Qhull 2011.2  2011/11/29 6.2.1.1446
 
 Bug fixes
  - qh_new_qhull: Call qh_prepare_output if !outfile [A. Aldoma]
    No effect on qhull users since qh_prepare_output is always called.
  - Replace Qhull-go.pif with Qhull-go.lnk for Windows 7 64-bit [lots]
  - Error if qh_newhashtable, qh_setnew, or qh_memalloc overflows [X. Cheng]
    For example, 'rbox 64 D32' overflows hash table for qh_matchnewfacets
    Qhull uses 32-bit ints for identifiers, counts, and sizes. See "WARN64"
  - q_eg, q_test: change tail +3 to tail -n +3 [N. Dubray, M. Atzeri]
  - Qhull-go.bat: Changed 'cmd' to '%comspec%'
 
 Build changes
  - Added src/libqhull/Makefile for simple gcc build of executables and lib
  - qhulltest.vcproj: Replaced full path to QT with $QTDIR (e.g., c:/qt/4.7.4)
  - Split userprintf_rbox.c from userprintf.c,  
    Otherwise qhull brings in rboxlib and rbox brings in libqhull
  - Makefile: qhullx target must be after LIBQHULLS_OBJS
  - Makefile: Explicitly list rbox dependencies for qhullx target
  - MBorland: Fixed tabs
  - Placed $LIBQHULLS_OBJS in same order.  Frequently called ones together. 
  - Update file lists for Make-config.sh [O. Lahaye]
  - CMakeLists: add README.txt,etc. to DOC_INSTALL_DIR [M. Atzeri]
  - Restored qhull.h-deprecated.  
    qhull.h conflicts with Qhull.h on Windows systems [C. Abela]
  - make-config.sh: Add warning that it is out-of-date
  - Remove extra space in '#! /bin/sh' in q_eg, etc. [P. Cheeseman]
 
 Source changes
  - libqhull.h: Added qh_True and qh_False for True/False [A. Mutzel]
    Did not remove or replace True/False since it is used everywhere
  - Moved error message from qh_argv_to_command to caller.  Avoids dependency.
  - user_eg3.c: Use '10 D2' as default rbox (e.g., 'user_eg3 rbox qhull d')
  - user.c, user_eg2.c: Add test of qh_qh as done in user_eg.c
  - q_test: Removed duplicate test of qhull C-0.02
 
 Documentation
  - index.html: Added ACM Authorizer link to ACM Trans. Math. Software
  - Split Delaunay and Voronoi FAQs
  - FAQ: How to compute the volume of a Voronoi region [C, Brinch]
  - Add 'FS' to qconvex prompt (total area and volume) 
  - Add clarification to 'Fv' about corner input sites [O. Can]
  - Qhull-go.bat: Removed out-of-date advice.  Added title.
  - qh-code.htm: Updated the discussion of multi-threading for C++ [I. Pirwani]
  
 Qhull 2009.1.2 2011/11/21
  - Revert to LF line endings [P. Cheeseman]
  - Remove out-of-date material from qhull-go.bat
  - Replaced QHULL-GO with a lnk file
 
 Qhull 2011.1  2011/05/23 6.2.0.1385 (exe/dll files unchanged)
  - delaunay.vcproj: Fixed qhullstatic_d.lib for debug and minrelsize builds
  - Did not redate the distribution
 
 Qhull 2011.1  2011/05/18 6.2.0.1385 (exe/dll files unchanged)
  - Add 'm' library to shared and static targets on Unix [A. Bouchard]
 
 Qhull 2011.1  2011/05/14 6.2.0.1383 (exe/dll files unchanged)
  - PointCoordinates.cpp: Add #include <iterator> [R. Richter, S. Pasko]
  - Remove deprecated libqhull/qhull.h
    Use libqhull/libqhull.h instead.  Avoids confusion with libqhullcpp/Qhull.h
  - Makefile: Add LIBDIR, INCDIR, and DESTDIR to install [L.H. de Mello]
      Separate MAN install from DOC install
      Create install directories
      Installs headers to include/libqhull, include/libqhullcpp, include/road
  - CMakeLists.txt: Add MAN_INSTALL_DIR for qhull.1 and rbox.1 man pages
      Add RoadTest.h to include/road for Qt users (road_HEADERS)
  - Renamed md5sum files to avoid two extensions
  - qh-get.htm: Add Readme links and 2009.1 note.
  - qh-optf.htm: Fix link
  - index.htm: Updated Google Scholar link
  - qhull-zip.sh: Improved error message.
 
 ------------
 Qhull 2011.1  2011/04/17 6.2.0.1373
 
 Changes to deliverables
  - qvoronoi: Deprecated 'Qt' and 'QJn'. Removed from documentation and prompts.
    These options produced duplicate Voronoi vertices for cospherical data.
  - Removed doskey from Qhull-go.bat.  It is incompatible with Windows 7
  - Added 'facets' argument to user_eg3.cpp
  - user_eg links with shared library
  - qhulltest.cpp: Add closing prompt.
 
 Changes to build system
  - Reorganized source directories
  - Moved executables to bin directory
  - Add CMake build for all targets (CMakeFiles.txt) [M. Moll assisted]
  - Add gcc build for all targets (Makefile)
  - Fixed location of qhull.man and rbox.man [M. Moll]
  - Add DevStudio builds for all targets (build/*.vcproj)
  - Added shared library (lib/qhull6.dll)
    Added qh_QHpointer_dllimport to work around problems with MSVC
  - Added static libraries with and without qh_QHpointer (lib/qhullstatic.lib)
  - Added eg/make-vcproj.sh to create vcproj/sln files from cmake and qmake
  - Document location of qh_QHpointer
  - Use shadow build directory
  - Made -fno-strict-aliasing conditional on gcc version
  - Added src/qhull-app-cpp.pri, src/qhull-app-c.pri, etc. for common settings
  - Add .gitignore with ignored files and directories.  
  -   Use .git/info/exclude for locally excluded files.
  - Fixed MBorland for new directory structure
 
 Changes to documentation
  - qvoronoi.htm: Remove quotes from qvoronoi example
  - qhull-cpp.xml: Add naming conventions
  - index.htm: Add Google Scholar references
  - qh-optf.htm: Add note about order of 'Fn' matching 'Fv' order [Q. Pan]
  - Add patch for old builds in qh-get.htm
  - Added C++ compiling instructions to README.txt
  - Add instructions for fixing the DOS window
  - Changed DOS window to command window
  - Fixed html links
  - qh-get.htm: Dropped the Spanish mirror site.  It was disabled.
 
 Changes to C code
  - mem.h: Define ptr_intT as 'long long' for Microsoft Windows _win64 builds.
    On Linux and Mac, 'long' is 64-bits on a 64-bit host
  - Added qh_QHpointer_dllimport to work around MSVC problem
  - qconvex.c,etc.: Define prototype for _isatty
  - Define MSG_QHULL_ERROR in user.h
  - Move MSG_FIXUP to 11000 and updated FIXUP QH11...
 
 Changes to test code
  - Add note to q_test than R1e-3 may error (qh-code.htm, Enhancements)
  - Add test for executables to q_eg, etc.
  - Fixed Qhull-go.bat.  QHULL-GO invokes it with command.com,
 
 Changes to C++ interface
  - QhullFacet: Added isSimplicial, isTopOrient, isTriCoplanar, isUpperDelaunay
  - Added Qhull::defineVertexFacetNeighbors() for facetNeighbors of vertices.
    Automatically called for facet merging and Voronoi diagrams
    Do not print QhullVertex::facetNeighbors is !facetNeighborsDefined()
  - Add Fixup identifiers
  - QhullError: Add copy constructor, assignment operator, and destructor
  - Add throw() specifiers to RoadError and QhullError
  - Renamed RoadError::defined() to RoadError::isDefined()
  - Add #error to Qhull.h if qh_QHpointer is not defined
 
 Changes to C++ code
  - Fixed bug reported by renangms.  Vertex output throws error QH10034
    and defineVertexNeighbors() does not exist.
  - Define QHULL_USES_QT for qt-qhull.cpp [renangms]
  - Reviewed all copy constructors and copy assignments.  Updated comments.
    Defined Qhull copy constructor and copy assignment [G. Rivet-Sabourin]
    Disabled UsingQhullLib default constructor, copy construct, and copy assign 
  - Merged changes from J. Obermayr in gitorious/jobermayrs-qhull:next
  -   Fix strncat limit in rboxlib.c and global.c
  -   Changes to CMakeLists.txt for openSUSE
  - Fixed additional uses of strncat
  - Fixed QhullFacet::PrintRidges to check hasNextRidge3d()
  - Removed gcc warnings for shadowing from code (src/qhull-warn.pri)
  - Removed semicolon after extern "C" {...}
  - Removed experimental QhullEvent/QhullLog
  - Use fabs() instead of abs() to avoid accidental conversions to int
  - Fixed type of vertex->neighbors in qh_printvoronoi [no effect on results]
  - Removed unnecessary if statement in qh_printvoronoi
 
 ------------
 qhull 2010.1 2010/01/14
 - Fixed quote for #include in qhull.h [U.Hergenhahn, K.Roland]
 - Add qt-qhull.cpp with Qt conditional code
 - Add libqhullp.proj
 - Add libqhull5 to Readme, Announce, download
 - Reviewed #pragma
 - Reviewed FIXUP and assigned QH tags
 - All projects compile with warnings enabled
 - Replaced 'up' glyphs with &#187;
 - Moved cpp questions to qh-code.htm#questions-cpp 
 - Moved suggestions to qh-code.htm#enhance 
 - Moved documentation requests to qh-code.htm#enhance
 - Add md5sum file to distributions
 - Switched to DevStudio builds to avoid dependent libraries, 10% slower
   Removed user_eg3.exe and qhullcpp.dll from Windows build 
   Fix qhull.sln and project files for qh_QHpointer
 - Add eg/qhull-zip.sh to build qhull distribution files
 
 ------------
 qhull 2010.1 2010/01/10
 - Test for NULL fp in qh_eachvoronoi [D. Szczerba]
 
 qhull 2010.1 2010/01/09
 
 Changes to build and distribution
 - Use qh_QHpointer=0 for libqhull.a, qhull, rbox, etc.
   Use -Dqh_QHpointer for libqhullp.a, qhullcpp.dll, etc.
   qh_QHpointer [2010, gcc] 4% time 4% space, [2003, msvc] 8% time 2% space
 - Add config/ and project/debian/ for Autoconf build [R. Laboissiere]
   from debian branch in git and http://savannah.nongnu.org/cvs/?group=qhull
 - Add CMakeLists.txt [kwilliams]
 - Fix tabs in Makefile.txt [mschamschula]
 - Add -fno-strict-aliasing to Makefile for gcc 4.1, 4.2, and 4.3 qset segfault
 - Remove user_eg.exe and user_eg2.exe from Windows distribution
 - Order object files by frequency of execution for better locality.
 
 Changes to source
 - Remove ptr_intT from qh_matchvertices.  It was int since the beginning.
 - user.h requires <time.h> for CLOCKS_PER_SEC
 - Move ostream<<QhullFacetList from inline to compiled.
 - Removed ConvexHull/ from git.  Not used.
 
 ------------
 qhull 2009.1.1 2010/01/09
 - Patch release of 2009.1.
   qh_gethash allowed a negative result, causing overwrite or segfault
   See git:qhull/project/patch/qhull-2003.1/poly.c-qh_gethash.patch
   Compared results of q_test, q_eg, q_egtest with patched poly.c, qhull-2003.1
 
 ------------
 qhull 2010.1 2010/01/07
 - Assign type to qh.old_qhstat and memT.tempstack [amorilia]
 - Replace tabs with spaces.
 - Fix qh_pointid in case ptr_intT is unsigned
 
 qhull 2010.1 2010/01/06
 - Fixed serious bug in qh_gethash [poly.c]
 - Documentation and build system are incomplete (see above)
 - First release of C++ interface [qh-code.htm]
 - Development moved to http://gitorious.org/qhull
   git clone git@gitorious.org:qhull/qhull.git
 - Did not fix conformant tesselations for 'Qt'.
   For details, see http://www.qhull.org/news#bugs of May 2007 and Dec 2006.
 - Use g++ builds for Windows distribution (10% faster than msvc2005)
   Combined vcproj/ and qtproj/ into project/
   vcproj will be replaced by qmake generated files
 
 ------------
 qhull 2010.0.3 2010/01/05
 Fixed bugs
 - 'QJn': Fix qh.STOPcone in qh_build_withrestart().  It was not cleared.
 - qh_initqhull_outputflags [global.c]: warn about Qc only if QHULLfinished
     otherwise set if needed
 
 qhull 2010.0.2 2010/01/04
 
 Fixed bugs
 - qh_gethash [poly.c]: fix sign conversion.
     Previously, the result may be negative, leading to a segfault.
     The bug is more likely with large address spaces
     Reviewed all uses of %(modulo) for remainder with negative arguments
 - Reviewed output of q_test and compared to results from 2003.1
 
 Breaking code changes
 - Return type of qh_gethash changed from unsigned to int.  Matches 'size'
 - addhash takes a signed hash
   qh_addhash( newelem, hashtable, hashsize, hash )
 
 Code changes
 - Test for qh_qh in qh_printf
 - Makefile.txt corrected for libqhull build [amorilia]
 - Renamed index to idx to avoid shadowing BSD strings.h [kwilliams]
 
 qhull 2010.0.1  2010/01/03
 
 New Features:
  - Added option 'Ta' to annotate output with message codes
 
 Preliminary C++ support:
  - C++ declarations may change without warning
  - Preliminary documentation for Qhull's C++ interface [qh-code.htm#cpp, qhull-cpp.xml]
  - Added user_eg3 as an example of Qhull.cpp
  - Removed qhull_interface.cpp
 
 Changes to qhull options and results
  - Allow 'd' and 'v' as the filename for 'TO ..' and 'TI ...' in qdelaunay [M. Jambon]
  - 'rbox tN' requires an integer (previously allowed floats)
  - Allow quoted filenames for 'TO ...' and 'TI ...'
  - Prefix error messages and warnings with a message code (e.g., QH6012)
  - Fixed rbox ignoring flags that were not separated by spaces
  - Report all hidden options before exiting in qh_checkflags()
  - Defined qh_OPTIONline [user.h] as max length of option line ('FO')
  - Report error if negative arguments to rbox 'G', 'L', 'Z'
  - Unknown rbox flag changed from a warning to an error
  - Set error status 4 qh_ERRmem if rbox runs out of memory
  - Removed extra spaces at end of line
 
 Breaking Code Changes:
  - Renamed qh.coplanarset to coplanarfacetset.  Avoids conflict with facetT.coplanarset
  - qh_restore_qhull() zeroes out qh.old_qhstat and qh.old_tempstack.  Ownership moved.
  - Rewrote save_qhull/restore_qhull
  - Add Ztotcheck to zzdef_ [R. Gardener]
  - Changed qh_malloc to size_t (was unsigned long)
  - Declare qh_PRINT instead of int [kwilliams]
  - In qh_printafacet(), changed error output to 'qh ferr'
 
 Bug fixes to C code:
  - Use gcc 4.4.0 or later.  gcc 4.2.1, 4.2.2, and 4.3.2 -O2 segfaults in qset.c .  gcc 4.1.1 was OK
    See bug report http://gcc.gnu.org/ml/gcc-bugs/2007-09/msg00474.html
  - Rewrite qh_setappend to avoid g++ 4.1, 4.2, and 4.3 strict_aliasing error.
      Orion Poplawski (orion@cora.nwra.com)
      http://www.rpmfind.net/linux/RPM/fedora/12/ppc/qhull-devel-2003.1-13.fc12.ppc64.html
  - Fixed qh_findfacet_all(), "REALmin" should be "-REALmax" [L.A. Taylor].
      Effects library users for convex hulls and halfspace intersections.
  - qh_printfacet [io.c] Removed extra space for neighboring facets
  - Report error if d points, Delaunay, and not Qz
  - Fixed double-free of facet->centrum for triangulated facets
  - Fixed mindist initialization if !testcentrum in io.c findbest_test [Ratcliff]
  - Fixed parentheses around warning for missing 'Qc' [qh_initqhull_outputflags]
  - Fixed rbox buffer overflow of 'command' when appending seedbuf
  - Fixed option string for 'rbox t t999'.  Although seed was correctly set to 999,
    a random seed was appended to the rbox comment (e.g., 'rbox t t999 t32343')
  - Fixed upper bound of sanity check for qh_RANDOMmax in qh_initqhull_globals()
 
 Changes to C code
  - Reordered #include from specific to general.  Move up .h for module.
  - Removed qh.old_stat -- never used
  - Removed qh_clearcenters from qh_freeqhull.  Duplicated by qh_delfacet
  - qh_printcenter [io.c] removed unreachable fprintf argument
  - qh_getarea() [geom2.c] ignored on multiple calls (qh.hasAreaVolume)
  - qh_getarea() [geom2.c] checks facet->isarea. Set by QhullFacet.facetArea()
  - qh_triangulate() [poly2.c] ignored on multiple calls (qh.hasTriangulation)
  - Add statistics for vertex_visit and visit_id to buildtracing
  - Defined scale and offset parameters for qh_randomfactor
 
 Bug fixes and changes to mem.c/mem.h
  - Fixed qhmem.totshort (total short memory in use)
  - Memory tracing (T5) redone for sort order by object
  - Added full tracing for short memory allocations.
  - Added qhmem.totfree (total short memory on freelists)
      Increases size of qh_memalloc_ and qh_memfree_
  - Added qhmem.totdropped (leftover freesize at end of each short buffer)
  - Added qhmem.totunused (short size - request size)
  - Added qhmem.totbuffer (total short memory buffer w/o links)
  - Added memory statistics to qh_NOmem;
  - Added qh_memtotal to track allocated memory
  - Renamed qh_memfree parameter to 'insize' for consistency with qh_memalloc
  - Removed qhmem.curlong.  qa_memfreeshort computes curlong from cntlong and cntfree
  - In mem.h, changed ptr_intT to long.  qh_meminit() checks that it holds a 'void*'
 
 Fixed g++ and devstudio warnings
  - Except for bit field conversions, compiles cleanly with
    -Wall -Wextra -Wshadow -Wcast-qual -Wwrite-strings -Wno-sign-conversion -Wconversion
  - Fixed warnings at VC8, level 4
  - Fix data types to remove conversion warnings [kwilliams]
  - Use size_t for calls to malloc,etc [kwilliams]
    Retained int sizes for qset.h and mem.h.  Follows Qt convention
    and is easier to work with.  int can be 64-bits if 2 billion facets
  - Change literal strings to const char* [kwilliams]
  - Added type casts to SETfirst and SETsecond [amorilia+alphax]
  - getid_() returns an int [kwilliams]
  - Add missing const annotations [kwilliams]
  - Fixed 64-bit warnings (marked with "WARN64")
  - Convert sizeof to (int) for int parameters
  - In libqhull.c, added explicit casts from long to float,  Avoids warning
  - In global.c, cast time() to int for QRandom-seed.  Avoids warning
 
 Changes to C code for C++ support
  - Add sln, vcproj, and qtpro files for building Qhull -- add to README notes
  - Added dim to vertexT for cpp interface. Reduced size of qh.vertex_visit
  - qh_produce_output [io.c] may be called multiple times (C++ interface)
  - Moved SETsizeaddr_() to qset.h for use by QhullSet.cpp
  - Option 'Tz' sets flag qh.USEstdout for QhullPoints.cpp
  - Added support for multiple output runs from QhullPoints.outputQhull
  -   qh_clear_outputflags() resets the output flags
  -   qh_initqhull_outputflags split from qh_initqhull_globals
  - Added qh.run_id, a random identifier for this instance of Qhull (QhullPoints)
  -   For qh.run_id, initqhull_start initializes qh_RANDOMseed to time instead of 1
  - Extracted qh_argv_to_command (random.c) from qh_init_qhull_command and fixed a buffer overflow
  - Moved qh_strtod/qh_strtol from global.c to random.c for use in rboxlib.c
  - Split out random functions into random.c
  - Added message codes to qh_fprintf().  See its definition in user.c
  - Replaced exit, malloc, free, fprintf, and fputs with qh_malloc,...[J.W. Ratcliff]
  - Added qh_fprintf, qh_malloc, qh_free, ph_printhelp_narrowhull to user.c
  - Moved qh_printhelp_degenerate and qh_printhelp_singular from io.c to user.c
  - Clear qh.ERREXITcalled at end of qh_errexit().
 
 Documentation:
  - Fixed out-of-date CiteSeer references
  - Renamed html/qh-in.htm to html/qh-code.htm
  - Add reference to 'Qt' to 'i'
  - Add reference to 'FS' to 'FA'
  - qh-impre.htm discusses precision issues for halfspace intersection
  - Add cross references between options 'FA' and 'FS'
  - Added link to Wolfram Research's MathWorld site
  - Updated Fukuda's links
  - Changed copyright to C.B. Barber for C++, documentation, and merge.c
  - Updated Qhull citation with page numbers.
  - Proposed project: constructing Voronoi diagram
  - Proposed project: computing Voronoi volumes
  - Replaced tabs with spaces in qhull.txt and rbox.txt
 
 ------------
 qhull 2009.1  2009/6/11
 
 This is a maintenance release done by Rafael Laboissiere <rafael@debian.org>.
  - src/rbox.c (main): Avoid problems of evaluation order when
    pre-incrementing arguments of strtod
  - src/io.c (qh_produce_output), src/stat.c (qh_initstatistics): Use %lu
    instead of %d in the format string for arguments of type size_t
  - html/qhull.man, html/rbox.man: Fix several syntax, macros, and hyphen
    problems in man pages
  - The Autotools files have been generated with modern version of autoconf (2.63),
    automake/aclocal (1.10.2), and libtool (2.2.6)
  - Some character issues in the man pages are fixed
 
 ------------
 qhull 2003.1  2003/12/30
 
 New Features:
  - Add Maple output ('FM') for 2-d and 3-d convex hulls [T. Abraham]
 
 Breaking Code Changes:
  - Annotate C code with 'const'.  An ANSI compatible compiler is required.
 
 Bug Fixes and Code Changes:
  - Fixed qh_findbest() for upperdelaunay facets w/o better, lower neighbors
      For library users and some qhull users [A. Cutti, E. Milloti, K. Sun]
  - Preserved qhmem.ferr in qh_memfreeshort() for library users
  - Removed 'static' from qh_compare... for io.h and merge.h [V. Brumberg]
  - Split out qh_initqhull_start2() to avoid allocating qh_qh
  - Split out qh_freeqhull2() to avoid freeing qh_qh
  - Split out qh_produce_output2() and qh_prepare_output()
  - qh_initstatistics() frees a previously existing qh_qhstat
  - qh_initqhull_start2() checks that qh_initstatistics() called first
 
 Documentation:
  - Add warning to findDelaunay() and qh_in.htm about tricoplanar facets
  - Noted Edelsbrunner's Geometry & Topology for Mesh Generation [qh-impre.htm]
  - Noted Gartner's Miniball algorithm [qh_impre.htm]
  - Noted Veron and Leon's shape preserving simplification [qh_impre.htm]
 
 qhull 2003.1  2003/12/19
 
 Bug Fixes:
  - Reversed coordinate order for qh.ATinfinity in qh_projectinput [V. Brumberg]
    This effects:
      Qhull library 'd' or 'v' users with 'Qz' and unequal coordinate ranges.
      qdelaunay/qvoronoi users with 'Qbk:0Bk:0', 'Qz', and unequal coordinate ranges
 
 Changes to code:
  - Replaced qh_VERSION with qh_version in global.c [B. Pearlmutter]
     The previous techniques were either clumsy or caused compiler errors
  - Removed unused variables from qh_findbest and qh_findbestnew [B. Pearlmutter]
  - Note that qh.TESTpoints was added in 2002.1 for tsearch implementation
 
 Changes to distribution:
  - Added Unix distribution including Debian files [R. Laboissiere]
     The previous Unix distribution is now the source distribution
  - Added rpm distribution [L. Mazet]
  - Investigated generation of Win32 dll.  Need to define a C++ interface.
 
 Changes to documentation:
  - Moved Qhull to www.qhull.org (geom.umn.edu is not available)
  - The Geometry Center is archived at http://www.geom.uiuc.edu
  - Reviewed introduction to each program
     Triangulated output ('Qt') is more accurate than joggled input ('QJ')
     qdelaunay is 'qhull d Qbb' [C. Ulbrich]
     qvoronoi is 'qhull v Qbb'
     Added example of non-simplicial intersection to halfspace intersections
  - Added warning about using the Qhull library.
  - Added qhull timings to When to use Qhull [C. Ulbrich]
  - Reorganized the home page index and the manual index
  - Moved qh-home.htm to index.htm
 
 Changes to examples
  - Fixed options for eg/eg.t23.voronoi.imprecise [B. Pearlmutter]
 
 
 ------------
 qhull 2002.1  2002/8/20
 
 Changes to distribution:
  - Set up savannah.nongnu.org/projects/qhull/ [R. Laboissiere]
  - Set up www.thesa.com as a backup
  - Added qh-get.htm, a local copy of the download page
  - Added Visual C++ interface to Qhull, qhull_interface.cpp [K. Erleben]
  - Use HTTP instead of FTP for downloading Qhull
  - Renamed qhull-1.0.sit.hqx
 
 Bug fixes:
  - Fixed sign of coefficients for cdd halfspaces ('FD','Fd')  [T. Abraham]
 
 Changes to code:
  - Replace qh_version with qh_VERSION in libqhull.h.
    Allows shared libraries and single point of definition
  - Added qh.TESTpoints for future implementation of tsearch
 
 Changes to build
  - Makefile.txt works under cygwin
  - Added Make-config.sh to create a Debian build [R. Laboissiere]
  - Added .exe to Makefile.txt#clean.
  - In README, use -fno-strict-aliasing with gcc-2.95.1 [Karas, Krishnaswami]
  - Fixed chmod in Makefile.txt [B. Karas]
 
 Documentation updates
  - Documented input options for each program [A. Montesinos]
  - FAQ: "How to get the radii of the empty spheres for Voronoi vertices"
 
 URL updates:
  - Changed official URL from locate/qhull to software/qhull
  - Changed URLs from relative to absolute in qh-home.htm and qh-get.htm
  - Added URL for Newsgroup: comp.soft-sys.matlab
  - Added URL for GNU Octave
  - Added URLs for Google and Google Groups
  - Replaced qhull_mail.html and qhull_bug.html with mailto links.
  - Removed URL for Computational Geometry Tribune
  - Changed URL for locate/cglist to software/cglist
  - Used site relative links for qh-home.htm
 
 ------------
 qhull 3.1 2001/10/04
 
 New features
  - Added option 'Qt' to triangulate non-simplicial facets
  - Added option 'TI file' to input data from file
  - Added option 'Q10' to prevent special processing for narrow distributions
         e.g., RBOX 1000 L100000 s G1e-6 t1001803691 | QHULL Tv Q10
  - Tried to compute Voronoi volumes ('Pv'). Requires dual face graph--not easy
         See Clarkson's hull program for code.
 
 Changes to options
  - Added numtricoplanars to 'Fs'. Number of good, triangulated facets for 'Qt'
  - Added Zdelvertextot to 'Fs'.  If non-zero and Delaunay, input is degenerate
  - Qhull command ('FQ') may be repeated.
  - If 'TPn' and 'TWn' defined, trace the addition of point 'n'
      otherwise continue tracing (previously it stopped in 4-d)
  - Removed 'Ft' from qdelaunay.  Use 'Qt o' or 'qhull d QJ Qt' instead.
      For non-simplicial regions, 'Ft' does not satisify the Delaunay property.
  - If 'Po' or 'TVn', qhull checks outer planes.  Use 'Q5' to turn off.
  - If 'T4', print facet lists and check polygon after adding each point
 
 Corrections to code
  - rbox: allow 'c' and 'd' with 's r', meshes, etc.
  - qh_findbest: redesigned as directed search. qh_findbesthorizon for coplanar
       qh_findbest is faster for many distributions
  - qh_findbestnew: redesigned to search horizon of coplanar best newfacets
       needed for distributions with a sharp edge,
           e.g., rbox 1000 s Z1 G1e-13 | qhull Tv
  - qh_findbest/qh_findbestnew: search neighbors of better horizon facets
       was needed for RBOX 1000 s Z1 G1e-13 t996564279 | qhull Tv
       and RBOX 1000 s W1e-13 P0 t996547055 | QHULL d Qbb Qc Tv
  - qh_findbest with noupper: could return an upperdelaunay facet if dist>qh.MINoutside.
  - qh_findbestnew: allow facet->upperdelaunay if dist > qh.MINoutside
  - qh_partitioncoplanar: call qh_partitionpoint if outside and perpendicular
       for distributions with a sharp edge
  - qh_partitionvisible: report precision error if all newfacets degenerate.
       was needed for RBOX 1000 s W1e-13 t995138628 | QHULL d
  - qh_createsimplex: clears qh.num_visible, may be non-zero with 'TRn QJ'
 
 Changes to prompts, warnings, and statistics
  - For Delaunay & Voronoi, 's' reports deleted vertices due to facet merging.
    They were incorrectly reported as nearly incident points.
  - Warn if recompute centrum after constructing hull
  - Simplified narrow hull warning and print all digits of cosine.
      A narrow hull may lead to a point outside of the hull.
  - Print total vertices deleted instead of ave. per iteration (Zdelvertextot)
  - Improved tracing for qh_partitionpoint and qh_partitioncoplanar
  - Added number of distance tests for checking outer planes (qh_check_maxout)
  - Simplified "qhull precision error: Only n facets remain."
  - Included 'TRn' in the causes of a premature exit
 
 Changes to documentation
  - README.txt: Added quickstart instructions for Visual C++
  - rbox: Added example of edge of narrow lens, rbox 1000 L100000 s G1e-6
  - Added cross references between options 'o' and 'p'.
  - qh-eg.html: added examples comparing 'Qt', 'QJ', and neither 'Qt' nor 'QJ'
         eg.15a.surface, eg.15b.triangle, eg.17a.delaunay.2, etc.
  - Reorganized and enhanced discussion of precision problems in qh_impre.htm
  - Fixed spelling errors [K. Briggs]
  - Fixed link errors, validated HTML, and spell checked [HomeSite]
  - Removed unnecessary #TOP links
  - Added source links to the qh-quick.htm's header and footer
  - qh-geom.htm, qh-poly.htm: add links to Voronoi functions in io.c
  - src/index.htm: Added how to search libqhull.h for qhull options
  - qvoronoi.htm/qdelaun.htm: 'Fc' and 'FN' includes deleted vertices
 
 Changes to URLs
  - Added http://www.voronoi.com and http://www.magic-software.com
 
 Changes to code
  - qh_qhull: if 'TVn' or 'TCn' do not call qh_check_maxout and qh_nearcoplanar
  - reviewed time profile.  Qhull is slower.  Optimized qh_findbestnew()
  - qh_addpoint: Added warning note about avoiding a local minimum
  - qh_checkpolygon: report qh.facet_next error if NARROWhull & dist>MINoutside
  - qh_findbest: renamed "newfacets" parameter to "isnewfacets" since it is boolT
  - qh_findbest/qh_findbestnew: testhorizon even if !MERGING
         Otherwise qhull c D6 | qhull Q0 Tv assigns coplanar points
  - qh_resetlists: add qh_RESETvisible for qh_triangulate
  - qh_findbest: search better facets first.  Rewritten.
  - qh_findbest: increased minminsearch, always check coplanar facets.
         See: RBOX 1000 s Z1 G1e-13 t996564279 | QHULL Tv
  - qh_findbestnew: report precision error for deleted cones [rare event]
         e.g.:  RBOX 1000 s W1e-13 P0 t1001034076 | QHULL d Qbb Qc Tv
  - qh_findbesthorizon: search horizon of qh.coplanarset.  New.
  - qh_findbestsharp: replaced with qh_sharpnewfacets followed by qh_findbestnew
  - qh_partitionpoint, Delaunay sites can not be inside.  Otherwise points may
        be outside upperDelaunay facets yet not near-inside Delaunay facets
        See: RBOX s 1000 t993602376 | QHULL C-1e-3 d  Qbb FA Tv
  - qh_partitioncoplanar: call qh_findbest/qh_findbestnew with qh DELAUNAY
  - qh_printlists: format long lines
  - qh_printvertex: format long lines
  - user.h: tightened qh_WARNnarrow and qh_MAXnarrow.  Do not see problems
        until they are -1.0.
  - user.h: defined qh_DISToutside, qh_SEARCHdist, and qh_USEfindbestnew
  - qh_checkfacet: in 3-d, allow #ridges > #vertices.  Can get a vertex twice
    in a ridge list, e.g,  RBOX 1000 s W1e-13 t995849315 D2 | QHULL d Tc Tv
 
 Changes to FAQ
  - Recommended use of triangulated output ('Qt')
 
 Changes to distribution
  - Recompiled in Visual C++ 5.0 with optimization (as was version 2.6)
  - q_test: Added bad cases for Qhull and tests for new features
 
 Changes to Qhull library
  - Added qh_triangulate() to poly2.c.  It triangulates the output.
  - Added option 'Q11' to copy normals and recompute centrums for tricoplanar facets
         'FP' may not print the nearest vertex for coplanar points
         Use option 'Q11' when adding points after qh_triangulate()
 
 ------------
 qhull 3.0 2001/02/11
 
 Changes to distribution
  - added qconvex, qdelaunay, qhalf, and qvoronoi
  - added qhull-interface.cpp on calling Qhull from C++ [K. Erleben]
  - renamed to qhull3.0/.
  - added eg/, html/, and src/ directories
 
 Changes to URLs
  - MathLab6 qhull: convhulln, delaunayn, griddatan, tsearchn, vororoin [Z. You]
  - Wolfram Research wrote a Mathematica interface for qdelaunay [Hinton]
  - Geomview moved from www.geom.umn.edu to www.geomview.org [M. Phillips}
  - added URLs for tcsh and cygwin to README.txt
 
 Changes to documentation
  - reorganized table of contents and renamed qh-man.htm to index.htm
  - wrote program documentation, dropped qh-opt.htm and qh-optv.htm
  - added quick reference, qh-quick.htm
  - reorganized qh-rbox.htm and renamed it to rbox.htm
  - split up qh-c.htm for quick navigation
 
 Corrections to code
  - fixed type of arg for error message in qh_initqhull_globals [N. Max]
  - fixed incorrect initialization of qh MINdenom_1 for scalepoints
  - fixed drop dim for 'H Qbk:0Bk:0'.  Added qh.feasible_point to qh_projectinput
  - qh_WARNnarrow is angle between facet normals.  Negate for warning message.
  -   statistics for Wangle/etc. concerns facet normals.  Reworded [E. Voth]
  - fixed error message for 'FC v'
  - report cospherical points if Delaunay and error in qh_scalelast()
 
 Changes to code
  - turn on Pg if (QVn or QGn) and not (Qg or PG)
  - turn on Qc if format option 'Fc', 'FP', or 'Gp' (removes warning)
  - removed last good facet unless ONLYgood ('Qg').
  - added count of non-simplicial or merged facets to 'FS'
  - added count of non-simplicial facets to 's' (OK if #vertices==dim)
  - added Znonsimplicial and Znowsimplicial to 'Ts'
  - allow Mathematica output of dual polytope for halfspace intersection
  - added qh_checkflags to globals.c for multiple front ends
  - qh_initqhull_globals sets qh.MERGING if qh.MERGEexact
  - removed hashentryT.  It is no longer used.
 
 Changes to prompts and warnings
  - reorganized prompts
  - reorganized synopsis for rbox.c
  - print warning if 'Fc' or 'FP' with 'd QJ'.  Coincident points are unlikely.
  - ignore warning if options 'v i Pp'.  qvoronoi users may need Delaunay tri.
  - reworded warning if 'Pg' and 'QVn' is not a vertex.
  - reworded warning for 'Qx Tv', qh_check_points() in poly2.c
  - if 'Pp', turn off warning for 'Qbb' without 'd' or 'v'
  - in qh_printsummary() of Voronoi and Delaunay, distinguish QVn, QGn, Pdn, PDn
 
 Changes to FAQ
  - added FAQ item for nearly flat Delaunay triangles [Z. You]
  - added FAQ item for area and volume [R. Konatham]
  - added FAQ item for Voronoi diagram of a square [J. Yong]
  - edited FAQ item on point location in Delaunay triangles [Z. You]
  - added FAQ item on nearly flat Delaunay triangles [Dehghani]
  - added FAQ item about halfspace intersection [V. Tyberghein]
  - added FAQ item for missing ridges [M. Schmidt]
  - added FAQ item about qh_call_qhull [R. Snyder]
  - added FAQ item about memory statistics [Masi]
  - added FAQ item on meshing non-convex objects
  - added FAQ item on MATLAB and Mathematica interface
 
 ------------
 qhull 2.6 1999/04/19
  - fixed memory overwrite (no effect) in qh_initstatistics() [K. Ford]
  - added zdoc11 to qh-stat.h#ZZdef for !qh_KEEPstatistics [K. Ford]
  - enhanced qh_initqhull_globals() test of qh_RANDOMint and qh_RANDOMmax
  - added debugging option to always return qh_RANDOMmax from qh_rand()
  - fixed option 'Qr', qh_initialvertices(), to allow a broken qh_rand()
    fixed option 'Qr', qh_nextfurthest(), to allow narrow hulls
      Option 'Qr' simulates the random incremental algorithm for convex hulls
  - added note that qh.num_outside includes coplanar points for narrow hulls
  - added FAQ items for triangles/ridges of 3-d Delaunay triangulation[P. Kumar]
  - added FAQ item about on-line processing with the Qhull library [O. Skare]
  - changed name of option 'Error-roundoff' to 'Distance-roundoff'
 
 ------------
 qhull 2.6 1998/12/30
  - for the unbounded rays of the Voronoi diagram, use a large box [Schmidt]
      e.g., 'rbox P4,4,4 P4,2,4 P2,4,4 P4,4,2 10 | qhull v Fv' fails for point 0
      while 'rbox P4,4,4 P4,2,4 P2,4,4 P4,4,2 10 c G5 | qhull v Fv' is OK.
  - fixed qh_new_qhull() to use outfile/errfile instead of stdout/stderr [Ford]
  - clarified COPYING.txt for use in other programs [Archer]
  - improved qh_readpoints() error message for incorrect point count.
  - added FAQ item for closest triangle to a point [Sminchisescu & Heijting]
  - added FAQ item for is a point outside of a facet [Beardsley]
  - added FAQ item for visiting facets of the Delaunay triangulation [Heijting]
  - added link to Erickson's Computational Geometry Software
  - added link to Sharman's HTML version of the comp.graphics.algorithms FAQ
  - added link to Owen's Meshing Research Corner
  - added note to 'd' about quadratic size of 'rbox 100 l | qhull d' [Kumar]
  - added 'about a point' to mentions of halfspace intersection
  - added request to qh-code.htm to compute largest empty circle [Hase]
  - the DOS window in Windows NT is better than the DOS window in Windows 95
  - removed obsolete qh_findfacet() from qh-c.htm [Sminchisescu]
 
 ------------
 qhull 2.6 1998/8/12
  new and modified features
  - rbox: added option Mn,m,r to generate a rotated lattice or mesh
  - rbox: report error if more than one of 'l', 'x', 'L', 's', or 'M'
 
  Qhull library changes
  - added qh_new_qhull() to user.c for calling qhull() from a program [D. Zwick]
    rewrote user_eg.c to use qh_new_qhull().  Added qh_QHpointer example.
  - added qh_CLOCKtype 2 in user.h to call times() for CPU time [B. Hemkemeier]
  - renamed set.c/set.h to avoid conflict with STL's set.h [G. van den Bergen]
    can also use '#include <qhull/qhull_a.h>' for Qhull library
 
  fixed errors
  - fixed qh_init_B() to call qh_initqhull_mem() once only [D. Zwick]
    This only effects Qhull library users of qh_QHpointer.
  - fixed qh_mergecycle_all() to check for redundant vertices [J. Nagle]
    e.g., 'rbox M3,4 64 | qhull Qc' should report 8 vertices & 48 coplanars
  - fixed gmcoord initialization in qh_setfacetplane() for qh.RANDOMdist
  - turn off qh.RANDOMdist during qh_printfacetheader()
  - fixed error messages for unknown option flags
 
  documentation changes
  - added note to FAQ on the Voronoi diagram of cospherical points [H. Hase]
  - added note to 'Qu' on furthest-site Delaunay triangulation via convex hull
  - added note to 'QJ' about coplanar points on the convex hull of the input
  - added note that 'o' and 'FN' list Voronoi regions in site id order [Arvind]
  - added links to Fukuda's introduction to convex hulls, etc. [H. Hase]
  - added .c and .h source files to web distribution and qh-c.htm [J. Sands]
  - documented qh_ZEROdelaunay.  Delaunay and Voronoi diagrams do not include
    facets that are coplanar with the convex hull of the input sites.
 
  modified code
  - replaced computed minnorm in qh_sethyperplane_det with distance test
  - removed 'qh rand_seed' since random number generator is independent of qhull
  - dropt 'qhull-PPC.sit.bin' from the distribution (out-of-date) [M. Harris]
 
 ------------
 qhull 2.5 1998/5/4
 
  fixed errors
  - removed zero-area Delaunay triangles and furthest-site triangles [I. Beichl]
    Zero-area triangles occur for points coplanar with the input's convex hull.
  - replaced qh.MINnorm with computed minnorm in qh_sethyperplane_det [J. Nagle]
    qh.MINnorm was incorrect for the convex hull of the "teapot" example.
    Qhull runs 0-20% slower in 3-d and 4-d.
  - allow 'Qg' with furthest-site Delaunay triangulation (may be faster)
  - removed extra space in definition of FOREACHmerge_() for Alpha cc [R. LeRoy]
  - fixed innerouter type in qh_printvdiagram2 [does not effect code, R. Adams]
 
  documentation changes
  - to browse qh-c.htm, set MIME type of .c and .h files to text/html
  - added example of 3-d Delaunay triangulation to q-faq.htm
  - added Delaunay and Voronoi examples to qh-optv.htm
 
 ------------
 qhull 2.5 1998/2/4
  - added option 'v Fi' for separating hyperplanes of bounded Voronoi regions
  - added option 'v Fo' for separating hyperplanes of unbounded Voronoi regions
  - option 'Pp' turns off the warning, "initial hull is narrow"
  - fixed partial, 3-d Voronoi diagrams (i.e., 'v Fv QVn Tc')
  - fixed missing statistics in qh_allstat* [T. Johnson]
  - rearranged qh_printvdiagram.  Use qh_eachvoronoi to iterate Voronoi ridges.
  - added qh_check_points to qh-math.c
 
 qhull 2.5 1998/1/28
  - added option 'Fv' to print the Voronoi diagram
  - added rbox option 'x' to generate random points in a simplex
  - added rbox option 'y' to generate a simplex and random points
  - added rbox option 'On' to offset the output
  - add unpacking instructions to README.txt
  - updated discussion of forced output, 'Po'
  - sorted the options alphabetically
  - removed __STDC__ check from libqhull.h for VisualC++
  - moved qh_markvoronoi from qh_printvoronoi and cleared facet->seen flags
  - added facet->seen2 flag for 'Fv'
 
 qhull 2.5 1998/1/16
  - fixed initialization of qh.last_low on restart of 'd QJ'
  - renamed qh_JOGGLEmax to qh_JOGGLEmaxincrease
  - updated URL for Fukuda's cdd program
 
 qhull 2.5 1998/1/12
 
 New or modified features
  - added option 'Fx' to print vertices by point id [G. Harris, T. McClendon]
      in 2-d, the vertices are printed in counter-clockwise order
      for Delaunay triangl., 'Fx' lists the extreme points of the input sites
  - added option 'QJ' to randomly joggle input instead of merging facets
  - added option 'TO file' to output results to a file.  Needed for Windows95.
  - added option 'TRn' to rerun Qhull n times. Use to collect joggle statistics
 
 Corrections
  - fixed 2-d facet orientation for 'i' and 'o' outputs
  - for Mathematica 2.2 ('m') changed %10.8g to %16.8f [A. Zhaxybayev]
  - fixed incorrect warning for 'QV0 Qg' in qh_initbuild [B. Wythoff]
  - fixed unaccessible statistic if !qh_KEEPstatistics for Wnewvertexmax
  - fixed overestimate of qh ONEmerge for point sets outside of
      first quadrant and far from the origin
  - fixed overestimate of 'Qbb' for point sets far from the origin
  - fixed potential overestimate of qh DISTround under 'Qbb'
  - fixed 'p' printing coplanar points of unselected facets
  - fixed 'Ft' printing centrums unnecessarily in 2-d
 
 Changes to documentation
  - wrote internal design documentation (qh-c.htm)
  - started frequently asked questions (qh-faq.htm)
  - added a section on joggled input to qh-impre.htm
  -   added joggle example to qh-eg.htm (eg.15.joggle)
  -   changed q_eg to use 'QJ' instead of 'Q0' were appropriate
  - added an example to each of the main options
  - added examples to rbox.htm
  - added examples to the synopsis
  - added a reference to Mucke, et al ['96], Fast randomized point location ...
  - added code for printing Delaunay triangles to qh-code.htm [A. Tsui]
  - options 'Pdk' and 'PDk' do not drop on equality
 
 Improvements to the code
  - reviewed warning messages for Qhull options in qh_initflags
  - added warning to 's' if premature exit from 'TCn' or 'TVn'
  - 's' prints max distance above/below only if qh.MERGING
  - reduced maxoutside in qh_check_bestdist/qh_check_points for 'Rn'
  - in post-merging, rebuild centrums of large facets that become small
  - lowered cutoff for coplanar facets for ischeckmax/qh_findbest
  - removed qh_check_maxout for 'Wn Q0'
  - reset tracing after 'TPn' adds point in 4-d and higher
 
 Changes for the Qhull library
  - changed qh_setdelaunay to call qh_scalelast if used with 'Qbb' or 'QJ'
      Delaunay callers to qh_findbestfacet, qh_addpoint, or qh_findfacet_all
      should always use qh_setdelaunay as in user_eg.c
  - defined qh.outside_err to check points against a given epsilon [E. Voth]
  - added header to user_eg.c to avoid its incorporation into qhull [C. Begnis]
  - added qh_nearcoplanar() calls to user_eg.c
      only needed if use 'QJ'
  - expanded __STDC__ warning message in libqhull.h [C. Begnis]
  - renamed qh maxmaxcoord to qh MAXabs_coord
  - replaced qh MAXlowcoord with qh MAXabs_coord
  - random seed ('QR-n') is reset in qh_initqhull_globals after testing
  - replaced 'FO' options "_max-coord/_min-coord" with "_max-width"/qh.MAXwidth
 
 Other changes to Qhull functions
  - report error for !bestfacet in qh_findbest (it shouldn't happen) [H. Meuret]
  - set newbest in qh_findbest only if bestfacet updated
  - renamed facet parameter for qh_findbest
  - added maxdist argument to qh_checkpoint
  - moved 'FO' output after qh_partitionall
  - separated qh_initbuild from qh_qhull
  -   reinitialize globals modified by qh_buildhull
  -   moved initialization of qh.GOODvertexp & qh.GOODpointp to qh_initbuild
  - separated qh_nearcoplanar from qh_check_maxout
  - separated qh_geomplanes from qh_printfacet2geom, etc.
  - separated qh_freebuild from qh_freeqhull
  - separated qh_outerinner from io.c to return outer and inner planes
  - separated qh_distround and qh_detroundoff from qh_maxmin
 
 
 ------------
 qhull 2.4 97/4/2
 
 New or modified features
  - made 'C-0' and 'Qx' default options.  Use 'Q0' to not handle roundoff errors
  - removed point-at-infinity from Delaunay/Voronoi.
      you no longer need to use 'Qu PDk'
  - added 'Qz' to add a point-at-infinity to Delaunay and Voronoi constructions
  - added published version of qhull article in ACM Trans Math Software
  - ported qhull to Windows95 under Visual C++ and Borland C++
  - added 'Ft' for triangulation by adding the centrums of non-simplicial facets
  - added 'Gt' to display 3-d Delaunay triangulations with a transparent hull
  - changed definition of coplanar point in output to qh min_vertex (see 'Qc')
      it was qh MAXcoplanar ('Un') [could make vertices non-coplanar]
  - automatically set 'Qi' for options 'd Qc' and 'v Qc'.
  - reworded summary ('s') for Delaunay/Voronoi/halfspace.
      use 'Fs' and 'FS' for summary statistics.
  - for summary 's' of Delaunay/Voronoi, display number of coplanars for facets
      if none, display total number of coplanars (i.e., non-vertices)
  - input comment is first non-numeric text (previously limited to header)
  - added input warning if use 'Qbb' without 'd' or 'v'
  - 'Q3' can not be followed with a numeric option
 
 Corrections
  - fixed qh_partitioncoplanar() to not drop interior points if 'Qi' is used
  - fixed 'FP d' to report distance in point set instead of paraboloid
  - fixed qh_findbest() to search all coplanar facets for qh_check_maxout()
 
 Changes to documentation
  - added example eg.17f.delaunay.3 to show a triangulation of cospherical sites
  - split up qh-opt.htm into multiple pieces
  - split off qh-code.htm for Qhull code
  - renamed .html files to .htm for Windows95
  - rewrote qh-optv.htm on Delaunay triangulation and Voronoi vertices
  - added 'man' pages qhull.txt and rbox.txt.  These list all the options
  - removed 'txt' versions of html files
  - added note to 'PDk' about avoiding a 'd' option immediately after a float
  - under option 'd', display the triangulation with 'GrD3', not 'GnrD3'
 
 Changes to the Qhull library
  - added 'format' argument to qh_printfacetNvertex_nonsimplicial() in io.c
  - removed C++ type errors [J. Stern, S. Marino]
  -  created SETelemt, SETfirstt, etc. for specifying data types.
  -  use SETelem,etc. for assignments.
  -  changed setT.maxsize to 'int' to prevent type conversion warnings
  -  changed FOREACH.. to a comma expression for better code and less warning
  -  changed qh.vertex_visit and .visit_id to unsigned int to prevent warnings
  - changed clock() to qh_CPUclock (user.h)
  - qh_init_B() and qh_readpoints() do not set qh.ATinfinity for Delaunay tri.
  - qh_setvoronoi_all() sets upper Delaunay facets if qh.UPPERdelaunay is set
  - qh_nearvertex() returns distance in dim-1 for qh.DELAUNAY
  - removed MSDOS path from qhull_command.  Spaces in Win95 tripped qh_setflags
  - removed memory.h from qhull_a.h.  memset,etc. should be in strings.h
  - split qh_prompt into pieces for Visual C++
  - added note to qh_addpoint that coordinates can not be deallocated
  - added Baker '89 to constrained Delaunay diagrams under Enhancements
     please let me know if you try this
  - added request for unbounded Voronoi rays to Enhancements
     please let me know if you try this
 
 ------------
 qhull V2.3 96/6/5
  - fixed total area of Delaunay triangulation. [A. Enge]
       It should ignore facets on the upper-envelope.
  - if 'd Qu FA', the total area is summed over the upper-Delaunay triangles
  - fixed sign of area for Delaunay triangulations.
  - fixed cdd input format for Delaunay triangulation. [A. Enge]
  - for cdd input, allow feasible point for halfspaces.
  - warning if cdd output format for centrums, halfspace intersections, or OFF.
  - print '0' for area ('Fa') if area is not computed for a facet
  - option 'QR-n' sets random number seed to n without rotating input
  - fixed qh_findbest() to retest coplanar and flipped facets after a restart
  - for 'd Qu Ts' collects angle statistics for upper Delaunay facets
 
  Changes to the Qhull library
  - expanded user_eg.c for incremental constructions and Delaunay triangulation
  - added discussion of incremental construction to qh_man.html#library
  - WARNING: The default value of qh ATinfinity was changed from True to False.
             A new flag, qh UPPERdelaunay, was defined for 'Qu'.
          Please set qh ATinfinity if you explicitly add the point "at-infinity"
          Please set qh ATinfinity if you explicitly call qh_projectinput.
          Please set qh UPPERdelaunay if you explicitly cleared qh ATinfinity.
          Other users do not need to change their code.
    Now you can build a Delaunay triangulation without creating a point
    "at-infinity".  This removes a potential, hard-to-understand error.
    qh_readpoints sets qh ATinfinity for options 'd' or 'v' without 'Qu'.
    qh_initB sets qh ATinfinity for qh PROJECTdelaunay w/o qh UPPERdelaunay.
    qh_projectinput adds a point "at-infinity" only if qh ATinfinity is set.
  - added qh_setdelaunay to geom2.c to project points to paraboloid
  - added qh_findbestfacet() to poly2.c to replace qh_findfacet()
  - removed procedure qh_findfacet().  It does not always work.
  - removed NULL option for facet in qh_addpoint().  It does not always work.
  - added noupper parameter to qh_findbest.
  - added search of upperdelaunay facets to qh_findbest()
  - allowed qh_findbest() to start with a flipped or upperdelaunay facet
  - removed qh_nonupper() -- it is no longer needed
  - allow space at end of options
  - fixed qh_projectinput for furthest-site Delaunay (qh PROJECTdelaunay 'd Qu')
  - added voids to procedure declarations with empty parameter lists
 
 ------------
 qhull V2.3 96/3/25
  - fixed missing qh_check_maxout when coplanar points and no merged facets.
  - fixed qh_freeqhull/allmem (e.g., if qh_NOmem) [only custom code] [E. Voth]
  - fixed qh_freeqhull to free qh interior_point [E. Voth]
  - fixed main() to free all of memory if qh_NOmem.  Include "mem.h" [E. Voth]
  - reset f.newcycle link in qh_mergecycle_all [E. Voth]
  - fixed false error if 'Tc', coplanar points, and a narrow hull
  - turn off 'Rn' when computing statistics, checking code, or tracing code
  - removed ={0} from global.c and stat.c to reduce compiler warnings
  - changed Makefile dependences to $(HFILES) for all but unix.o, set.o, mem.o
  - pulled out qh_printpointid and reordered qh_pointid [E. Voth]
  - removed some compiler warnings
  - moved 'FO' print of options to just before qh_buildhull
  - changed 'FO' to list difference from -1 for _narrow-hull
 
 ------------
 qhull V2.2 96/2/15
  - detect narrow initial hulls (cosine of min angle < qh_MAXnarrow in user.h).
    Write warning if cosine < qh_WARNnarrow in user.h.  If narrow (qh NARROWhull),
    partition coplanar points as outside points and delay coplanar test to end.
    Needed for  RBOX 1000 L100000 s G1e-6 t995127886 | QHULL Tv
    See 'limitations' in qh-impre.html for further discussion.
  - corrected some confusions between 'FV' and 'Fv' in qh-opt.html
  - fixed initialization error for small Voronoi diagrams (e.g., [0,0], [1,0], [0,1]) [J. Velez]
   - fixed bad return from qh_mindiff in geom2.c
  - for initial hull, first process facet with furthest outside point (qh_furthestnext)
  - added facet->notfurthest flag for recomputing furthest point
  - added check for __STDC__ (needs ANSI C) [E. Voth]
  - reduced warning messages from [E. Voth].  e[1] in setT still reports a warning.
  - added a cube to the discussion of option 'v' (Voronoi) in qh-opt.html [J. Velez]
  - added notes about adjacent vertices to "Calling Qhull" in qh-man.html [R. Lewis & J. Velez]
  - added note about 'lines closer' when viewing 3-d Delaunay triangulations [P. Kallberg]
  - added option 'Q9' to always process furthest of furthest outside points.
  - removed option 'Pp' from q_eg and qh-eg.html.
 
 ------------
 qhull V2.2 95/12/28
  - added option 'Qbb' to scale the last coordinate to [0,m] (max prev coord).
    This reduces roundoff errors for Delaunay triangulations with integer coordinates.
  - changed option 'Qu d' to print out the furthest-site Delaunay triangulation
    Use options 'Qu d PD2' to compute the normal 2-d Delaunay triangulation without
    the point at infinity.
  - added notes to the documentation of option 'd'
  - added notes to limitations of how Qhull handles imprecision
  - added warning if options 'FP', 'Fc', or 'Gp' without option 'Qc' or 'Qi'
  - added note to options 'PDk:n' and 'Pdk:n' that closest facet is returned if none match
  - added check that 'Qbk' and 'QBk' does not invert paraboloid for 'd'
  - added notes that qh_findfacet and qh_addpoint require lifted points for Delaunay triangulations
  - fixed 'rbox s 5000 W1e-13 D2 | qhull d Qcu C-0 Qbb'
  - fixed option 'QbB' (qh SCALEpoints was not set)
  - fixed minor confusion between 'Gc' (print centrums) and 'Gp' (print points)
  - rewrote qh_findbestnew for upper convex hull, Delaunay facets
  - changed option name for 'Gp' from 'Gcoplanar' to 'Gpoints'
  - changed "nearest" facet for 'Pdk' to threshold - normal
  - reworked qh GOODclosest for 'Qg'
  - added note that 'Qg' does not always work
  - recorded option 'C-0' as "_zero-merge" in option 'FO'
  - refined qh DISTround in qh_maxmin/geom2.c for Delaunay triangulations
 
 qhull V2.2 95/12/4
  - Version 2.2 fixes an important bug in computing Delaunay triangulations
    and convex hulls with edges sharper than ninety degrees.  The problem
    occurs when processing a point at a sharp edge.  A directed search can
    not be used for partitioning because one side may hide facets from the
    other side.  The new lens-shaped distribution for rbox demonstrates the
    problem.  For example, 'rbox 100 L3 G0.5 s | qhull Tv' fails for Version 2.1.
    O. Schramm found the bug when computing the Delaunay triangulation of points
    near an outside edge.
 
    I rewrote qh_findbest and related functions.  Qh_findbest
    uses an exhaustive test for sharp edges (qh_findbest_sharp).
    Qh_findbest avoids the upper convex hull of Delaunay triangulations.
 
    Options 'd' and 'v' no longer assign coplanar points to the upper convex hull.
 
    Qh_check_maxout tests near-inside points.  It ignores fully inside points.
    When done, it removes near-inside points from the coplanar sets.
 
    If you use qh_addpoint or qh_findbest, please review the function headers.
    They do not work for lens-shaped hulls for arbitrary facets.  They do work for
    Delaunay triangulations.
 
  Changes to options for V2.2
  - added 'Qu' for computing the furthest-site Delaunay triangulation (upper hull)
    and furthest-site Voronoi vertices.
  - added 'FP' to print nearest vertex for coplanar points
  - added coplanar count to 'Fs' and 's'
  - added number of similar points to summary for Delaunay/Voronoi
  - Option 'Qc' is no longer necessary when merging.
  - 'o' format for Voronoi vertices ('v') generates "0" lines for similar points
  - 'QRn' for Delaunay ('d' or 'v') now rotates about the Z axis (see qh_init_B).
    Otherwise Qhull does not identify the upper hull
  - removed option 'Qa' for "all points outside".  In V2.1 it was automatically
    set for 'd'.  Even though it was a bad idea, it revealed the above bug.
  - for option list ('FO'), added version, values for one-merge, maxpos, maxneg,
    and near-inside, and flags for zero-centrum
  - optimized 'C-0' and 'Qx'.  These options ("zero-centrum") test vertices
    instead of centrums for adjacent simplicial facets.
  - if 'Tv', report number of points that are not verified due to qh_findbest
  - Option 'Q8' ignores near-inside points.
 
  rbox 95/12/3
  - added lens distribution ('Ln')  It may be used with 's', 'r', 'Wn', and 'Gn'
  - removed default point count except for the test case, 'Dn'
  - divided main() of rbox.c into sections
 
  Documentation changes for V2.2
  - added examples for lens distribution and furthest-site Delaunay triangulation
    and renumbered the examples for q_eg
  - described facet orientation in 'data structure' section [P. Soikkonen]
  - added notes to qh-man.html/"What to do if something goes wrong"
  - added note about using 'Tv' to verify the results [O. Schramm]
  - expanded definition of f_r in Performance section [S. Grundmann]
  - noted that Geomview display of a Voronoi diagram adds extra edges
    for unbounded Voronoi cells
  - rewrote error "convexity constraints may be too strong" [D. Newland]
  - added limitations section to "Imprecision in Qhull"
  - added note about zero-area facets to 'Imprecise convex hulls' in qh-impre.html
  - added note to 'Qi' that it does not retain coplanar points
  - added note that option 'Q5' may be used if outer planes are not needed
  - added note to README.txt about Irix 5.1 [C. Goudeseune]
  - added code fragment for visiting Voronoi vertices to "Calling Qhull" [M. Downes]
  - added note about qh_addpoint() to "Calling Qhull" [M. Downes]
 
  Errors fixed for V2.2
  - use qh_sethyperplane_gauss if 3-d or 4-d norm is less than qh MINnorm
  - count Zcentrumtests if qh_NOstat
  - reversed sign convention for qh_sethyperplane_gauss
    it was opposite to qh_sethyperplane_det
    this effects qh_determinant and qh_detsimplex
  - fixed error in qh_findgood_all with multiple restrictions, e.g., 'QVn Pdk'
  - fixed call to qh_clearcenters for qh_produce_output
  - in qh_errexit, report p0 if last furthest point
 
  Changes for users of the Qhull library
  - user code needs to define qh_version (see user_eg.c)
  - merged initialization code into qh_init_A and qh_init_B [M. Mazzario]
    old code works as before.
    qh_initflags also sets qh qhull_command for qh_initthresholds
    redid initialization for user_eg.c
  - simplified user_eg.c.  It computes the convex hull of a cube.
  - added qh_setvoronoi_all in poly2.c to compute Voronoi centers
    added related note to call_qhull
  - added qh_findfacet to use in place of qh_findbest
  - added qh_nearvertex to return nearest vertex in facet to point
  - redid notes on multiple, concurrent calls in call_qhull/user.c
  - changed BoolT to unsigned int (prevent implicit enum conversion warnings)
  - added upperdelaunay to facetT.  It indicates a facet of the upper convex hull.
  - converted qhull-PPC.sit for CodeWarrior 7
 
  Code changes for V2.2
  - simplified calls to setjmp() for Cray J916 [Salazar & Velez]
  - replaced fprintf(fp,string) with fputs in io.c
  - 'qh num_coplanar' removed (too expensive and not used).
  - added numcoplanars to qh_countfacets()
  - added min norm to qh_normalize2().  qh_normalize() wasn't changed
  - removed type casts from qh_point and qh_pointid [Salazar & Velez]
  - account for roundoff error in detecting upper convex hull (qh ANGLEround).
  - post merging uses qh_findbestnew for partitioning
  - qh_findbestnew for qh_partitioncoplanar goes to best facet
  - 'Qm' always processes points above the upper hull of a Delaunay triangulation
  - GOODvertex initialized with qh_findbestnew instead of qh_findbest
  - for 'v', qh_facetcenter returns furthest-neighbor vertex if 'Qu'
  - added test for qh feasible_point if use 'Fp' and qh_sethalfspace_all
  - reviewed Sugihara's algorithm for topologically robust beneath-beyond
  - on error, report if qhull in post-merging or has completed
  - if tracing, option 'FO' and qhull command always printed
  - added current furthest point ("during p%d") to 'T-1' events
  - added 'TWn' tracing for vertices of new facets (qh_setfacetplane)
  - added 'TWn' tracing for vertices in an output facet (qh_check_maxout)
  - reorganized split between poly/poly2.c and geom/geom2.c
  - reordered object files in Makefile
 
 ------------
 qhull V2.1 95/9/25
  - converted qhull.man to html format, many edits
  - referenced Shewchuk's triangle program and Schneiders' Mesh Generation page
  - added option 'Qa' to force all points outside
      automatically set for "precise" Delaunay or Voronoi [Salazar & Velez]
      it is turned off by merging, 'Wn', 'Qc' or 'Qi'
  - added coplanar points to option 'FN'
  - moved option 'FO' to include default precision options
  - changed default random number generator to qh_rand in geom2.c (user.h)
 
  other code changes
  - fixed option comment Pdrop-facets-dim-less, Qbound-dim-low, QbBound-unit-box
  - defined ptr_intT for converting 64-bit ptrs to 'unsigned long' [D. Bremner]
  - defined setelemT to distinguish actual size from pointers [D. Bremner]
      use either e[...].p or e[...].i (user-level code should use set.h macros)
  - changed %x to %p in format statements for pointers [D. Bremner]
  - added test of REALmax,etc. to qh_maxmin [H. Poulard]
  - added type parameter to qh_memalloc_() macro for type conversion
  - added type conversion to qh_memalloc() calls where missing
  - added type conversion to calls into set.c that return void*
 
  other documentation changes:
  - new URLs for graphics images
  - fixed comment for facetT.neighbors in libqhull.h [P. Soikkonen]
  - changed recommendations for precision errors in qh_printhelp_degenerate()
  -  added recommendation for 'V0' (facet is visible if distance >= 0)
  - added note about 'long double' to user.h [S. Grundmann]
  - added note about zero area Delaunay triangles for the 'v' option
  - added note about locating Delaunay triangles to option 'd' [A. Curtis]
  - added note that coplanar vertices correspond to duplicate points for 'd'
  - added note about option 'd' automatically setting 'PDk' (lower convex hull)
  - added note about precision errors to option 'd' [many users]
  - added note about qh_findbest() to the Qhull library section [L. Lai]
  - 'make install' renames qhull.man to qhull.1 for Unix [M. Phillips]
  - renamed README, etc. to *.txt to match WWW conventions [D. Cervone]
 
 ------------
 qhull V2.1 7/10/95
   - in 2-d, 'v o' lists the vertex at infinity in order [R. Critchlow]
   -   it used to always list the vertex at infinity ("0") first
   - rewrote description of 'v' option (Voronoi vertices and 2-d diagrams)
   - added 'PFn' for printing facets whose area is at least 'n' [D. Holland]
   - prefixed 'Q',etc. to the 'Q',etc. options in the long help prompt
   - fixed references to 'Fv' and 'FV' options under option 'Hn,n,n'
   - updated reference to cdd, <ftp://ifor13.ethz.ch/pub/fukuda/cdd/>
   - in set.c, added some missing type coercions for qhmem.tempstack
 
 qhull V2.1 6/12/95
   - replaced qhull.ps with qhull-2.ps (paper submitted to ACM TOMS)
   - use BUFSIZ for setvbuf for Power Macintosh
   - number of good facets printed if QVn, QGn, Pd, or PD
   - added Makefile for Borland C++ 4.02 with Win32 [D. Zwick]
   - added note to Enhancements section of qhull.1 about constrained
        Delaunay triangulations [T. Rasanen]
 
 qhull V2.1 6/7/95
   - fixed qh_facetarea_simplex() for non-simplicial facets [L. Schramm]
   - fixed cast in qh_point and qh_pointid for 64-bit architectures
   - fixed URL for Amenta's list of computational geometry software
   - fixed cast in qh_meminitbuffers for qhmem.freelists
   - added test for !qh half_space in qh readpoints
   - clarified options for qh_printhelp_singular()
   - discussed non-simplicial facet area under option 'Fa' in qhull.1
 
 qhull V2.1 6/3/95
   - home page for Qhull and new descriptions for the Qhull examples
       http://www.qhull.org
   - changed SIOUX buffering for Power Macintosh.   It runs fast now.
       added a project file for Metrowerk's C
   - note in README about compiling qhull on the PC
 
 qhull V2.1 beta 5/15/95
 
                 ======= main changes ========
   - added halfspace intersection ('Hn,n,n')
   - facet merging is better, especially for high dimensions
   -   added 'Qx' for exact merges of coplanar points and precision faults
   - facet merging is faster, especially for high dimensions.
       e.g., convex hull of the 8-d hypercube is seven times faster
   - added 'F' output formats for printing each aspect of the convex hull
   - format 'Fa' computes facet areas, total area, and total volume
   - format 'FO' writes a descriptive list of selected options to stderr
   - moved all customization options to user.h
   - changed the default precision to 'double' since it's needed for Delaunay.
       using 'float' is faster and takes less space (REALfloat in user.h)
   - option 'Qm' is no longer important for facet merging
   - removed need for 'Qs' by selecting initial simplex with pos. determinants
   - renamed 'Qv' to 'Q7' since virtual memory does not work well for qhull
   - Qhull is available for the Power Mac (no graphical output)
 
                  ====== other new and modified options ===========
   - changed default MINvisible ('Vn') to a multiple of premerge_centrum ('C-n')
   - added 'Un' option to set width of facet for coplanar points.
        This replaces the previous rules for determining coplanar points.
   - changed default MINoutside ('Wn') to twice MINvisible ('Vn')
   - Geomview output adjusts point radii for MINvisible 'Vn'
   - the input format allows the number of points to precede the dimension
   - options 'v' 'd' 'FAn' and 'FMn' record good facets ('Pg')
   - added 'Fd' and 'FD' options for homogeneous coordinates in cdd format
   -   in rbox, added 'h' flag to generate homogeneous coordinates in cdd format
   - option 'PAn' prints out the n facets with the largest area
   - option 'PMn' prints out the n facets with the most merges
   - option 'Po' under tracing ('Tn') no longer tries to write erroneous facets
   - option 'TCn' only prints the old 'visible' facets for 'f'
   - 'TFn' reports intermediate results when post-merging
   -   option 'Ts' with option 'TFn' prints intermediate statistics
   - the message for 'Tv' reports if it is checking outer planes
   - 'Tz' sends stderr output to stdout
   - added 'Q1' to ignore angle when sorting merges (merges are worse)
   - added 'Q2' to not perform merges in independent sets (merges are worse)
   - added 'Q3' to not remove redundant vertices (faster)
   - added 'Q4' to avoid merges of old facets into new facets (does worse)
   - added 'Q5' to skip qh_check_maxout (faster, but less accurate)
   - added 'Q6' to skip pre-merge of concave and coplanar facets
   - added 'Qv' for testing vertex neighbors for convexity (needs merge option)
   - added warning if mix Geomview output with other outputs ('Po' turns off)
   - options 'o v' for 3-d and higher sort the Voronoi vertices by index
 
                 ======= documentation =======
   - rewrote the introduction and precision sections
   - added a section on performance
   - added an example on halfspace intersection
   - installed examples of Qhull in
     <http://www.geom.uiuc.edu/graphics/pix/Special_Topics/Computational_Geometry/>
 
                 ======= Makefile, user.h, and messages =======
   - Makefile calls ./qhull, ./rbox, and prints short prompt for qhull
   - added new statistics, e.g., for buildhull
   - changed default qh_RANDOMtype to RAND_MAX with rand()
   - added comment about numeric overflow to printhelp_singular
   - reorganized the code to improve locality of reference
   - option in mem.h (qh_NOmem) to turn off memory management in qhull
   - option in user.h (qh_NOtrace) to turn off tracing in qhull
   - option in user.h (qh_NOmerge) to turn off merging in qhull.
   -   use this instead of redefining qh_merge_nonconvex in user.c
   - simplified user_eg.c.  See qh_call_qhull() in user.c for the full version
 
                 ======== bug fixes ============
   - fixed error in number of points for 'rbox 100 r' (odd distribution)
   - fixed performance error in qh_degen_redundant_neighbors
   - qh_partitionpoint now sets facet->maxoutside for first outside point
   - fixed performance error in partitioning when merging a large, regular cone
   - removed memory leak in qh_appendmergeset
   - removed double free of qh line under errors in qh_readinput()
   - forcing output on error ('Po') fixed for options 'n' 'o' 'i' 's'
   - fixed optimization error on HP machines [fprintf(... *p++)]
 
                 ======== changes to libqhull.h for user code =======
   - qh_collectstatistics and qh_printstatistics removed from libqhull.h.
       should use qh_printallstatistics instead
   - qh_findbest uses boolT for newfacets
   - added qh_findbestnew for non-simplicial facets.  qh_findbest is
     too slow in this case since it needs to look at many nearly coplanar
     facets.
   - renamed qh_voronoi/qh_centrum to qh_ASvoronoi, qh_AScentrum
   - changed facet->id to 32-bits, added new flags for merging
   - added facet->f for facet pointers while merging and for facet area
   - added dfacet/dvertex for printing facets/vertices while debugging
   - added qh_produce_output and qh_printsummary
 
                 ======== changes to code ==========
   - moved qh_setfacetplane from qh_makenewfacets to qh_makenewplanes
   - added qh_setfree2, qh_setcompact, and qh_setduplicate to set.c
   - qh_findgooddist returns list of visible facets instead of setting global
   - in qh_check_maxout, inside points may be added to coplanar list.
   - qh_findbestnew used for qh_partitionall.  It is faster.
   - in qh_findbest, changed searchdist to MINvisible+max_outside+DISTround.
       MINvisible is the default MAXcoplanar.
   - cleaned up list management via qh_resetlists
   - uses facet->dupridge to indicate duplicated ridges instead of ->seen
   - qh_buildtracing records CPU time relative to qh hulltime instead of 0
 
                 ========== changes to merging =======
   - many performance improvements, especially in high-d.
   - when merging, qh_findbest and qh_findbestnew stops search at qh_DISToutside
   - vertex neighbors delayed until first merge
   - post merges reported every TFn/2 merges
   - vertex merging turned off in 7-d and higher (lots of work, no benefit).
       vertex merging moved to qh_qhull_postmerging in 6-d.
   - replaced qh min_vertex with MAXcoplanar for determining coplanarity
   - pick closest facets to merge in duplicate ridge instead of flip/flip
       (see qh_matchduplicates in poly2.c)
   - optimize merge of simplex into a facet
   - optimize merge of a "samecycle" of facets into a coplanar horizon facet
   - cleaned up qh_forcedmerges/qh_flippedmerges and removed facet->newmerge
   - rewrote qh_merge_degenredundant with separate queue
   - qh_facetdegen replaced by facet->degenredun
   - flipped neighbors no longer merged in preference to flip/non-flip pairs
   - removed angle argument from qh_merge_degenredundant and qh_mergefacet
        only used for tracing
   - getmergeset_initial had extra test of neighbor->simplicial
   - ridge->nonconvex is now set on only one ridge between non-convex facets
   - moved centrum deletion to qh_updatetested
   - qh_isnewmerge(facet) changed to facet->newmerge (removed NEWmerges)
   - qh_findbestneighbor reports correct distance even if testcentrum
   - added hull_dim factor to qh_BESTcentrum
   - removed horizon preference in qh_merge_nonconvex (qh AVOIDold)
   - facet->keepcentrum if qh WIDEfacet or qh_MAXnewcentrum extra vertices
 
 ------------
 qhull V2.02 1/25/95
   - rbox 'z' prints integer coordinates, use 'Bn' to change range
   - fixed rare bug in qh_check_maxout when qh_bestfacet returns NULL
   - fixed performance bug in findbestneighbor, should be + BESTnonconvex
   - renamed 'notgood' flag in 'f' option to 'notG' flag (caused confusion)
   - changed qh.hulltime to (unsigned) to prevent negative CPU times
   - added random perturbations to qh_getangle under the 'Rn' option
   - reviewed the documentation and enhancement list
   - added discussion of how to intersect halfspaces using qhull
   - replaced expression that caused incorrect code under an old version of gcc
   - added buffer after qh.errexit in case 'jmp_buf' has the wrong size
   - rewrote qh_printhelp_singular for lower-dimensional inputs
   - rewrote qh_printhelp_degenerate
   - added options for qh_RANDOMint in qhull_a.h
   - changed time format for 'TFn' to %02d
 
 ------------
 qhull V2.01 6/20/94
   - fixed bug in qh_matchnewfacets that occured when memory alignment makes
     facet->neighbors larger than necessary.
   - fixed bug in computing worst-case simplicial merge of angle coplanar
     facets (ONEmerge).  This decreases (...x) in printsummary.
 
 qhull V2.01 6/17/94
   - added recommendation for 'Qcm' to documentation and help prompts
   - added an input warning to qh_check_points ('Tv') if coplanars and no 'Qc'
   - qh_partitionpoint: always counts coplanar partitions (Zcoplanarpart)
   - rewrote qh_printhelp_degenerate to emphasize option 'C-0'
   - For Geomview output, roundoff is not needed when printing the inner and
     outer planes.  This improves Geomview output for the 'Rn' option.
   - For Geomview output without coplanar points or vertices, qh_GEOMepislon
     is not needed.  This removes the edge gap when displaying a Voronoi cell.
   - For Geomview output 'Gp', direct vertices to the interior point
     instead of the arithmetic center of the displayed vertices.
 
 qhull V2.01 6/11/94
   - if pre-merge, 'Qf' is automatically set.  Otherwise an outside point may
         be dropt by qh_findbest().  This slows down partitioning.
   - always use 'Qc' if merging and all facet->maxoutside's must be right.
         Otherwise distributions with many coplanar points may occassionally
         miss a coplanar point for a facet.  This is because qh_findbest, when
         called by qh_check_maxout, can become stuck at a local maximum if
         the search is started at an arbitrary facet.  With 'Qc', the search
         is started from a coplanar facet.  For example,
                 rbox 1000 W8e-6 t | qhull C-0 Tv
         will (rarely) report that a facet->minoutside is incorrect
   - option 'Pp' turns off "Verifying" message for 'Tv'
   - added qh_copynonconvex to qh_renameridgevertex (fixes rare error)
   - 'rbox tn' sets random seed to n
   - 'rbox t' reports random seed in comment line
   - qh_errexit reports rbox_command | qhull_command and 'QR' random seed
   - added additional tracing to bestdist and setfacetplane
   - in qh_checkconvex, need to test coplanar against 0 instead of -DISTround
   - in qh_checkconvex, always test centrums if merging.  The opposite
     vertex of a simplicial facet may be coplanar since a vertex of
     a simplicial facet may be above the facet's hyperplane.
   - fixed error handling in qh_checkconvex when merging
   - in qh_printsummary, one merge ratio not printed if less than 'Wn'
   - documented that 'Tv' verifies all facet->maxoutside
 
 qhull V2.01 6/2/94
   - 's' prints summary to stderr
   - multiple output formats printed in order to stdout
   - added statistic for worst-case distance for merging simplicial facets
         can not hope for a better "max distance above/below facet"
         print factor for "max distance.."/"merge simplicial" in printsummary
   - fixed error in scaling input with min/max reversed ('Qb0:1B0:-1')
   - fixed error in scaling if project & Delaunay & scale ('d Qb0:0B1:0b2:0')
   - user_eg.c: qh_delpoint removed since it does not always work
   - user_eg.c now works for either convex hull or Delaunay triangulation
   - added PROJECTdelaunay for Delaunay triangulations and Voronoi diagrams
         with libqhull.a and user_eg.c
   - user_eg.c: if project or scale input, need to copy points
   - user_eg.c: default just defines main, added fprintf's for qh_errprint etc.
   - qh_gausselim: a 0 pivot no longer zeros the rest of the array,
           need the remaining elements for area computation
   - qh_qhull: restore cos_max, centrum_radius at end of POSTmerging
   - qh_checkflipped with !allerror is >=0.0 instead of >0.0
   - removed -Wall from gcc due to unnecesssary "warning: implicit declaration"
   - renamed 'new' variables and fields to allow compilation by g++
   - added README notes on C++, and "size isn't known"
   - updated manual on 'Qg' with coplanar facets and no merging ('rbox c D7')
       'Qg Pg' and 'Pg' produce different results because of precision problems
 
 ------------
 Converting from qhull 1.01 to qhull 2.00
   - 'qhull An' is now 'qhull Wn'
         option 'Wn Po' is faster but it doesn't check coplanars
   - 'qhull g' is now 'qhull G', and the output formats are different
   - 'qhull c' is now 'qhull Tc'
   - 'qhull f' is now 'qhull Qf'
   - 'qhull o' is now 'qhull Po'
   - 'qhull b' is now always done
   - qhull and rbox now use floats, change REALfloat in libqhull.h for doubles
   - qhull 2.00 fixes several initialization errors and performanace errors
         e.g., "singular input" on data with lots of 0 coordinates
   - 'rbox b' is now 'rbox c G0.48'
   - all rbox distributions are now scaled to a 0.5 box (use 'Bn' to change)
   - rbox now adds a comment line.  This may be removed by 'rbox n'
   - 'rbox r s Z G' no longer includes the positive pole
   - no changes to the Macintosh version
 
 qhull V2.00 5/23/94
   - if force output ('Po'), facet->maxoutside= 'Wn' since coplanars not updated
         convexity checked if precision problems or verify ('Tv')
   - if merging, new facets always checked for flipped orientation
   - a facet is visible (findhorizon) under 'Qm' if distance > max_vertex
   - if using 'Qm' then min. outside is max_vertex instead of max_outside
   - default is random()/srandom() in qhull_a.h, checked in initqhull_globals
   - created internal strtod since strtod may skip spacing after number
   - removed lower bound (1.0) for qh maxmaxcoord
   - divzero needs to handle 0/0 and large/small
   - decreased size of precise vertices
   - need to initialize qh MINdenom_1 for scalepoints
   - added factor of qh maxmaxcoord into DISTround (needed for offset)
   - 'Rn' perturbs distance computations by random +/-n
   - check_points needs an extra DISTround to get from precise point to computed
   - rewrote some of the IMPRECISION section in qhull.man
   - added the input format to the qhull prompt
   - moved include files to qhull_a.h since some compilers do not use float.h
   - added qhull.1 and rbox.1 since SGI does not ship nroff
   - reduced cutoff for printpointvect
   - use time for qhull random seed only if QR0 or QR-1
   - radius of vertices and coplanar points determined by pre-merge values
 
 qhull V2.00 5/12/94
   - facet2point (io.c) used vertex0 instead of vertex1
   - can't print visible facets after cone is attached
   - shouldn't check output after STOPcone (TCn)
   - statistic 'Wminvertex' and 'Wmaxoutside' only if MERGING or APPROXhull
   - 'make doc' uses lineprinter format for paging
   - warning if Gpv in 4-d
 
 qhull V2.b05 5/9/94
   - decreased size of precise vertices
   - precise facets in 2-d print hyperplanes
   - accounted for GOODpoint in printsummary
   - added IMPRECISION section to qhull.man
   - 'Qg' does work in 7-d unless there's many coplanar facets
 
diff --git a/src/libqhull/DEPRECATED.txt b/src/libqhull/DEPRECATED.txt
new file mode 100644
index 0000000..11fdb62
--- /dev/null
+++ b/src/libqhull/DEPRECATED.txt
@@ -0,0 +1,13 @@
+
+qhull/src/libqhull
+
+    This directory contains the deprecated qh_qh global configuration of qhull
+    
+    It will be maintained at least until January 2015.
+    
+    Except for qhull, the qhull executables will continue to build with libqhull.
+    
+    See qhull/src/libqhullr for the reentrant version of qhull.  On modern
+    architectures, it is as fast or faster than the global configuration.
+    
+ 
diff --git a/src/libqhull/libqhull.pro b/src/libqhull/libqhull.pro
index 3ed9fa0..6541ee3 100644
--- a/src/libqhull/libqhull.pro
+++ b/src/libqhull/libqhull.pro
@@ -1,65 +1,36 @@
 # -------------------------------------------------
 # libqhull.pro -- Qt project for Qhull shared library
 # -------------------------------------------------
 
 include(../qhull-warn.pri)
 
 DESTDIR = ../../lib
 DLLDESTDIR = ../../bin
 TEMPLATE = lib
 CONFIG += shared warn_on
 CONFIG -= qt
 
 build_pass:CONFIG(debug, debug|release):{
     TARGET = qhull_d
     OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release):{
     TARGET = qhull
     OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
 win32-msvc* : DEF_FILE += ../../src/libqhull/qhull-exports.def
 
-# Order object files by frequency of execution.  Small files at end.
-SOURCES += rboxlib.c
-SOURCES += user.c
-SOURCES += global.c
-SOURCES += stat.c
-SOURCES += io.c
-SOURCES += geom2.c
-SOURCES += poly2.c
-SOURCES += merge.c
-SOURCES += libqhull.c
-SOURCES += geom.c
-SOURCES += poly.c
-SOURCES += qset.c
-SOURCES += mem.c
-SOURCES += usermem.c
-SOURCES += userprintf.c
-SOURCES += userprintf_rbox.c
-SOURCES += random.c
-
-HEADERS += geom.h
-HEADERS += io.h
-HEADERS += libqhull.h
-HEADERS += mem.h
-HEADERS += merge.h
-HEADERS += poly.h
-HEADERS += random.h
-HEADERS += qhull_a.h
-HEADERS += qset.h
-HEADERS += stat.h
-HEADERS += user.h
+include(../qhull-libqhull-src.pri)
 
 OTHER_FILES += Mborland
 OTHER_FILES += qh-geom.htm
 OTHER_FILES += qh-globa.htm
 OTHER_FILES += qh-io.htm
 OTHER_FILES += qh-mem.htm
 OTHER_FILES += qh-merge.htm
 OTHER_FILES += qh-poly.htm
 OTHER_FILES += qh-qhull.htm
 OTHER_FILES += qh-set.htm
 OTHER_FILES += qh-stat.htm
 OTHER_FILES += qh-user.htm
diff --git a/src/libqhull/qhull-exports.def b/src/libqhull/qhull-exports.def
index 7a9203f..5186b16 100644
--- a/src/libqhull/qhull-exports.def
+++ b/src/libqhull/qhull-exports.def
@@ -1,412 +1,414 @@
 ; qhull-exports.def -- msvc module-definition file
 ;
 ;   Generated from depends.exe by cut-and-paste of exported symbols by mingw gcc
 ;   [mar'11] 399 symbols 
-;   Annotate as DATA qh_qh qh_qhstat qhmem qhull_inuse rbox_inuse
+;   Annotate as DATA qh_last_random qh_qh qh_qhstat qhmem qhull_inuse rbox rbox_inuse
+;   Annotate as __declspec for outside access in win32 -- qh_qh qh_qhstat
 ;   Same as ../libqhullp/qhull_p-exports.def without qh_save_qhull and qh_restore_qhull
 ;
-; $Id: //main/2011/qhull/src/libqhull/qhull-exports.def#4 $$Change: 1468 $
-; $DateTime: 2012/01/26 23:42:31 $$Author: bbarber $
+; $Id: //main/2011/qhull/src/libqhull/qhull-exports.def#5 $$Change: 1657 $
+; $DateTime: 2014/01/17 18:37:16 $$Author: bbarber $
 ; 
 ; Define qhull_VERSION in CMakeLists.txt, Makefile, qhull-exports.def, qhull_p-exports.def, and qhull-warn.pri
 VERSION 6.3
 EXPORTS
-dfacet
-dvertex
-out1
-out2n
-out3n
 qh_addhash
 qh_addpoint
 qh_all_merges
 qh_allstatA
 qh_allstatB
 qh_allstatC
 qh_allstatD
 qh_allstatE
 qh_allstatE2
 qh_allstatF
 qh_allstatG
 qh_allstatH
 qh_allstatI
 qh_allstatistics
 qh_appendfacet
 qh_appendmergeset
 qh_appendprint
 qh_appendvertex
 qh_argv_to_command
 qh_argv_to_command_size
 qh_attachnewfacets
 qh_backnormal
 qh_basevertices
 qh_build_withrestart
 qh_buildhull
 qh_buildtracing
 qh_check_bestdist
 qh_check_maxout
 qh_check_output
 qh_check_point
 qh_check_points
 qh_checkconnect
 qh_checkconvex
 qh_checkfacet
 qh_checkflags
 qh_checkflipped
 qh_checkflipped_all
 qh_checkpolygon
 qh_checkvertex
 qh_checkzero
 qh_clear_outputflags
 qh_clearcenters
 qh_clock
 qh_collectstatistics
 qh_compare_facetarea
 qh_compare_facetmerge
 qh_compare_facetvisit
 qh_compare_vertexpoint
 qh_compareangle
 qh_comparemerge
 qh_comparevisit
 qh_copyfilename
 qh_copynonconvex
 qh_copypoints
 qh_countfacets
 qh_createsimplex
 qh_crossproduct
 qh_degen_redundant_facet
 qh_degen_redundant_neighbors
 qh_deletevisible
 qh_delfacet
 qh_delridge
 qh_delvertex
 qh_determinant
 qh_detjoggle
 qh_detroundoff
 qh_detsimplex
 qh_detvnorm
 qh_detvridge
 qh_detvridge3
+qh_dfacet
 qh_distnorm
 qh_distplane
 qh_distround
 qh_divzero
+qh_dvertex
 qh_eachvoronoi
 qh_eachvoronoi_all
 qh_errexit
 qh_errexit2
 qh_errexit_rbox
 qh_errprint
 qh_exit
 qh_facet2point
 qh_facet3vertex
 qh_facetarea
 qh_facetarea_simplex
 qh_facetcenter
 qh_facetintersect
 qh_facetvertices
 qh_find_newvertex
 qh_findbest
 qh_findbest_test
 qh_findbestfacet
 qh_findbesthorizon
 qh_findbestlower
 qh_findbestneighbor
 qh_findbestnew
 qh_findfacet_all
 qh_findgood
 qh_findgood_all
 qh_findgooddist
 qh_findhorizon
 qh_flippedmerges
 qh_forcedmerges
 qh_fprintf
 qh_fprintf_rbox
 qh_free
 qh_freebuffers
 qh_freebuild
 qh_freeqhull
 qh_freeqhull2
 qh_freestatistics
 qh_furthestnext
 qh_furthestout
 qh_gausselim
 qh_geomplanes
 qh_getangle
 qh_getarea
 qh_getcenter
 qh_getcentrum
 qh_getdistance
 qh_gethash
 qh_getmergeset
 qh_getmergeset_initial
 qh_gram_schmidt
 qh_hashridge
 qh_hashridge_find
 qh_infiniteloop
 qh_init_A
 qh_init_B
 qh_init_qhull_command
 qh_initbuild
 qh_initflags
 qh_initialhull
 qh_initialvertices
 qh_initqhull_buffers
 qh_initqhull_globals
 qh_initqhull_mem
 qh_initqhull_outputflags
 qh_initqhull_start
 qh_initqhull_start2
 qh_initstatistics
 qh_initthresholds
 qh_inthresholds
 qh_isvertex
 qh_joggleinput
+; Mark as DATA, otherwise links a separate qh_last_random.  No __declspec
+qh_last_random      DATA
 qh_makenew_nonsimplicial
 qh_makenew_simplicial
 qh_makenewfacet
 qh_makenewfacets
 qh_makenewplanes
 qh_makeridges
 qh_malloc
 qh_mark_dupridges
 qh_markkeep
 qh_markvoronoi
 qh_matchduplicates
 qh_matchneighbor
 qh_matchnewfacets
 qh_matchvertices
 qh_maxabsval
 qh_maxmin
 qh_maxouter
 qh_maxsimplex
 qh_maydropneighbor
 qh_memalloc
 qh_memfree
 qh_memfreeshort
 qh_meminit
 qh_meminitbuffers
 qh_memsetup
 qh_memsize
 qh_memstatistics
 qh_memtotal
 qh_merge_degenredundant
 qh_merge_nonconvex
 qh_mergecycle
 qh_mergecycle_all
 qh_mergecycle_facets
 qh_mergecycle_neighbors
 qh_mergecycle_ridges
 qh_mergecycle_vneighbors
 qh_mergefacet
 qh_mergefacet2d
 qh_mergeneighbors
 qh_mergeridges
 qh_mergesimplex
 qh_mergevertex_del
 qh_mergevertex_neighbors
 qh_mergevertices
 qh_minabsval
 qh_mindiff
 qh_nearcoplanar
 qh_nearvertex
 qh_neighbor_intersections
 qh_new_qhull
 qh_newfacet
 qh_newhashtable
 qh_newridge
 qh_newstats
 qh_newvertex
 qh_newvertices
 qh_nextfurthest
 qh_nextridge3d
 qh_normalize
 qh_normalize2
 qh_nostatistic
 qh_option
 qh_order_vertexneighbors
 qh_orientoutside
+qh_out1
+qh_out2n
+qh_out3n
 qh_outcoplanar
 qh_outerinner
 qh_partitionall
 qh_partitioncoplanar
 qh_partitionpoint
 qh_partitionvisible
 qh_point
 qh_point_add
 qh_pointdist
 qh_pointfacet
 qh_pointid
 qh_pointvertex
 qh_postmerge
 qh_precision
 qh_premerge
 qh_prepare_output
 qh_prependfacet
 qh_printafacet
 qh_printallstatistics
 qh_printbegin
 qh_printcenter
 qh_printcentrum
 qh_printend
 qh_printend4geom
 qh_printextremes
 qh_printextremes_2d
 qh_printextremes_d
 qh_printfacet
 qh_printfacet2geom
 qh_printfacet2geom_points
 qh_printfacet2math
 qh_printfacet3geom_nonsimplicial
 qh_printfacet3geom_points
 qh_printfacet3geom_simplicial
 qh_printfacet3math
 qh_printfacet3vertex
 qh_printfacet4geom_nonsimplicial
 qh_printfacet4geom_simplicial
 qh_printfacetNvertex_nonsimplicial
 qh_printfacetNvertex_simplicial
 qh_printfacetheader
 qh_printfacetlist
 qh_printfacetridges
 qh_printfacets
 qh_printhashtable
 qh_printhelp_degenerate
 qh_printhelp_narrowhull
 qh_printhelp_singular
 qh_printhyperplaneintersection
 qh_printline3geom
 qh_printlists
 qh_printmatrix
 qh_printneighborhood
 qh_printpoint
 qh_printpoint3
 qh_printpointid
 qh_printpoints
 qh_printpoints_out
 qh_printpointvect
 qh_printpointvect2
 qh_printridge
 qh_printspheres
 qh_printstatistics
 qh_printstatlevel
 qh_printstats
 qh_printsummary
 qh_printvdiagram
 qh_printvdiagram2
 qh_printvertex
 qh_printvertexlist
 qh_printvertices
 qh_printvneighbors
 qh_printvnorm
 qh_printvoronoi
 qh_printvridge
 qh_produce_output
 qh_produce_output2
 qh_projectdim3
 qh_projectinput
 qh_projectpoint
 qh_projectpoints
-; Mark as DATA, otherwise links a separate qh_qh.  Requires __dcelspec
+; Mark as DATA, otherwise links a separate qh_qh.  qh_qh and qh_qhstat requires __declspec
 qh_qh               DATA
 qh_qhstat           DATA
 qh_qhull
 qh_rand
-qh_rand_seed
 qh_randomfactor
 qh_randommatrix
 qh_rboxpoints
 qh_readfeasible
 qh_readpoints
 qh_reducevertices
 qh_redundant_vertex
 qh_remove_extravertices
 qh_removefacet
 qh_removevertex
 qh_rename_sharedvertex
 qh_renameridgevertex
 qh_renamevertex
 qh_resetlists
 qh_rotateinput
 qh_rotatepoints
+qh_roundi
 qh_scaleinput
 qh_scalelast
 qh_scalepoints
 qh_setaddnth
 qh_setaddsorted
 qh_setappend
 qh_setappend2ndlast
 qh_setappend_set
 qh_setcheck
 qh_setcompact
 qh_setcopy
 qh_setdel
 qh_setdelaunay
 qh_setdellast
 qh_setdelnth
 qh_setdelnthsorted
 qh_setdelsorted
 qh_setduplicate
 qh_setequal
 qh_setequal_except
 qh_setequal_skip
 qh_setfacetplane
 qh_setfeasible
 qh_setfree
 qh_setfree2
 qh_setfreelong
 qh_sethalfspace
 qh_sethalfspace_all
 qh_sethyperplane_det
 qh_sethyperplane_gauss
 qh_setin
 qh_setindex
 qh_setlarger
 qh_setlast
 qh_setnew
 qh_setnew_delnthsorted
 qh_setprint
 qh_setreplace
 qh_setsize
 qh_settemp
 qh_settempfree
 qh_settempfree_all
 qh_settemppop
 qh_settemppush
 qh_settruncate
 qh_setunique
 qh_setvoronoi_all
 qh_setzero
 qh_sharpnewfacets
 qh_skipfacet
 qh_skipfilename
 qh_srand
 qh_stddev
 qh_strtod
 qh_strtol
 qh_test_appendmerge
 qh_test_vneighbors
 qh_tracemerge
 qh_tracemerging
 qh_triangulate
 qh_triangulate_facet
 qh_triangulate_link
 qh_triangulate_mirror
 qh_triangulate_null
 qh_updatetested
 qh_updatevertices
 qh_user_memsizes
 qh_version
 qh_vertexintersect
 qh_vertexintersect_new
 qh_vertexneighbors
 qh_vertexridges
 qh_vertexridges_facet
 qh_vertexsubset
 qh_voronoi_center
 qh_willdelete
-; Mark as DATA, otherwise links a separate qhmem.  Requires __dcelspec
+; Mark as DATA, otherwise links a separate qhmem.  No __declspec
 qhmem                   DATA
 qhull_inuse             DATA
-rbox
+rbox			DATA
 rbox_inuse              DATA
-roundi
diff --git a/src/libqhull/userprintf.c b/src/libqhull/userprintf.c
index 77c17cc..281194e 100644
--- a/src/libqhull/userprintf.c
+++ b/src/libqhull/userprintf.c
@@ -1,64 +1,65 @@
 /*<html><pre>  -<a                             href="qh-user.htm"
   >-------------------------------</a><a name="TOP">-</a>
 
    userprintf.c
    qh_fprintf()
 
    see README.txt  see COPYING.txt for copyright information.
 
    If you recompile and load this file, then userprintf.o will not be loaded
    from qhull.a or qhull.lib
 
    See libqhull.h for data structures, macros, and user-callable functions.
    See user.c for qhull-related, redefinable functions
    see user.h for user-definable constants
    See usermem.c for qh_exit(), qh_free(), and qh_malloc()
    see Qhull.cpp and RboxPoints.cpp for examples.
 
    Please report any errors that you fix to qhull@qhull.org
 */
 
 #include "libqhull.h"
+#include "mem.h"
 
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 /*-<a                             href="qh-user.htm#TOC"
    >-------------------------------</a><a name="qh_fprintf">-</a>
 
    qh_fprintf(fp, msgcode, format, list of args )
      print arguments to *fp according to format
      Use qh_fprintf_rbox() for rboxlib.c
 
    notes:
      same as fprintf()
      fgets() is not trapped like fprintf()
      exit qh_fprintf via qh_errexit()
      may be called for errors in qh_initstatistics and qh_meminit
 */
 
 void qh_fprintf(FILE *fp, int msgcode, const char *fmt, ... ) {
     va_list args;
 
     if (!fp) {
         fprintf(qhmem.ferr, "QH6232 Qhull internal error (userprintf.c): fp is 0.  Wrong qh_fprintf called.\n");
         qh_errexit(6232, NULL, NULL);
     }
     va_start(args, fmt);
 #if qh_QHpointer
     if (qh_qh && qh ANNOTATEoutput) {
 #else
     if (qh ANNOTATEoutput) {
 #endif
       fprintf(fp, "[QH%.4d]", msgcode);
     }else if (msgcode >= MSG_ERROR && msgcode < MSG_STDERR ) {
       fprintf(fp, "QH%.4d ", msgcode);
     }
     vfprintf(fp, fmt, args);
     va_end(args);
 
     /* Place debugging traps here. Use with option 'Tn' */
 
 } /* qh_fprintf */
 
diff --git a/src/libqhullcpp/libqhullcpp.pro b/src/libqhullcpp/libqhullcpp.pro
index f91d1cc..4311d04 100644
--- a/src/libqhullcpp/libqhullcpp.pro
+++ b/src/libqhullcpp/libqhullcpp.pro
@@ -1,71 +1,71 @@
 # -------------------------------------------------
 # libqhullcpp.pro -- Qt project for Qhull cpp shared library
 # -------------------------------------------------
 
 include(../qhull-warn.pri)
 
 DESTDIR = ../../lib
 TEMPLATE = lib
 CONFIG += staticlib warn_on
 CONFIG -= qt rtti
 build_pass:CONFIG(debug, debug|release):{
    TARGET = qhullcpp_d
    OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release):{
    TARGET = qhullcpp
    OBJECTS_DIR = Release
 }
 MOC_DIR = moc
 
 DEFINES += qh_QHpointer # libqhull/user.h
 
 INCLUDEPATH += ../../src
 INCLUDEPATH += $$PWD # for MOC_DIR
 
 CONFIG += qhull_warn_shadow qhull_warn_conversion
 
-SOURCES += Coordinates.cpp
-SOURCES += PointCoordinates.cpp
-SOURCES += Qhull.cpp
-SOURCES += QhullFacet.cpp
-SOURCES += QhullFacetList.cpp
-SOURCES += QhullFacetSet.cpp
-SOURCES += QhullHyperplane.cpp
-SOURCES += QhullPoint.cpp
-SOURCES += QhullPoints.cpp
-SOURCES += QhullPointSet.cpp
-SOURCES += QhullQh.cpp
-SOURCES += QhullRidge.cpp
-SOURCES += QhullSet.cpp
-SOURCES += QhullStat.cpp
-SOURCES += QhullVertex.cpp
-SOURCES += QhullVertexSet.cpp
-SOURCES += RboxPoints.cpp
-SOURCES += RoadError.cpp
-SOURCES += RoadLogEvent.cpp
-SOURCES += UsingLibQhull.cpp
+SOURCES += ../libqhullcpp/Coordinates.cpp
+SOURCES += ../libqhullcpp/PointCoordinates.cpp
+SOURCES += ../libqhullcpp/Qhull.cpp
+SOURCES += ../libqhullcpp/QhullFacet.cpp
+SOURCES += ../libqhullcpp/QhullFacetList.cpp
+SOURCES += ../libqhullcpp/QhullFacetSet.cpp
+SOURCES += ../libqhullcpp/QhullHyperplane.cpp
+SOURCES += ../libqhullcpp/QhullPoint.cpp
+SOURCES += ../libqhullcpp/QhullPoints.cpp
+SOURCES += ../libqhullcpp/QhullPointSet.cpp
+SOURCES += ../libqhullcpp/QhullQh.cpp
+SOURCES += ../libqhullcpp/QhullRidge.cpp
+SOURCES += ../libqhullcpp/QhullSet.cpp
+SOURCES += ../libqhullcpp/QhullStat.cpp
+SOURCES += ../libqhullcpp/QhullVertex.cpp
+SOURCES += ../libqhullcpp/QhullVertexSet.cpp
+SOURCES += ../libqhullcpp/RboxPoints.cpp
+SOURCES += ../libqhullcpp/RoadError.cpp
+SOURCES += ../libqhullcpp/RoadLogEvent.cpp
+SOURCES += ../libqhullcpp/UsingLibQhull.cpp
 
-HEADERS += Coordinates.h
-HEADERS += functionObjects.h
-HEADERS += PointCoordinates.h
-HEADERS += Qhull.h
-HEADERS += QhullError.h
-HEADERS += QhullFacet.h
-HEADERS += QhullFacetList.h
-HEADERS += QhullFacetSet.h
-HEADERS += QhullHyperplane.h
-HEADERS += QhullIterator.h
-HEADERS += QhullLinkedList.h
-HEADERS += QhullPoint.h
-HEADERS += QhullPoints.h
-HEADERS += QhullPointSet.h
-HEADERS += QhullQh.h
-HEADERS += QhullRidge.h
-HEADERS += QhullSet.h
-HEADERS += QhullSets.h
-HEADERS += QhullStat.h
-HEADERS += QhullVertex.h
-HEADERS += RboxPoints.h
-HEADERS += RoadError.h
-HEADERS += RoadLogEvent.h
-HEADERS += UsingLibQhull.h
+HEADERS += ../libqhullcpp/Coordinates.h
+HEADERS += ../libqhullcpp/functionObjects.h
+HEADERS += ../libqhullcpp/PointCoordinates.h
+HEADERS += ../libqhullcpp/Qhull.h
+HEADERS += ../libqhullcpp/QhullError.h
+HEADERS += ../libqhullcpp/QhullFacet.h
+HEADERS += ../libqhullcpp/QhullFacetList.h
+HEADERS += ../libqhullcpp/QhullFacetSet.h
+HEADERS += ../libqhullcpp/QhullHyperplane.h
+HEADERS += ../libqhullcpp/QhullIterator.h
+HEADERS += ../libqhullcpp/QhullLinkedList.h
+HEADERS += ../libqhullcpp/QhullPoint.h
+HEADERS += ../libqhullcpp/QhullPoints.h
+HEADERS += ../libqhullcpp/QhullPointSet.h
+HEADERS += ../libqhullcpp/QhullQh.h
+HEADERS += ../libqhullcpp/QhullRidge.h
+HEADERS += ../libqhullcpp/QhullSet.h
+HEADERS += ../libqhullcpp/QhullSets.h
+HEADERS += ../libqhullcpp/QhullStat.h
+HEADERS += ../libqhullcpp/QhullVertex.h
+HEADERS += ../libqhullcpp/RboxPoints.h
+HEADERS += ../libqhullcpp/RoadError.h
+HEADERS += ../libqhullcpp/RoadLogEvent.h
+HEADERS += ../libqhullcpp/UsingLibQhull.h
diff --git a/src/libqhullp/DEPRECATED.txt b/src/libqhullp/DEPRECATED.txt
new file mode 100644
index 0000000..8f20606
--- /dev/null
+++ b/src/libqhullp/DEPRECATED.txt
@@ -0,0 +1,10 @@
+
+qhull/src/libqhullp
+
+    This directory contains the deprecated qh_qhPOINTER configuration of qhull
+    
+    It will be maintained at least until January 2015.
+    
+    See qhull/src/libqhullr for the reentrant version of qhull
+    
+ 
diff --git a/src/libqhullp/qhull_p-exports.def b/src/libqhullp/qhull_p-exports.def
index fbe37ca..743b6a5 100644
--- a/src/libqhullp/qhull_p-exports.def
+++ b/src/libqhullp/qhull_p-exports.def
@@ -1,413 +1,415 @@
 ; qhull_p-exports.def -- msvc module-definition file
 ;
 ;   Generated from depends.exe by cut-and-paste of exported symbols by mingw gcc
 ;   [mar'11] 399 symbols 
-;   Annotate as DATA qh_qh qh_qhstat qhmem qhull_inuse rbox_inuse
+;   Annotate as DATA qh_last_random qh_qh qh_qhstat qhmem qhull_inuse rbox rbox_inuse
+;   Annotate as __declspec for outside access in win32 -- qh_qh qh_qhstat
 ;
 ; $Id: //main/2011/qhull/src/libqhull/qhull-exports.def#2 $$Change: 1368 $
 ; $DateTime: 2011/04/16 08:12:32 $$Author: bbarber $
 ;
 ; Define qhull_VERSION in CMakeLists.txt, Makefile, qhull-exports.def, qhull_p-exports.def, and qhull-warn.pri
 VERSION 6.3
 EXPORTS
-dfacet
-dvertex
-out1
-out2n
-out3n
 qh_addhash
 qh_addpoint
 qh_all_merges
 qh_allstatA
 qh_allstatB
 qh_allstatC
 qh_allstatD
 qh_allstatE
 qh_allstatE2
 qh_allstatF
 qh_allstatG
 qh_allstatH
 qh_allstatI
 qh_allstatistics
 qh_appendfacet
 qh_appendmergeset
 qh_appendprint
 qh_appendvertex
 qh_argv_to_command
 qh_argv_to_command_size
 qh_attachnewfacets
 qh_backnormal
 qh_basevertices
 qh_build_withrestart
 qh_buildhull
 qh_buildtracing
 qh_check_bestdist
 qh_check_maxout
 qh_check_output
 qh_check_point
 qh_check_points
 qh_checkconnect
 qh_checkconvex
 qh_checkfacet
 qh_checkflags
 qh_checkflipped
 qh_checkflipped_all
 qh_checkpolygon
 qh_checkvertex
 qh_checkzero
 qh_clear_outputflags
 qh_clearcenters
 qh_clock
 qh_collectstatistics
 qh_compare_facetarea
 qh_compare_facetmerge
 qh_compare_facetvisit
 qh_compare_vertexpoint
 qh_compareangle
 qh_comparemerge
 qh_comparevisit
 qh_copyfilename
 qh_copynonconvex
 qh_copypoints
 qh_countfacets
 qh_createsimplex
 qh_crossproduct
 qh_degen_redundant_facet
 qh_degen_redundant_neighbors
 qh_deletevisible
 qh_delfacet
 qh_delridge
 qh_delvertex
 qh_determinant
 qh_detjoggle
 qh_detroundoff
 qh_detsimplex
 qh_detvnorm
 qh_detvridge
 qh_detvridge3
+qh_dfacet
 qh_distnorm
 qh_distplane
 qh_distround
 qh_divzero
+qh_dvertex
 qh_eachvoronoi
 qh_eachvoronoi_all
 qh_errexit
 qh_errexit2
 qh_errexit_rbox
 qh_errprint
 qh_exit
 qh_facet2point
 qh_facet3vertex
 qh_facetarea
 qh_facetarea_simplex
 qh_facetcenter
 qh_facetintersect
 qh_facetvertices
 qh_find_newvertex
 qh_findbest
 qh_findbest_test
 qh_findbestfacet
 qh_findbesthorizon
 qh_findbestlower
 qh_findbestneighbor
 qh_findbestnew
 qh_findfacet_all
 qh_findgood
 qh_findgood_all
 qh_findgooddist
 qh_findhorizon
 qh_flippedmerges
 qh_forcedmerges
 qh_fprintf
 qh_fprintf_rbox
 qh_free
 qh_freebuffers
 qh_freebuild
 qh_freeqhull
 qh_freeqhull2
 qh_freestatistics
 qh_furthestnext
 qh_furthestout
 qh_gausselim
 qh_geomplanes
 qh_getangle
 qh_getarea
 qh_getcenter
 qh_getcentrum
 qh_getdistance
 qh_gethash
 qh_getmergeset
 qh_getmergeset_initial
 qh_gram_schmidt
 qh_hashridge
 qh_hashridge_find
 qh_infiniteloop
 qh_init_A
 qh_init_B
 qh_init_qhull_command
 qh_initbuild
 qh_initflags
 qh_initialhull
 qh_initialvertices
 qh_initqhull_buffers
 qh_initqhull_globals
 qh_initqhull_mem
 qh_initqhull_outputflags
 qh_initqhull_start
 qh_initqhull_start2
 qh_initstatistics
 qh_initthresholds
 qh_inthresholds
 qh_isvertex
 qh_joggleinput
+; Mark as DATA, otherwise links a separate qh_last_random.  No __declspec.
+qh_last_random      DATA
 qh_makenew_nonsimplicial
 qh_makenew_simplicial
 qh_makenewfacet
 qh_makenewfacets
 qh_makenewplanes
 qh_makeridges
 qh_malloc
 qh_mark_dupridges
 qh_markkeep
 qh_markvoronoi
 qh_matchduplicates
 qh_matchneighbor
 qh_matchnewfacets
 qh_matchvertices
 qh_maxabsval
 qh_maxmin
 qh_maxouter
 qh_maxsimplex
 qh_maydropneighbor
 qh_memalloc
 qh_memfree
 qh_memfreeshort
 qh_meminit
 qh_meminitbuffers
 qh_memsetup
 qh_memsize
 qh_memstatistics
 qh_memtotal
 qh_merge_degenredundant
 qh_merge_nonconvex
 qh_mergecycle
 qh_mergecycle_all
 qh_mergecycle_facets
 qh_mergecycle_neighbors
 qh_mergecycle_ridges
 qh_mergecycle_vneighbors
 qh_mergefacet
 qh_mergefacet2d
 qh_mergeneighbors
 qh_mergeridges
 qh_mergesimplex
 qh_mergevertex_del
 qh_mergevertex_neighbors
 qh_mergevertices
 qh_minabsval
 qh_mindiff
 qh_nearcoplanar
 qh_nearvertex
 qh_neighbor_intersections
 qh_new_qhull
 qh_newfacet
 qh_newhashtable
 qh_newridge
 qh_newstats
 qh_newvertex
 qh_newvertices
 qh_nextfurthest
 qh_nextridge3d
 qh_normalize
 qh_normalize2
 qh_nostatistic
 qh_option
 qh_order_vertexneighbors
 qh_orientoutside
+qh_out1
+qh_out2n
+qh_out3n
 qh_outcoplanar
 qh_outerinner
 qh_partitionall
 qh_partitioncoplanar
 qh_partitionpoint
 qh_partitionvisible
 qh_point
 qh_point_add
 qh_pointdist
 qh_pointfacet
 qh_pointid
 qh_pointvertex
 qh_postmerge
 qh_precision
 qh_premerge
 qh_prepare_output
 qh_prependfacet
 qh_printafacet
 qh_printallstatistics
 qh_printbegin
 qh_printcenter
 qh_printcentrum
 qh_printend
 qh_printend4geom
 qh_printextremes
 qh_printextremes_2d
 qh_printextremes_d
 qh_printfacet
 qh_printfacet2geom
 qh_printfacet2geom_points
 qh_printfacet2math
 qh_printfacet3geom_nonsimplicial
 qh_printfacet3geom_points
 qh_printfacet3geom_simplicial
 qh_printfacet3math
 qh_printfacet3vertex
 qh_printfacet4geom_nonsimplicial
 qh_printfacet4geom_simplicial
 qh_printfacetNvertex_nonsimplicial
 qh_printfacetNvertex_simplicial
 qh_printfacetheader
 qh_printfacetlist
 qh_printfacetridges
 qh_printfacets
 qh_printhashtable
 qh_printhelp_degenerate
 qh_printhelp_narrowhull
 qh_printhelp_singular
 qh_printhyperplaneintersection
 qh_printline3geom
 qh_printlists
 qh_printmatrix
 qh_printneighborhood
 qh_printpoint
 qh_printpoint3
 qh_printpointid
 qh_printpoints
 qh_printpoints_out
 qh_printpointvect
 qh_printpointvect2
 qh_printridge
 qh_printspheres
 qh_printstatistics
 qh_printstatlevel
 qh_printstats
 qh_printsummary
 qh_printvdiagram
 qh_printvdiagram2
 qh_printvertex
 qh_printvertexlist
 qh_printvertices
 qh_printvneighbors
 qh_printvnorm
 qh_printvoronoi
 qh_printvridge
 qh_produce_output
 qh_produce_output2
 qh_projectdim3
 qh_projectinput
 qh_projectpoint
 qh_projectpoints
-; Mark as DATA, otherwise links a separate qh_qh.  Requires __dcelspec
+; Mark as DATA, otherwise links a separate qh_qh.  qh_qh and qh_qhstat requires __declspec
 qh_qh               DATA
 qh_qhstat           DATA
 qh_qhull
 qh_rand
-qh_rand_seed
 qh_randomfactor
 qh_randommatrix
 qh_rboxpoints
 qh_readfeasible
 qh_readpoints
 qh_reducevertices
 qh_redundant_vertex
 qh_remove_extravertices
 qh_removefacet
 qh_removevertex
 qh_rename_sharedvertex
 qh_renameridgevertex
 qh_renamevertex
 qh_resetlists
 qh_restore_qhull
 qh_rotateinput
 qh_rotatepoints
+qh_roundi
 qh_save_qhull
 qh_scaleinput
 qh_scalelast
 qh_scalepoints
 qh_setaddnth
 qh_setaddsorted
 qh_setappend
 qh_setappend2ndlast
 qh_setappend_set
 qh_setcheck
 qh_setcompact
 qh_setcopy
 qh_setdel
 qh_setdelaunay
 qh_setdellast
 qh_setdelnth
 qh_setdelnthsorted
 qh_setdelsorted
 qh_setduplicate
 qh_setequal
 qh_setequal_except
 qh_setequal_skip
 qh_setfacetplane
 qh_setfeasible
 qh_setfree
 qh_setfree2
 qh_setfreelong
 qh_sethalfspace
 qh_sethalfspace_all
 qh_sethyperplane_det
 qh_sethyperplane_gauss
 qh_setin
 qh_setindex
 qh_setlarger
 qh_setlast
 qh_setnew
 qh_setnew_delnthsorted
 qh_setprint
 qh_setreplace
 qh_setsize
 qh_settemp
 qh_settempfree
 qh_settempfree_all
 qh_settemppop
 qh_settemppush
 qh_settruncate
 qh_setunique
 qh_setvoronoi_all
 qh_setzero
 qh_sharpnewfacets
 qh_skipfacet
 qh_skipfilename
 qh_srand
 qh_stddev
 qh_strtod
 qh_strtol
 qh_test_appendmerge
 qh_test_vneighbors
 qh_tracemerge
 qh_tracemerging
 qh_triangulate
 qh_triangulate_facet
 qh_triangulate_link
 qh_triangulate_mirror
 qh_triangulate_null
 qh_updatetested
 qh_updatevertices
 qh_user_memsizes
 qh_version
 qh_vertexintersect
 qh_vertexintersect_new
 qh_vertexneighbors
 qh_vertexridges
 qh_vertexridges_facet
 qh_vertexsubset
 qh_voronoi_center
 qh_willdelete
-; Mark as DATA, otherwise links a separate qhmem.  Requires __dcelspec
+; Mark as DATA, otherwise links a separate qhmem.  No __declspec
 qhmem                   DATA
 qhull_inuse             DATA
-rbox
+rbox			DATA
 rbox_inuse              DATA
-roundi
diff --git a/src/libqhullrcpp/Coordinates.cpp b/src/libqhullpcpp/Coordinates.cpp
similarity index 94%
rename from src/libqhullrcpp/Coordinates.cpp
rename to src/libqhullpcpp/Coordinates.cpp
index 72b8557..8352aea 100644
--- a/src/libqhullrcpp/Coordinates.cpp
+++ b/src/libqhullpcpp/Coordinates.cpp
@@ -1,184 +1,184 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/Coordinates.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/Coordinates.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include "functionObjects.h"
 #include "QhullError.h"
 #include "Coordinates.h"
 
 #include <iostream>
 #include <iterator>
 #include <algorithm>
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//! Coordinates -- vector of coordT (normally double)
 
 #//Element access
 
 // Inefficient without result-value-optimization or implicitly shared object
 Coordinates Coordinates::
 mid(int idx, int length) const
 {
     int newLength= length;
     if(length<0 || idx+length > count()){
         newLength= count()-idx;
     }
     Coordinates result;
     if(newLength>0){
         std::copy(begin()+idx, begin()+(idx+newLength), std::back_inserter(result));
     }
     return result;
 }//mid
 
 coordT Coordinates::
 value(int idx, const coordT &defaultValue) const
 {
     return ((idx < 0 || idx >= count()) ? defaultValue : (*this)[idx]);
 }//value
 
 #//Operator
 
 Coordinates Coordinates::
 operator+(const Coordinates &other) const
 {
     Coordinates result(*this);
     std::copy(other.begin(), other.end(), std::back_inserter(result));
     return result;
 }//operator+
 
 Coordinates & Coordinates::
 operator+=(const Coordinates &other)
 {
     if(&other==this){
         Coordinates clone(other);
         std::copy(clone.begin(), clone.end(), std::back_inserter(*this));
     }else{
         std::copy(other.begin(), other.end(), std::back_inserter(*this));
     }
     return *this;
 }//operator+=
 
 #//Read-write
 
 coordT Coordinates::
 takeAt(int idx)
 {
     coordT c= at(idx);
     erase(begin()+idx);
     return c;
 }//takeAt
 
 coordT Coordinates::
 takeLast()
 {
     coordT c= last();
     removeLast();
     return c;
 }//takeLast
 
 void Coordinates::
 swap(int idx, int other)
 {
     coordT c= at(idx);
     at(idx)= at(other);
     at(other)= c;
 }//swap
 
 #//Search
 
 bool Coordinates::
 contains(const coordT &t) const
 {
     CoordinatesIterator i(*this);
     return i.findNext(t);
 }//contains
 
 int Coordinates::
 count(const coordT &t) const
 {
     CoordinatesIterator i(*this);
     int result= 0;
     while(i.findNext(t)){
         ++result;
     }
     return result;
 }//count
 
 int Coordinates::
 indexOf(const coordT &t, int from) const
 {
     if(from<0){
         from += count();
         if(from<0){
             from= 0;
         }
     }
     if(from<count()){
         const_iterator i= begin()+from;
         while(i!=constEnd()){
             if(*i==t){
                 return (static_cast<int>(i-begin())); // WARN64
             }
             ++i;
         }
     }
     return -1;
 }//indexOf
 
 int Coordinates::
 lastIndexOf(const coordT &t, int from) const
 {
     if(from<0){
         from += count();
     }else if(from>=count()){
         from= count()-1;
     }
     if(from>=0){
         const_iterator i= begin()+from+1;
         while(i-- != constBegin()){
             if(*i==t){
                 return (static_cast<int>(i-begin())); // WARN64
             }
         }
     }
     return -1;
 }//lastIndexOf
 
 void Coordinates::
 removeAll(const coordT &t)
 {
     MutableCoordinatesIterator i(*this);
     while(i.findNext(t)){
         i.remove();
     }
 }//removeAll
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::istream;
 using std::ostream;
 using std::string;
 using std::ws;
 using orgQhull::Coordinates;
 
 ostream &
 operator<<(ostream &os, const Coordinates &cs)
 {
     Coordinates::const_iterator c= cs.begin();
     for(int i=cs.count(); i--; ){
         os << *c++ << " ";
     }
     return os;
 }//operator<<
 
diff --git a/src/libqhullrcpp/Coordinates.h b/src/libqhullpcpp/Coordinates.h
similarity index 99%
rename from src/libqhullrcpp/Coordinates.h
rename to src/libqhullpcpp/Coordinates.h
index 7713bc0..1fca646 100644
--- a/src/libqhullrcpp/Coordinates.h
+++ b/src/libqhullpcpp/Coordinates.h
@@ -1,311 +1,311 @@
 /****************************************************************************
 **
 ** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/Coordinates.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/Coordinates.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHCOORDINATES_H
 #define QHCOORDINATES_H
 
 #include "QhullError.h"
 #include "QhullIterator.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 
 #include <cstddef> // ptrdiff_t, size_t
 #include <ostream>
 #include <vector>
 
 namespace orgQhull {
 
 #//Types
     //! an allocated vector of point coordinates
     //!  Used by PointCoordinates for RboxPoints
     //!  A QhullPoint refers to previously allocated coordinates
     class  Coordinates;
     class  MutableCoordinatesIterator;
 
 
 class Coordinates {
 
 private:
 #//Fields
     std::vector<coordT> coordinate_array;
 
 public:
 #//Subtypes
 
     class                       const_iterator;
     class                       iterator;
     typedef iterator Iterator;
     typedef const_iterator ConstIterator;
 
     typedef coordT              value_type;
     typedef const value_type   *const_pointer;
     typedef const value_type   &const_reference;
     typedef value_type         *pointer;
     typedef value_type         &reference;
     typedef ptrdiff_t           difference_type;
     typedef int                 size_type;
 
 #//Construct
                         Coordinates() {};
     explicit            Coordinates(const std::vector<coordT> &other) : coordinate_array(other) {}
                         Coordinates(const Coordinates &other) : coordinate_array(other.coordinate_array) {}
     Coordinates        &operator=(const Coordinates &other) { coordinate_array= other.coordinate_array; return *this; }
     Coordinates        &operator=(const std::vector<coordT> &other) { coordinate_array= other; return *this; }
                        ~Coordinates() {}
 
 #//Conversion
 
     coordT             *data() { return isEmpty() ? 0 : &at(0); }
     const coordT       *data() const { return const_cast<const pointT*>(isEmpty() ? 0 : &at(0)); }
 
 #ifndef QHULL_NO_STL
     std::vector<coordT> toStdVector() const { return coordinate_array; }
 #endif //QHULL_NO_STL
 #ifdef QHULL_USES_QT
     QList<coordT>      toQList() const;
 #endif //QHULL_USES_QT
 
 #//GetSet
     int                count() const { return static_cast<int>(size()); }
     bool               empty() const { return coordinate_array.empty(); }
     bool               isEmpty() const { return empty(); }
     bool               operator==(const Coordinates &other) const  { return coordinate_array==other.coordinate_array; }
     bool               operator!=(const Coordinates &other) const  { return coordinate_array!=other.coordinate_array; }
     size_t             size() const { return coordinate_array.size(); }
 
 #//Element access
     coordT             &at(int idx) { return coordinate_array.at(idx); }
     const coordT       &at(int idx) const { return coordinate_array.at(idx); }
     coordT             &back() { return coordinate_array.back(); }
     const coordT       &back() const { return coordinate_array.back(); }
     coordT             &first() { return front(); }
     const coordT       &first() const { return front(); }
     coordT             &front() { return coordinate_array.front(); }
     const coordT       &front() const { return coordinate_array.front(); }
     coordT             &last() { return back(); }
     const coordT       &last() const { return back(); }
     Coordinates        mid(int idx, int length= -1) const;
     coordT            &operator[](int idx) { return coordinate_array.operator[](idx); }
     const coordT      &operator[](int idx) const { return coordinate_array.operator[](idx); }
     coordT             value(int idx, const coordT &defaultValue) const;
 
 #//Iterator
     iterator            begin() { return iterator(coordinate_array.begin()); }
     const_iterator      begin() const { return const_iterator(coordinate_array.begin()); }
     const_iterator      constBegin() const { return begin(); }
     const_iterator      constEnd() const { return end(); }
     iterator            end() { return iterator(coordinate_array.end()); }
     const_iterator      end() const { return const_iterator(coordinate_array.end()); }
 
 #//Read-only
     Coordinates         operator+(const Coordinates &other) const;
 
 #//Modify
     void                append(const coordT &c) { push_back(c); }
     void                clear() { coordinate_array.clear(); }
     iterator            erase(iterator idx) { return iterator(coordinate_array.erase(idx.base())); }
     iterator            erase(iterator beginIterator, iterator endIterator) { return iterator(coordinate_array.erase(beginIterator.base(), endIterator.base())); }
     void                insert(int before, const coordT &c) { insert(begin()+before, c); }
     iterator            insert(iterator before, const coordT &c) { return iterator(coordinate_array.insert(before.base(), c)); }
     void                move(int from, int to) { insert(to, takeAt(from)); }
     Coordinates        &operator+=(const Coordinates &other);
     Coordinates        &operator+=(const coordT &c) { append(c); return *this; }
     Coordinates        &operator<<(const Coordinates &other) { return *this += other; }
     Coordinates        &operator<<(const coordT &c) { return *this += c; }
     void                pop_back() { coordinate_array.pop_back(); }
     void                pop_front() { removeFirst(); }
     void                prepend(const coordT &c) { insert(begin(), c); }
     void                push_back(const coordT &c) { coordinate_array.push_back(c); }
     void                push_front(const coordT &c) { insert(begin(), c); }
                         //removeAll below
     void                removeAt(int idx) { erase(begin()+idx); }
     void                removeFirst() { erase(begin()); }
     void                removeLast() { erase(--end()); }
     void                replace(int idx, const coordT &c) { (*this)[idx]= c; }
     void                reserve(int i) { coordinate_array.reserve(i); }
     void                swap(int idx, int other);
     coordT              takeAt(int idx);
     coordT              takeFirst() { return takeAt(0); }
     coordT              takeLast();
 
 #//Search
     bool                contains(const coordT &t) const;
     int                 count(const coordT &t) const;
     int                 indexOf(const coordT &t, int from = 0) const;
     int                 lastIndexOf(const coordT &t, int from = -1) const;
     void                removeAll(const coordT &t);
 
 #//Coordinates::iterator -- from QhullPoints, forwarding to coordinate_array
     // before const_iterator for conversion with comparison operators
     class iterator {
 
     private:
         std::vector<coordT>::iterator i;
         friend class    const_iterator;
 
     public:
         typedef std::random_access_iterator_tag  iterator_category;
         typedef coordT      value_type;
         typedef value_type *pointer;
         typedef value_type &reference;
         typedef ptrdiff_t   difference_type;
 
                         iterator() {}
                         iterator(const iterator &other) { i= other.i; }
         explicit        iterator(const std::vector<coordT>::iterator &vi) { i= vi; }
         iterator       &operator=(const iterator &other) { i= other.i; return *this; }
         std::vector<coordT>::iterator &base() { return i; }
                         // No operator-> for base types
         coordT         &operator*() const { return *i; }
         coordT         &operator[](int idx) const { return i[idx]; }
 
         bool            operator==(const iterator &other) const { return i==other.i; }
         bool            operator!=(const iterator &other) const { return i!=other.i; }
         bool            operator<(const iterator &other) const { return i<other.i; }
         bool            operator<=(const iterator &other) const { return i<=other.i; }
         bool            operator>(const iterator &other) const { return i>other.i; }
         bool            operator>=(const iterator &other) const { return i>=other.i; }
               // reinterpret_cast to break circular dependency
         bool            operator==(const Coordinates::const_iterator &other) const { return *this==reinterpret_cast<const iterator &>(other); }
         bool            operator!=(const Coordinates::const_iterator &other) const { return *this!=reinterpret_cast<const iterator &>(other); }
         bool            operator<(const Coordinates::const_iterator &other) const { return *this<reinterpret_cast<const iterator &>(other); }
         bool            operator<=(const Coordinates::const_iterator &other) const { return *this<=reinterpret_cast<const iterator &>(other); }
         bool            operator>(const Coordinates::const_iterator &other) const { return *this>reinterpret_cast<const iterator &>(other); }
         bool            operator>=(const Coordinates::const_iterator &other) const { return *this>=reinterpret_cast<const iterator &>(other); }
 
         iterator        operator++() { return iterator(++i); } //FIXUP QH11012 Should return reference, but get reference to temporary
         iterator        operator++(int) { return iterator(i++); }
         iterator        operator--() { return iterator(--i); }
         iterator        operator--(int) { return iterator(i--); }
         iterator        operator+=(int idx) { return iterator(i += idx); }
         iterator        operator-=(int idx) { return iterator(i -= idx); }
         iterator        operator+(int idx) const { return iterator(i+idx); }
         iterator        operator-(int idx) const { return iterator(i-idx); }
         difference_type operator-(iterator other) const { return i-other.i; }
     };//Coordinates::iterator
 
 #//Coordinates::const_iterator
     class const_iterator {
 
     private:
         std::vector<coordT>::const_iterator i;
 
     public:
         typedef std::random_access_iterator_tag  iterator_category;
         typedef coordT            value_type;
         typedef const value_type *pointer;
         typedef const value_type &reference;
         typedef ptrdiff_t         difference_type;
 
                         const_iterator() {}
                         const_iterator(const const_iterator &other) { i= other.i; }
                         const_iterator(iterator o) : i(o.i) {}
         explicit        const_iterator(const std::vector<coordT>::const_iterator &vi) { i= vi; }
         const_iterator &operator=(const const_iterator &other) { i= other.i; return *this; }
                         // No operator-> for base types
                         // No reference to a base type for () and []
         const coordT   &operator*() const { return *i; }
         const coordT   &operator[](int idx) const { return i[idx]; }
 
         bool            operator==(const const_iterator &other) const { return i==other.i; }
         bool            operator!=(const const_iterator &other) const { return i!=other.i; }
         bool            operator<(const const_iterator &other) const { return i<other.i; }
         bool            operator<=(const const_iterator &other) const { return i<=other.i; }
         bool            operator>(const const_iterator &other) const { return i>other.i; }
         bool            operator>=(const const_iterator &other) const { return i>=other.i; }
 
         const_iterator  operator++() { return const_iterator(++i); } //FIXUP QH11014 -- too much copying
         const_iterator  operator++(int) { return const_iterator(i++); }
         const_iterator  operator--() { return const_iterator(--i); }
         const_iterator  operator--(int) { return const_iterator(i--); }
         const_iterator  operator+=(int idx) { return const_iterator(i += idx); }
         const_iterator  operator-=(int idx) { return const_iterator(i -= idx); }
         const_iterator  operator+(int idx) const { return const_iterator(i+idx); }
         const_iterator  operator-(int idx) const { return const_iterator(i-idx); }
         difference_type operator-(const_iterator other) const { return i-other.i; }
     };//Coordinates::const_iterator
 
 };//Coordinates
 
 //class CoordinatesIterator
 //QHULL_DECLARE_SEQUENTIAL_ITERATOR(Coordinates, coordT)
 
 class CoordinatesIterator
 {
     typedef Coordinates::const_iterator const_iterator;
     const Coordinates *c;
     const_iterator i;
     public:
     inline CoordinatesIterator(const Coordinates &container)
     : c(&container), i(c->constBegin()) {}
     inline CoordinatesIterator &operator=(const Coordinates &container)
     { c = &container; i = c->constBegin(); return *this; }
     inline void toFront() { i = c->constBegin(); }
     inline void toBack() { i = c->constEnd(); }
     inline bool hasNext() const { return i != c->constEnd(); }
     inline const coordT &next() { return *i++; }
     inline const coordT &peekNext() const { return *i; }
     inline bool hasPrevious() const { return i != c->constBegin(); }
     inline const coordT &previous() { return *--i; }
     inline const coordT &peekPrevious() const { const_iterator p = i; return *--p; }
     inline bool findNext(const coordT &t)
     { while (i != c->constEnd()) if (*i++ == t) return true; return false; }
     inline bool findPrevious(const coordT &t)
     { while (i != c->constBegin()) if (*(--i) == t) return true;
     return false;  }
 };//CoordinatesIterator
 
 //class MutableCoordinatesIterator
 //QHULL_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(Coordinates, coordT)
 class MutableCoordinatesIterator
 {
     typedef Coordinates::iterator iterator;
     typedef Coordinates::const_iterator const_iterator;
     Coordinates *c;
     iterator i, n;
     inline bool item_exists() const { return const_iterator(n) != c->constEnd(); }
     public:
     inline MutableCoordinatesIterator(Coordinates &container)
     : c(&container)
     { i = c->begin(); n = c->end(); }
     inline ~MutableCoordinatesIterator()
     {}
     inline MutableCoordinatesIterator &operator=(Coordinates &container)
     { c = &container;
     i = c->begin(); n = c->end(); return *this; }
     inline void toFront() { i = c->begin(); n = c->end(); }
     inline void toBack() { i = c->end(); n = i; }
     inline bool hasNext() const { return c->constEnd() != const_iterator(i); }
     inline coordT &next() { n = i++; return *n; }
     inline coordT &peekNext() const { return *i; }
     inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); }
     inline coordT &previous() { n = --i; return *n; }
     inline coordT &peekPrevious() const { iterator p = i; return *--p; }
     inline void remove()
     { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } }
     inline void setValue(const coordT &t) const { if (c->constEnd() != const_iterator(n)) *n = t; }
     inline coordT &value() { QHULL_ASSERT(item_exists()); return *n; }
     inline const coordT &value() const { QHULL_ASSERT(item_exists()); return *n; }
     inline void insert(const coordT &t) { n = i = c->insert(i, t); ++i; }
     inline bool findNext(const coordT &t)
     { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; }
     inline bool findPrevious(const coordT &t)
     { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true;
     n = c->end(); return false;  }
 };//MutableCoordinatesIterator
 
 
 }//namespace orgQhull
 
 #//Global functions
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::Coordinates &c);
 
 #endif // QHCOORDINATES_H
diff --git a/src/libqhullpcpp/DEPRECATED.txt b/src/libqhullpcpp/DEPRECATED.txt
new file mode 100644
index 0000000..c13770f
--- /dev/null
+++ b/src/libqhullpcpp/DEPRECATED.txt
@@ -0,0 +1,9 @@
+
+qhull/src/libqhullpcpp
+
+    This directory contains the deprecated cpp classes based on libqhullp.
+    
+    It will be maintained until January 2015.
+    
+    See qhull/src/libqhullcpp for the new cpp classes.
+ 
diff --git a/src/libqhullrcpp/PointCoordinates.cpp b/src/libqhullpcpp/PointCoordinates.cpp
similarity index 97%
rename from src/libqhullrcpp/PointCoordinates.cpp
rename to src/libqhullpcpp/PointCoordinates.cpp
index 52a68ac..78f7af1 100644
--- a/src/libqhullrcpp/PointCoordinates.cpp
+++ b/src/libqhullpcpp/PointCoordinates.cpp
@@ -1,294 +1,294 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/PointCoordinates.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/PointCoordinates.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include "QhullError.h"
 #include "QhullPoint.h"
 #include "PointCoordinates.h"
 
 #include <iterator>
 #include <iostream>
 
 using std::istream;
 using std::string;
 using std::ws;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//! PointCoordinates -- vector of PointCoordinates
 
 #//Construct
 PointCoordinates::
 PointCoordinates()
 : QhullPoints()
 , point_coordinates()
 , point_comment()
 {
     makeValid();
 }
 
 #//Construct
 PointCoordinates::
 PointCoordinates(int pointDimension)
 : QhullPoints(pointDimension)
 , point_coordinates()
 , point_comment()
 {
     makeValid();
 }
 
 PointCoordinates::
 PointCoordinates(const std::string &aComment)
 : QhullPoints()
 , point_coordinates()
 , point_comment(aComment)
 {
     makeValid();
 }
 
 PointCoordinates::
 PointCoordinates(int pointDimension, const std::string &aComment)
 : QhullPoints(pointDimension)
 , point_coordinates()
 , point_comment(aComment)
 {
     makeValid();
 }
 
 PointCoordinates::
 PointCoordinates(int pointDimension, const std::string &aComment, int coordinatesCount, const coordT *c)
 : QhullPoints(pointDimension)
 , point_coordinates()
 , point_comment(aComment)
 {
     append(coordinatesCount, c);
 }
 
 PointCoordinates::
 PointCoordinates(const PointCoordinates &other)
 : QhullPoints(other)
 , point_coordinates(other.point_coordinates)
 , point_comment(other.point_comment)
 {
     makeValid();
 }
 
 PointCoordinates & PointCoordinates::
 operator=(const PointCoordinates &other)
 {
     point_coordinates= other.point_coordinates;
     point_comment= other.point_comment;
     makeValid();
     return *this;
 }//operator=
 
 PointCoordinates::
 ~PointCoordinates()
 { }
 
 #//GetSet
 
 void PointCoordinates::
 checkValid() const
 {
     if(getCoordinates().data()!=data()
     || getCoordinates().count()!=coordinateCount()){
         throw QhullError(10060, "Qhull error: first point (%x) is not PointCoordinates.data() or count (%d) is not PointCoordinates.count (%d)", coordinateCount(), getCoordinates().count(), 0.0, data());
     }
 }//checkValid
 
 void PointCoordinates::
 setDimension(int i)
 {
     if(i<0){
         throw QhullError(10062, "Qhull error: can not set PointCoordinates dimension to %d", i);
     }
     int currentDimension=QhullPoints::dimension();
     if(currentDimension!=0 && i!=currentDimension){
         throw QhullError(10063, "Qhull error: can not change PointCoordinates dimension (from %d to %d)", currentDimension, i);
     }
     QhullPoints::setDimension(i);
 }//setDimension
 
 //#Foreach
 
 Coordinates::ConstIterator PointCoordinates::
 beginCoordinates(int pointIndex) const
 {
     return point_coordinates.begin()+indexOffset(pointIndex);
 }
 
 Coordinates::Iterator PointCoordinates::
 beginCoordinates(int pointIndex)
 {
     return point_coordinates.begin()+indexOffset(pointIndex);
 }
 
 #//Modify
 
 void PointCoordinates::
 append(int coordinatesCount, const coordT *c)
 {
     if(coordinatesCount<=0){
         return;
     }
     if(includesCoordinates(c)){
         throw QhullError(10065, "Qhull error: can not append a subset of PointCoordinates to itself.  The coordinates for point %d may move.", indexOf(c, QhullError::NOthrow));
     }
     reserveCoordinates(coordinatesCount);
     std::copy(c, c+coordinatesCount, std::back_inserter(point_coordinates));
     makeValid();
 }//append coordT
 
 void PointCoordinates::
 append(const PointCoordinates &other)
 {
     setDimension(other.dimension());
     append(other.coordinateCount(), other.data());
 }//append PointCoordinates
 
 void PointCoordinates::
 append(const QhullPoint &p)
 {
     setDimension(p.dimension());
     append(p.dimension(), p.coordinates());
 }//append QhullPoint
 
 void PointCoordinates::
 appendComment(const std::string &s){
     if(char c= s[0] && point_comment.empty()){
         if(c=='-' || isdigit(c)){
             throw QhullError(10028, "Qhull argument error: comments can not start with a number or minus, %s", 0, 0, 0.0, s.c_str());
         }
     }
     point_comment += s;
 }//appendComment
 
 //! Read PointCoordinates from istream.  First two numbers are dimension and count.  A non-digit starts a rboxCommand.
 //! Overwrites point_comment.  See qh_readpoints [io.c]
 void PointCoordinates::
 appendPoints(istream &in)
 {
     int inDimension, inCount;
     in >> ws >> inDimension >> ws;
     if(!in.good()){
         in.clear();
         string remainder;
         getline(in, remainder);
         throw QhullError(10005, "Qhull error: input did not start with dimension or count -- %s", 0, 0, 0, remainder.c_str());
     }
     char c= (char)in.peek();
     if(c!='-' && !isdigit(c)){         // Comments start with a non-digit
         getline(in, point_comment);
         in >> ws;
     }
     in >> inCount >> ws;
     if(!in.good()){
         in.clear();
         string remainder;
         getline(in, remainder);
         throw QhullError(10009, "Qhull error: input did not start with dimension and count -- %d %s", inDimension, 0, 0, remainder.c_str());
     }
     c= (char)in.peek();
     if(c!='-' && !isdigit(c)){         // Comments start with a non-digit
         getline(in, point_comment);
         in >> ws;
     }
     if(inCount<inDimension){           // Count may precede dimension
         std::swap(inCount, inDimension);
     }
     setDimension(inDimension);
     reserveCoordinates(inCount*inDimension);
     int coordinatesCount= 0;
     while(!in.eof()){
         realT p;
         in >> p >> ws;
         if(in.fail()){
             in.clear();
             string remainder;
             getline(in, remainder);
             throw QhullError(10008, "Qhull error: failed to read coordinate %d  of point %d\n   %s", coordinatesCount % inDimension, coordinatesCount/inDimension, 0, remainder.c_str());
         }else{
             point_coordinates.push_back(p);
             coordinatesCount++;
         }
     }
     if(coordinatesCount != inCount*inDimension){
         if(coordinatesCount%inDimension==0){
             throw QhullError(10006, "Qhull error: expected %d %d-d PointCoordinates but read %i PointCoordinates", int(inCount), inDimension, 0.0, int(coordinatesCount/inDimension));
         }else{
             throw QhullError(10012, "Qhull error: expected %d %d-d PointCoordinates but read %i PointCoordinates plus %f extra coordinates", inCount, inDimension, float(coordinatesCount%inDimension), coordinatesCount/inDimension);
         }
     }
     makeValid();
 }//appendPoints istream
 
 PointCoordinates PointCoordinates::
 operator+(const PointCoordinates &other) const
 {
     PointCoordinates pc= *this;
     pc << other;
     return pc;
 }//operator+
 
 void PointCoordinates::
 reserveCoordinates(int newCoordinates)
 {
     // vector::reserve is not const
     point_coordinates.reserve((int)point_coordinates.size()+newCoordinates); // WARN64
     makeValid();
 }//reserveCoordinates
 
 #//Helpers
 
 int PointCoordinates::
 indexOffset(int i) const {
     int n= i*dimension();
     int coordinatesCount= point_coordinates.count();
     if(i<0 || n>coordinatesCount){
         throw QhullError(10061, "Qhull error: point_coordinates is too short (%d) for point %d", coordinatesCount, i);
     }
     return n;
 }
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::ostream;
 
 using orgQhull::Coordinates;
 using orgQhull::PointCoordinates;
 
 ostream&
 operator<<(ostream &os, const PointCoordinates &p)
 {
     p.checkValid();
     int count= p.count();
     int dimension= p.dimension();
     string comment= p.comment();
     if(comment.empty()){
         os << dimension << endl;
     }else{
         os << dimension << " " << comment << endl;
     }
     os << count << endl;
     Coordinates::ConstIterator c= p.beginCoordinates();
     for(int i=0; i<count; i++){
         for(int j=0; j<dimension; j++){
             os << *c++ << " ";
         }
         os << endl;
     }
     return os;
 }//operator<<
 
diff --git a/src/libqhullrcpp/PointCoordinates.h b/src/libqhullpcpp/PointCoordinates.h
similarity index 98%
rename from src/libqhullrcpp/PointCoordinates.h
rename to src/libqhullpcpp/PointCoordinates.h
index 6fb322c..7f6e27a 100644
--- a/src/libqhullrcpp/PointCoordinates.h
+++ b/src/libqhullpcpp/PointCoordinates.h
@@ -1,149 +1,149 @@
 /****************************************************************************
 **
 ** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/PointCoordinates.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/PointCoordinates.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHPOINTCOORDINATES_H
 #define QHPOINTCOORDINATES_H
 
 #include "QhullPoints.h"
 #include "Coordinates.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <ostream>
 #include <vector>
 
 namespace orgQhull {
 
 #//Types
     //! Zero or more points with Coordinates, count, and dimension
     class PointCoordinates;
 
 class PointCoordinates : public QhullPoints {
 
 private:
 #//Field
     Coordinates         point_coordinates;      //! array of point coordinates
                                                 //! may have extraCoordinates()
     std::string         point_comment;          //! Comment describing PointCoordinates
 
 public:
 #//Construct
                         PointCoordinates();
     explicit            PointCoordinates(int pointDimension);
     explicit            PointCoordinates(const std::string &aComment);
                         PointCoordinates(int pointDimension, const std::string &aComment);
                         PointCoordinates(int pointDimension, const std::string &aComment, int coordinatesCount, const coordT *c); // may be invalid
                         //! Use append() and appendPoints() for Coordinates and vector<coordT>
                         PointCoordinates(const PointCoordinates &other);
     PointCoordinates   &operator=(const PointCoordinates &other);
     ~PointCoordinates();
 
 #//Convert
     //! QhullPoints coordinates, constData, data, count, size
 #ifndef QHULL_NO_STL
     void                append(const std::vector<coordT> &otherCoordinates) { if(!otherCoordinates.empty()){ append((int)otherCoordinates.size(), &otherCoordinates[0]); } }
     std::vector<coordT> toStdVector() const { return point_coordinates.toStdVector(); }
 #endif //QHULL_NO_STL
 #ifdef QHULL_USES_QT
     void                append(const QList<coordT> &pointCoordinates) { if(!pointCoordinates.isEmpty()){ append(pointCoordinates.count(), &pointCoordinates[0]); } }
     QList<coordT>       toQList() const { return point_coordinates.toQList(); }
 #endif //QHULL_USES_QT
 
 #//GetSet
     //! See QhullPoints for coordinates, coordinateCount, dimension, empty, isEmpty, ==, !=
     void                checkValid() const;
     std::string         comment() const { return point_comment; }
     void                makeValid() { defineAs(point_coordinates.count(), point_coordinates.data()); }
     const Coordinates  &getCoordinates() const { return point_coordinates; }
     void                setComment(const std::string &s) { point_comment= s; }
     void                setDimension(int i);
 
 private:
     void                defineAs(int coordinatesCount, coordT *c) { QhullPoints::defineAs(coordinatesCount, c); }
     //! defineAs() otherwise disabled
 public:
 
 #//ElementAccess
     //! See QhullPoints for at, back, first, front, last, mid, [], value
 
 #//Foreach
     //! See QhullPoints for begin, constBegin, end
     Coordinates::ConstIterator  beginCoordinates() const { return point_coordinates.begin(); }
     Coordinates::Iterator       beginCoordinates() { return point_coordinates.begin(); }
     Coordinates::ConstIterator  beginCoordinates(int pointIndex) const;
     Coordinates::Iterator       beginCoordinates(int pointIndex);
     Coordinates::ConstIterator  endCoordinates() const { return point_coordinates.end(); }
     Coordinates::Iterator       endCoordinates() { return point_coordinates.end(); }
 
 #//Search
     //! See QhullPoints for contains, count, indexOf, lastIndexOf
 
 #//Read-only
     PointCoordinates    operator+(const PointCoordinates &other) const;
 
 #//Modify
     //FIXUP QH11001: Add clear() and other modify operators from Coordinates.h.  Include QhullPoint::operator=()
     void                append(int coordinatesCount, const coordT *c);  //! Dimension previously defined
     void                append(const coordT &c) { append(1, &c); } //! Dimension previously defined
     void                append(const QhullPoint &p);
     //! See convert for std::vector and QList
     void                append(const Coordinates &c) { append(c.count(), c.data()); }
     void                append(const PointCoordinates &other);
     void                appendComment(const std::string &s);
     void                appendPoints(std::istream &in);
     PointCoordinates   &operator+=(const PointCoordinates &other) { append(other); return *this; }
     PointCoordinates   &operator+=(const coordT &c) { append(c); return *this; }
     PointCoordinates   &operator+=(const QhullPoint &p) { append(p); return *this; }
     PointCoordinates   &operator<<(const PointCoordinates &other) { return *this += other; }
     PointCoordinates   &operator<<(const coordT &c) { return *this += c; }
     PointCoordinates   &operator<<(const QhullPoint &p) { return *this += p; }
     // reserve() is non-const
     void                reserveCoordinates(int newCoordinates);
 
 #//Helpers
 private:
     int                 indexOffset(int i) const;
 
 };//PointCoordinates
 
 // No references to QhullPoint.  Prevents use of QHULL_DECLARE_SEQUENTIAL_ITERATOR(PointCoordinates, QhullPoint)
 class PointCoordinatesIterator
 {
     typedef PointCoordinates::const_iterator const_iterator;
     const PointCoordinates *c;
     const_iterator i;
     public:
     inline PointCoordinatesIterator(const PointCoordinates &container)
     : c(&container), i(c->constBegin()) {}
     inline PointCoordinatesIterator &operator=(const PointCoordinates &container)
     { c = &container; i = c->constBegin(); return *this; }
     inline void toFront() { i = c->constBegin(); }
     inline void toBack() { i = c->constEnd(); }
     inline bool hasNext() const { return i != c->constEnd(); }
     inline const QhullPoint next() { return *i++; }
     inline const QhullPoint peekNext() const { return *i; }
     inline bool hasPrevious() const { return i != c->constBegin(); }
     inline const QhullPoint previous() { return *--i; }
     inline const QhullPoint peekPrevious() const { const_iterator p = i; return *--p; }
     inline bool findNext(const QhullPoint &t)
     { while (i != c->constEnd()) if (*i++ == t) return true; return false; }
     inline bool findPrevious(const QhullPoint &t)
     { while (i != c->constBegin()) if (*(--i) == t) return true;
     return false;  }
 };//CoordinatesIterator
 
 // FIXUP QH11002:  Add MutablePointCoordinatesIterator after adding modify operators
 \
 }//namespace orgQhull
 
 #//Global functions
 
 std::ostream           &operator<<(std::ostream &os, const orgQhull::PointCoordinates &p);
 
 #endif // QHPOINTCOORDINATES_H
diff --git a/src/libqhullrcpp/Qhull.cpp b/src/libqhullpcpp/Qhull.cpp
similarity index 98%
rename from src/libqhullrcpp/Qhull.cpp
rename to src/libqhullpcpp/Qhull.cpp
index 00cbcbe..e19e241 100644
--- a/src/libqhullrcpp/Qhull.cpp
+++ b/src/libqhullpcpp/Qhull.cpp
@@ -1,543 +1,543 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/Qhull.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/Qhull.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! Qhull -- invoke qhull from C++
 #//! Compile libqhull and Qhull together due to use of setjmp/longjmp()
 
 #include "QhullError.h"
 #include "UsingLibQhull.h"
 #include "RboxPoints.h"
 #include "QhullQh.h"
 #include "QhullFacet.h"
 #include "QhullFacetList.h"
 #include "Qhull.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <iostream>
 
 using std::cerr;
 using std::string;
 using std::vector;
 using std::ostream;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  // interaction between '_setjmp' and C++ object destruction is non-portable
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//Global variables
 
 char s_unsupported_options[]=" Fd TI ";
 char s_not_output_options[]= " Fd TI A C d E H P Qb QbB Qbb Qc Qf Qg Qi Qm QJ Qr QR Qs Qt Qv Qx Qz Q0 Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 R Tc TC TM TP TR Tv TV TW U v V W ";
 
 #//Constructor, destructor, etc.
 Qhull::
 Qhull()
 : qhull_qh(0)
 , qhull_run_id(UsingLibQhull::NOqhRunId)
 , origin_point()
 , qhull_status(qh_ERRnone)
 , qhull_dimension(0)
 , run_called(false)
 , qh_active(false)
 , qhull_message()
 , error_stream(0)
 , output_stream(0)
 , feasiblePoint()
 , useOutputStream(false)
 {
     initializeQhull();
 }//Qhull
 
 Qhull::
 Qhull(const RboxPoints &rboxPoints, const char *qhullCommand2)
 : qhull_qh(0)
 , qhull_run_id(UsingLibQhull::NOqhRunId)
 , origin_point()
 , qhull_status(qh_ERRnone)
 , qhull_dimension(0)
 , run_called(false)
 , qh_active(false)
 , qhull_message()
 , error_stream(0)
 , output_stream(0)
 , feasiblePoint()
 , useOutputStream(false)
 {
     initializeQhull();
     runQhull(rboxPoints, qhullCommand2);
 }//Qhull rbox
 
 Qhull::
 Qhull(const char *rboxCommand2, int pointDimension, int pointCount, const realT *pointCoordinates, const char *qhullCommand2)
 : qhull_qh(0)
 , qhull_run_id(UsingLibQhull::NOqhRunId)
 , origin_point()
 , qhull_status(qh_ERRnone)
 , qhull_dimension(0)
 , run_called(false)
 , qh_active(false)
 , qhull_message()
 , error_stream(0)
 , output_stream(0)
 , feasiblePoint()
 , useOutputStream(false)
 {
     initializeQhull();
     runQhull(rboxCommand2, pointDimension, pointCount, pointCoordinates, qhullCommand2);
 }//Qhull points
 
 Qhull::
 Qhull(const Qhull &other)
 : qhull_qh(0)
 , qhull_run_id(UsingLibQhull::NOqhRunId)
 , origin_point()
 , qhull_status(qh_ERRnone)
 , qhull_dimension(0)
 , run_called(false)
 , qh_active(false)
 , qhull_message(other.qhull_message)
 , error_stream(other.error_stream)
 , output_stream(other.output_stream)
 , feasiblePoint(other.feasiblePoint)
 , useOutputStream(other.useOutputStream)
 {
     if(other.initialized()){
         throw QhullError(10069, "Qhull error: can not use Qhull copy constructor if initialized() is true");
     }
     initializeQhull();
 }//copy constructor
 
 Qhull & Qhull::
 operator=(const Qhull &other)
 {
     if(other.initialized() || initialized()){
         throw QhullError(10070, "Qhull error: can not use Qhull copy assignment if initialized() is true");
     }
     qhull_message= other.qhull_message;
     error_stream= other.error_stream;
     output_stream= other.output_stream;
     feasiblePoint= other.feasiblePoint;
     useOutputStream= other.useOutputStream;
     return *this;
 }//copy constructor
 
 void Qhull::
 initializeQhull()
 {
     #if qh_QHpointer
         qhull_qh= new QhullQh;
         qhull_qh->old_qhstat= qh_qhstat;
         qhull_qh->old_tempstack= qhmem.tempstack;
         qh_qh= 0;
         qh_qhstat= 0;
     #else
         qhull_qh= new (&qh_qh) QhullQh;
         qhull_qh->old_qhstat= &qh_qhstat;
         qhull_qh->old_tempstack= qhmem.tempstack;
     #endif
     qhmem.tempstack= 0;
     qhull_run_id= qhull_qh->run_id;
 }//initializeQhull
 
 Qhull::
 ~Qhull() throw()
 {
     //! UsingLibQhull is required by ~QhullQh
     UsingLibQhull q(this, QhullError::NOthrow);
     if(q.defined()){
         int exitCode = setjmp(qh errexit);
         if(!exitCode){ // no object creation -- destructors skipped on longjmp()
 #if qh_QHpointer
             delete qhull_qh;
             // clears qhull_qh and qh_qh
             qh_qh= 0;
 #else
             qhull_qh->~QhullQh();
             qhull_qh= 0;
 #endif
             qhull_run_id= UsingLibQhull::NOqhRunId;
             // Except for cerr, does not throw errors
             if(hasQhullMessage()){
                 cerr<< "\nQhull output at end\n"; //FIXUP QH11005: where should error and log messages go on ~Qhull?
                 cerr<<qhullMessage();
                 clearQhullMessage();
             }
         }
         maybeThrowQhullMessage(exitCode, QhullError::NOthrow);
     }
     s_qhull_output= 0; // Set by UsingLibQhull
 }//~Qhull
 
 #//Messaging
 
 void Qhull::
 appendQhullMessage(const string &s)
 {
     if(output_stream && useOutputStream && qh USEstdout){   // threading errors caught elsewhere
         *output_stream << s;
     }else if(error_stream){
         *error_stream << s;
     }else{
         qhull_message += s;
     }
 }//appendQhullMessage
 
 //! clearQhullMessage does not throw errors (~Qhull)
 void Qhull::
 clearQhullMessage()
 {
     qhull_status= qh_ERRnone;
     qhull_message.clear();
     RoadError::clearGlobalLog();
 }//clearQhullMessage
 
 //! hasQhullMessage does not throw errors (~Qhull)
 bool Qhull::
 hasQhullMessage() const
 {
     return (!qhull_message.empty() || qhull_status!=qh_ERRnone);
     //FIXUP QH11006 -- inconsistent usage with Rbox.  hasRboxMessage just tests rbox_status.  No appendRboxMessage()
 }
 
 //! qhullMessage does not throw errors (~Qhull)
 std::string Qhull::
 qhullMessage() const
 {
     if(qhull_message.empty() && qhull_status!=qh_ERRnone){
         return "qhull: no message for error.  Check cerr or error stream\n";
     }else{
         return qhull_message;
     }
 }//qhullMessage
 
 int Qhull::
 qhullStatus() const
 {
     return qhull_status;
 }//qhullStatus
 
 void Qhull::
 setErrorStream(ostream *os)
 {
     error_stream= os;
 }//setErrorStream
 
 //! Updates useOutputStream
 void Qhull::
 setOutputStream(ostream *os)
 {
     output_stream= os;
     useOutputStream= (os!=0);
 }//setOutputStream
 
 #//GetSet
 
 void Qhull::
 checkIfQhullInitialized()
 {
     if(!initialized()){ // qh_initqhull_buffers() not called
         throw QhullError(10023, "Qhull error: checkIfQhullInitialized failed.  Call runQhull() first.");
     }
 }//checkIfQhullInitialized
 
 //! Setup global state (qh_qh, qh_qhstat, qhmem.tempstack)
 int Qhull::
 runId()
 {
     UsingLibQhull u(this);
     QHULL_UNUSED(u);
 
     return qhull_run_id;
 }//runId
 
 
 #//GetValue
 
 double Qhull::
 area(){
     checkIfQhullInitialized();
     UsingLibQhull q(this);
     if(!qh hasAreaVolume){
         int exitCode = setjmp(qh errexit);
         if(!exitCode){ // no object creation -- destructors skipped on longjmp()
             qh_getarea(qh facet_list);
         }
         maybeThrowQhullMessage(exitCode);
     }
     return qh totarea;
 }//area
 
 double Qhull::
 volume(){
     checkIfQhullInitialized();
     UsingLibQhull q(this);
     if(!qh hasAreaVolume){
         int exitCode = setjmp(qh errexit);
         if(!exitCode){ // no object creation -- destructors skipped on longjmp()
             qh_getarea(qh facet_list);
         }
         maybeThrowQhullMessage(exitCode);
     }
     return qh totvol;
 }//volume
 
 #//ForEach
 
 //! Define QhullVertex::neighborFacets().
 //! Automatically called if merging facets or computing the Voronoi diagram.
 //! Noop if called multiple times.
 void Qhull::
 defineVertexNeighborFacets(){
     checkIfQhullInitialized();
     UsingLibQhull q(this);
     if(!qh hasAreaVolume){
         int exitCode = setjmp(qh errexit);
         if(!exitCode){ // no object creation -- destructors skipped on longjmp()
             qh_vertexneighbors();
         }
         maybeThrowQhullMessage(exitCode);
     }
 }//defineVertexNeighborFacets
 
 QhullFacetList Qhull::
 facetList() const{
     return QhullFacetList(beginFacet(), endFacet());
 }//facetList
 
 QhullPoints Qhull::
 points() const
 {
     return QhullPoints(hullDimension(), qhull_qh->num_points*hullDimension(), qhull_qh->first_point);
 }//points
 
 QhullPointSet Qhull::
 otherPoints() const
 {
     return QhullPointSet(hullDimension(), qhull_qh->other_points);
 }//otherPoints
 
 //! Return vertices of the convex hull.
 QhullVertexList Qhull::
 vertexList() const{
     return QhullVertexList(beginVertex(), endVertex());
 }//vertexList
 
 #//Modify
 
 void Qhull::
 outputQhull()
 {
     checkIfQhullInitialized();
     UsingLibQhull q(this);
     int exitCode = setjmp(qh errexit);
     if(!exitCode){ // no object creation -- destructors skipped on longjmp()
         qh_produce_output2();
     }
     maybeThrowQhullMessage(exitCode);
 }//outputQhull
 
 void Qhull::
 outputQhull(const char *outputflags)
 {
     checkIfQhullInitialized();
     UsingLibQhull q(this);
     string cmd(" "); // qh_checkflags skips first word
     cmd += outputflags;
     char *command= const_cast<char*>(cmd.c_str());
     int exitCode = setjmp(qh errexit);
     if(!exitCode){ // no object creation -- destructors skipped on longjmp()
         qh_clear_outputflags();
         char *s = qh qhull_command + strlen(qh qhull_command) + 1; //space
         strncat(qh qhull_command, command, sizeof(qh qhull_command)-strlen(qh qhull_command)-1);
         qh_checkflags(command, s_not_output_options);
         qh_initflags(s);
         qh_initqhull_outputflags();
         if(qh KEEPminArea < REALmax/2
            || (0 != qh KEEParea + qh KEEPmerge + qh GOODvertex
                     + qh GOODthreshold + qh GOODpoint + qh SPLITthresholds)){
             facetT *facet;
             qh ONLYgood= False;
             FORALLfacet_(qh facet_list) {
                 facet->good= True;
             }
             qh_prepare_output();
         }
         qh_produce_output2();
         if(qh VERIFYoutput && !qh STOPpoint && !qh STOPcone){
             qh_check_points();
         }
     }
     maybeThrowQhullMessage(exitCode);
 }//outputQhull
 
 void Qhull::
 runQhull(const RboxPoints &rboxPoints, const char *qhullCommand2)
 {
     runQhull(rboxPoints.comment().c_str(), rboxPoints.dimension(), rboxPoints.count(), &*rboxPoints.coordinates(), qhullCommand2);
 }//runQhull, RboxPoints
 
 //! points is a array of points, input sites ('d' or 'v'), or halfspaces with offset last ('H')
 //! Derived from qh_new_qhull [user.c]
 void Qhull::
 runQhull(const char *rboxCommand2, int pointDimension, int pointCount, const realT *rboxPoints, const char *qhullCommand2)
 {
     if(run_called){
         throw QhullError(10027, "Qhull error: runQhull called twice.  Only one call allowed.");
     }
     run_called= true;
     string s("qhull ");
     s += qhullCommand2;
     char *command= const_cast<char*>(s.c_str());
     UsingLibQhull q(this);
     int exitCode = setjmp(qh errexit);
     if(!exitCode){ // no object creation -- destructors skipped on longjmp()
         qh_checkflags(command, s_unsupported_options);
         qh_initflags(command);
         *qh rbox_command= '\0';
         strncat( qh rbox_command, rboxCommand2, sizeof(qh rbox_command)-1);
         if(qh DELAUNAY){
             qh PROJECTdelaunay= True;   // qh_init_B() calls qh_projectinput()
         }
         pointT *newPoints= const_cast<pointT*>(rboxPoints);
         int newDimension= pointDimension;
         int newIsMalloc= False;
         if(qh HALFspace){
             --newDimension;
             initializeFeasiblePoint(newDimension);
             newPoints= qh_sethalfspace_all(pointDimension, pointCount, newPoints, qh feasible_point);
             newIsMalloc= True;
         }
         qh_init_B(newPoints, pointCount, newDimension, newIsMalloc);
         qhull_dimension= (qh DELAUNAY ? qh hull_dim - 1 : qh hull_dim);
         qh_qhull();
         qh_check_output();
         qh_prepare_output();
         if(qh VERIFYoutput && !qh STOPpoint && !qh STOPcone){
             qh_check_points();
         }
     }
     for(int k= qhull_dimension; k--; ){  // Do not move up (may throw)
         origin_point << 0.0;
     }
     maybeThrowQhullMessage(exitCode);
 }//runQhull
 
 #//Helpers -- be careful of allocating C++ objects due to setjmp/longjmp() error handling by qh_... routines
 
 void Qhull::
 initializeFeasiblePoint(int hulldim)
 {
     if(qh feasible_string){
         qh_setfeasible(hulldim);
     }else{
         if(feasiblePoint.empty()){
             qh_fprintf(qh ferr, 6209, "qhull error: missing feasible point for halfspace intersection.  Use option 'Hn,n' or set qh.feasiblePoint\n");
             qh_errexit(qh_ERRmem, NULL, NULL);
         }
         if(feasiblePoint.size()!=(size_t)hulldim){
             qh_fprintf(qh ferr, 6210, "qhull error: dimension of feasiblePoint should be %d.  It is %u", hulldim, feasiblePoint.size());
             qh_errexit(qh_ERRmem, NULL, NULL);
         }
         if (!(qh feasible_point= (coordT*)qh_malloc(hulldim * sizeof(coordT)))) {
             qh_fprintf(qh ferr, 6202, "qhull error: insufficient memory for feasible point\n");
             qh_errexit(qh_ERRmem, NULL, NULL);
         }
         coordT *t= qh feasible_point;
         // No qh_... routines after here -- longjmp() ignores destructor
         for(Coordinates::ConstIterator p=feasiblePoint.begin(); p<feasiblePoint.end(); p++){
             *t++= *p;
         }
     }
 }//initializeFeasiblePoint
 
 void Qhull::
 maybeThrowQhullMessage(int exitCode)
 {
     if(qhull_status==qh_ERRnone){
         qhull_status= exitCode;
     }
     if(qhull_status!=qh_ERRnone){
         QhullError e(qhull_status, qhull_message);
         clearQhullMessage();
         throw e; // FIXUP QH11007: copy constructor is expensive if logging
     }
 }//maybeThrowQhullMessage
 
 void Qhull::
 maybeThrowQhullMessage(int exitCode, int noThrow)  throw()
 {
     QHULL_UNUSED(noThrow);
 
     if(qhull_status==qh_ERRnone){
         qhull_status= exitCode;
     }
     if(qhull_status!=qh_ERRnone){
         QhullError e(qhull_status, qhull_message);
         e.logError();
     }
 }//maybeThrowQhullMessage
 
 }//namespace orgQhull
 
 /*-<a                             href="qh-user.htm#TOC"
  >-------------------------------</a><a name="qh_fprintf">-</a>
 
   qh_fprintf(fp, msgcode, format, list of args )
     fp is ignored (replaces qh_fprintf() in userprintf.c)
     s_qhull_output == Qhull
 
 notes:
     only called from libqhull
     same as fprintf() and RboxPoints::qh_fprintf_rbox()
     fgets() is not trapped like fprintf()
     Do not throw errors from here.  Use qh_errexit;
 */
 extern "C"
 void qh_fprintf(FILE *fp, int msgcode, const char *fmt, ... ) {
     va_list args;
 
     using namespace orgQhull;
 
     if(!s_qhull_output){
         fprintf(stderr, "QH10025 Qhull error: UsingLibQhull not declared prior to calling qh_...().  s_qhull_output==NULL.\n");
         qh_exit(10025);
     }
     Qhull *out= s_qhull_output;
     va_start(args, fmt);
     if(msgcode<MSG_OUTPUT || fp == qh_FILEstderr){
         if(msgcode>=MSG_ERROR && msgcode<MSG_WARNING){
             if(out->qhull_status<MSG_ERROR || out->qhull_status>=MSG_WARNING){
                 out->qhull_status= msgcode;
             }
         }
         char newMessage[MSG_MAXLEN];
         // RoadError will add the message tag
         vsnprintf(newMessage, sizeof(newMessage), fmt, args);
         out->appendQhullMessage(newMessage);
         va_end(args);
         return;
     }
     if(out->output_stream && out->useOutputStream){
         char newMessage[MSG_MAXLEN];
         vsnprintf(newMessage, sizeof(newMessage), fmt, args);
         *out->output_stream << newMessage;
         va_end(args);
         return;
     }
     // FIXUP QH11008: how do users trap messages and handle input?  A callback?
     char newMessage[MSG_MAXLEN];
     vsnprintf(newMessage, sizeof(newMessage), fmt, args);
     out->appendQhullMessage(newMessage);
     va_end(args);
 } /* qh_fprintf */
 
diff --git a/src/libqhullrcpp/Qhull.h b/src/libqhullpcpp/Qhull.h
similarity index 98%
rename from src/libqhullrcpp/Qhull.h
rename to src/libqhullpcpp/Qhull.h
index 5025191..cc8c4c0 100644
--- a/src/libqhullrcpp/Qhull.h
+++ b/src/libqhullpcpp/Qhull.h
@@ -1,147 +1,147 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/Qhull.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/Qhull.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLCPP_H
 #define QHULLCPP_H
 
 #include "QhullQh.h"
 #include "RboxPoints.h"
 #include "QhullLinkedList.h"
 #include "QhullPoint.h"
 #include "QhullPoints.h"
 #include "QhullVertex.h"
 #include "QhullFacet.h"
 
 #include <stdarg.h>
 #include <string>
 #include <vector>
 #include <sstream>
 #include <iostream>
 
 #if qh_QHpointer != 1
 #error  qh_QHpointer is not set.  Please set it in user.h or
 #error  compile Qhull with -Dqh_QHpointer.  The C++ classes
 #error  require dynamic allocation for Qhulls global data
 #error  structure qhT (QhullQh).
 #endif
 
 namespace orgQhull {
 
 /***
    Compile qhullcpp and libqhull with the same compiler.  setjmp() and longjmp() must be the same.
 */
 
 #//Types
     //! Qhull -- run Qhull from C++
     class Qhull;
 
     //Defined elsewhere
     class QhullFacetList;
     class RboxPoints;
 
 class Qhull {
 
 private:
 #//Members and friends
     QhullQh            *qhull_qh;       //! qh_qh for this instance
     int                 qhull_run_id;    //! qh.run_id at initialization (catch multiple runs if !qh_QHpointer)
     Coordinates         origin_point;   //! origin for qhull_dimension.  Set by runQhull()
     int                 qhull_status;   //! qh_ERRnone if valid
     int                 qhull_dimension; //! Dimension of result (qh.hull_dim or one less for Delaunay/Voronoi)
     bool                run_called;     //! True at start of runQhull.  Errors if call again.
     bool                qh_active;      //! True if global pointer qh_qh equals qhull_qh
     std::string         qhull_message;
     std::ostream       *error_stream;   //! overrides errorMessage, use appendQhullMessage()
     std::ostream       *output_stream;  //! send output to stream
 
     friend void       ::qh_fprintf(FILE *fp, int msgcode, const char *fmt, ... );
     friend class        UsingLibQhull;
 
 #//Attribute
 public:
     Coordinates         feasiblePoint;  //! feasible point for half-space intersection
     bool                useOutputStream; //! Set if using outputStream
     // FIXUP QH11003 feasiblePoint useOutputStream as field or getter?
 
 #//constructor, assignment, destructor, invariant
                         Qhull();      //! Qhull::runQhull() must be called next
                         Qhull(const RboxPoints &rboxPoints, const char *qhullCommand2);
                         Qhull(const char *rboxCommand2, int pointDimension, int pointCount, const realT *pointCoordinates, const char *qhullCommand2);
                         // Throws error if other.initialized().  Needed for return by value and parameter passing
                         Qhull(const Qhull &other);
                         // Throws error if initialized() or other.initialized().  Needed for vector<Qhull>
     Qhull              &operator=(const Qhull &other);
                        ~Qhull() throw();
 private:
     void                initializeQhull();
 
 public:
 #//virtual methods
     //FIXUP QH11004 -- qh_memfree, etc. as virtual?
 
 #//Messaging
     void                appendQhullMessage(const std::string &s);
     void                clearQhullMessage();
     std::string         qhullMessage() const;
     bool                hasQhullMessage() const;
     int                 qhullStatus() const;
     void                setErrorStream(std::ostream *os);
     void                setOutputStream(std::ostream *os);
 
 #//GetSet
     void                checkIfQhullInitialized();
     bool                initialized() const { return qhull_dimension>0; }
     int                 dimension() const { return qhull_dimension; }
     int                 hullDimension() const { return qhullQh()->hull_dim; }
                         // non-const due to QhullPoint
     QhullPoint          origin() { QHULL_ASSERT(initialized()); return QhullPoint(dimension(), origin_point.data()); }
     QhullQh            *qhullQh() const { return qhull_qh; };
     int                 runId(); // Modifies my_qhull
 
 #//GetQh -- access to qhT (Qhull's global data structure)
     const char         *qhullCommand() const { return qhull_qh->qhull_command; }
     const char         *rboxCommand() const { return qhull_qh->rbox_command; }
     int                 facetCount() const { return qhull_qh->num_facets; }
     int                 vertexCount() const { return qhull_qh->num_vertices; }
 
 #//GetValue
     double              area();
     double              volume();
 
 #//ForEach
     QhullFacet          beginFacet() const { return QhullFacet(qhull_qh->facet_list); }
     QhullVertex         beginVertex() const { return QhullVertex(qhull_qh->vertex_list); }
     void                defineVertexNeighborFacets(); //!< Automatically called if merging facets or Voronoi diagram
     QhullFacet          endFacet() const { return QhullFacet(qhull_qh->facet_tail); }
     QhullVertex         endVertex() const { return QhullVertex(qhull_qh->vertex_tail); }
     QhullFacetList      facetList() const;
     QhullFacet          firstFacet() const { return beginFacet(); }
     QhullVertex         firstVertex() const { return beginVertex(); }
     QhullPoints         points() const;
     QhullPointSet       otherPoints() const;
                         //! Same as points().coordinates()
     coordT             *pointCoordinateBegin() const { return qhull_qh->first_point; }
     coordT             *pointCoordinateEnd() const { return qhull_qh->first_point + qhull_qh->num_points*qhull_qh->hull_dim; }
     QhullVertexList     vertexList() const;
 
 #//Modify
     void                outputQhull();
     void                outputQhull(const char * outputflags);
     void                runQhull(const RboxPoints &rboxPoints, const char *qhullCommand2);
     void                runQhull(const char *rboxCommand2, int pointDimension, int pointCount, const realT *rboxPoints, const char *qhullCommand2);
 
 private:
 #//Helpers
     void                initializeFeasiblePoint(int hulldim);
     void                maybeThrowQhullMessage(int exitCode);
     void                maybeThrowQhullMessage(int exitCode, int noThrow) throw();
 };//Qhull
 
 }//namespace orgQhull
 
 #endif // QHULLCPP_H
diff --git a/src/libqhullrcpp/QhullError.h b/src/libqhullpcpp/QhullError.h
similarity index 94%
rename from src/libqhullrcpp/QhullError.h
rename to src/libqhullpcpp/QhullError.h
index 6019247..c136c76 100644
--- a/src/libqhullrcpp/QhullError.h
+++ b/src/libqhullpcpp/QhullError.h
@@ -1,64 +1,64 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullError.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullError.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLERROR_H
 #define QHULLERROR_H
 
 #include "RoadError.h"
 
 #include <assert.h>
 #include <stdexcept>
 #include <string>
 
 namespace orgQhull {
 
 #//Types
     //! QhullError -- std::exception class for Qhull
     class QhullError;
 
 class QhullError : public RoadError {
 
 public:
 #//Constants
     enum {
         QHULLfirstError= 10000, //MSG_QHULL_ERROR in Qhull's user.h
         QHULLlastError= 10070,
         NOthrow= 1 //! For flag to UsingLibQhull()
     };
 
 #//Constructors
     // default constructors
     QhullError() : RoadError() {};
     QhullError(const QhullError &other) : RoadError(other) {}
     QhullError(int code, const std::string &message) : RoadError(code, message) {};
     QhullError(int code, const char *fmt) : RoadError(code, fmt) {};
     QhullError(int code, const char *fmt, int d) : RoadError(code, fmt, d) {};
     QhullError(int code, const char *fmt, int d, int d2) : RoadError(code, fmt, d, d2) {};
     QhullError(int code, const char *fmt, int d, int d2, float f) : RoadError(code, fmt, d, d2, f) {};
     QhullError(int code, const char *fmt, int d, int d2, float f, const char *s) : RoadError(code, fmt, d, d2, f, s) {};
     QhullError(int code, const char *fmt, int d, int d2, float f, const void *x) : RoadError(code, fmt, d, d2, f, x) {};
     QhullError(int code, const char *fmt, int d, int d2, float f, int i) : RoadError(code, fmt, d, d2, f, i) {};
     QhullError(int code, const char *fmt, int d, int d2, float f, long long i) : RoadError(code, fmt, d, d2, f, i) {};
     QhullError(int code, const char *fmt, int d, int d2, float f, double e) : RoadError(code, fmt, d, d2, f, e) {};
     QhullError &operator=(const QhullError &other) { this->RoadError::operator=(other); return *this; }
     ~QhullError() throw() {}
 
 };//class QhullError
 
 #ifndef QHULL_1
     #define QHULL_ASSERT assert
 
 #endif
 
 }//namespace orgQhull
 
 #//Global functions
 
 inline std::ostream &operator<<(std::ostream &os, const orgQhull::QhullError &e) { return os << e.what(); }
 
 #endif // QHULLERROR_H
diff --git a/src/libqhullrcpp/QhullFacet.cpp b/src/libqhullpcpp/QhullFacet.cpp
similarity index 98%
rename from src/libqhullrcpp/QhullFacet.cpp
rename to src/libqhullpcpp/QhullFacet.cpp
index fdd6468..6a0583e 100644
--- a/src/libqhullrcpp/QhullFacet.cpp
+++ b/src/libqhullpcpp/QhullFacet.cpp
@@ -1,524 +1,524 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullFacet.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullFacet.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullFacet -- Qhull's facet structure, facetT, as a C++ class
 
 #include "QhullError.h"
 #include "QhullSet.h"
 #include "QhullPoint.h"
 #include "QhullPointSet.h"
 #include "QhullRidge.h"
 #include "QhullFacet.h"
 #include "QhullFacetSet.h"
 #include "QhullVertex.h"
 
 #include <ostream>
 
 using std::endl;
 using std::string;
 using std::vector;
 using std::ostream;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  // interaction between '_setjmp' and C++ object destruction is non-portable
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//class statics
 facetT QhullFacet::
         s_empty_facet= {0,0,0,0,{0},
                 0,0,0,0,0,
                 0,0,0,0,0,
                 0,0,0,0,0,
                 0,0,0,0,0,
                 0,0,0,0,0,
                 0,0,0,0,0,
                 0,0,0,0};
 
 #//GetSet
 
 int QhullFacet::
 dimension() const
 {
     if(qh_facet->ridges){
         setT *s= qh_facet->ridges;
         ridgeT *r= reinterpret_cast<ridgeT *>(SETfirst_(s));
         return r ? QhullSetBase::count(r->vertices)+1 : 0;
     }else{
         return QhullSetBase::count(qh_facet->vertices);
     }
 }//dimension
 
 //! Return voronoi center or facet centrum.  Derived from qh_printcenter [io.c]
 //! printFormat=qh_PRINTtriangles if return centrum of a Delaunay facet
 //! Sets center if needed
 //! Code duplicated for PrintCenter and getCenter
 //! .empty() if none or qh_INFINITE
 QhullPoint QhullFacet::
 getCenter(int qhRunId, qh_PRINT printFormat)
 {
     UsingLibQhull q(qhRunId);
 
     if(qh CENTERtype==qh_ASvoronoi){
         if(!qh_facet->normal || !qh_facet->upperdelaunay || !qh ATinfinity){
             if(!qh_facet->center){
                 int exitCode = setjmp(qh errexit);
                 if(!exitCode){ // no object creation -- destructors skipped on longjmp()
                     qh_facet->center= qh_facetcenter(qh_facet->vertices);
                 }
                 q.maybeThrowQhullMessage(exitCode);
             }
             return QhullPoint(qh hull_dim-1, qh_facet->center);
         }
     }else if(qh CENTERtype==qh_AScentrum){
         volatile int numCoords= qh hull_dim;
         if(printFormat==qh_PRINTtriangles && qh DELAUNAY){
             numCoords--;
         }
         if(!qh_facet->center){
             int exitCode = setjmp(qh errexit);
             if(!exitCode){ // no object creation -- destructors skipped on longjmp()
                 qh_facet->center= qh_getcentrum(getFacetT());
             }
             q.maybeThrowQhullMessage(exitCode);
         }
         return QhullPoint(numCoords, qh_facet->center);
     }
     return QhullPoint();
  }//getCenter
 
 //! Return innerplane clearly below the vertices
 //! from io.c[qh_PRINTinner]
 QhullHyperplane QhullFacet::
 innerplane(int qhRunId) const{
     UsingLibQhull q(qhRunId);
     realT inner;
     // Does not error
     qh_outerinner(const_cast<facetT *>(getFacetT()), NULL, &inner);
     QhullHyperplane h= hyperplane();
     h.setOffset(h.offset()-inner); //inner is negative
     return h;
 }//innerplane
 
 //! Return outerplane clearly above all points
 //! from io.c[qh_PRINTouter]
 QhullHyperplane QhullFacet::
 outerplane(int qhRunId) const{
     UsingLibQhull q(qhRunId);
     realT outer;
     // Does not error
     qh_outerinner(const_cast<facetT *>(getFacetT()), &outer, NULL);
     QhullHyperplane h= hyperplane();
     h.setOffset(h.offset()-outer); //outer is positive
     return h;
 }//outerplane
 
 //! Set by qh_triangulate for option 'Qt'.
 //! Errors if tricoplanar and facetArea() or qh_getarea() called first.
 QhullFacet QhullFacet::
 tricoplanarOwner() const
 {
     if(qh_facet->tricoplanar){
         if(qh_facet->isarea){
             throw QhullError(10018, "Qhull error: facetArea() or qh_getarea() previously called.  triCoplanarOwner() is not available.");
         }
         return qh_facet->f.triowner;
     }
     return 0; // FIXUP QH11009 Should false be the NULL facet or empty facet
 }//tricoplanarOwner
 
 QhullPoint QhullFacet::
 voronoiVertex(int qhRunId)
 {
     if(
 #if qh_QHpointer
       !qh_qh ||
 #endif
       qh CENTERtype!=qh_ASvoronoi){
           throw QhullError(10052, "Error: QhullFacet.voronoiVertex() requires option 'v' (qh_ASvoronoi)");
     }
     return getCenter(qhRunId);
 }//voronoiVertex
 
 #//Value
 
 //! Disables tricoplanarOwner()
 double QhullFacet::
 facetArea(int qhRunId)
 {
     if(!qh_facet->isarea){
         UsingLibQhull q(qhRunId);
         int exitCode = setjmp(qh errexit);
         if(!exitCode){ // no object creation -- destructors skipped on longjmp()
             qh_facet->f.area= qh_facetarea(qh_facet);
             qh_facet->isarea= True;
         }
         q.maybeThrowQhullMessage(exitCode);
     }
     return qh_facet->f.area;
 }//facetArea
 
 #//Foreach
 
 QhullPointSet QhullFacet::
 coplanarPoints() const
 {
     return QhullPointSet(dimension(), qh_facet->coplanarset);
 }//coplanarPoints
 
 QhullFacetSet QhullFacet::
 neighborFacets() const
 {
     return QhullFacetSet(qh_facet->neighbors);
 }//neighborFacets
 
 QhullPointSet QhullFacet::
 outsidePoints() const
 {
     return QhullPointSet(dimension(), qh_facet->outsideset);
 }//outsidePoints
 
 QhullRidgeSet QhullFacet::
 ridges() const
 {
     return QhullRidgeSet(qh_facet->ridges);
 }//ridges
 
 QhullVertexSet QhullFacet::
 vertices() const
 {
     return QhullVertexSet(qh_facet->vertices);
 }//vertices
 
 
 }//namespace orgQhull
 
 #//operator<<
 
 using std::ostream;
 
 using orgQhull::QhullFacet;
 using orgQhull::QhullFacetSet;
 using orgQhull::QhullPoint;
 using orgQhull::QhullPointSet;
 using orgQhull::QhullRidge;
 using orgQhull::QhullRidgeSet;
 using orgQhull::QhullSetBase;
 using orgQhull::QhullVertexSet;
 using orgQhull::UsingLibQhull;
 
 ostream &
 operator<<(ostream &os, const QhullFacet::PrintFacet &pr)
 {
     QhullFacet f= *pr.facet;
     if(f.getFacetT()==0){ // Special values from set iterator
         os << " NULLfacet" << endl;
         return os;
     }
     if(f.getFacetT()==qh_MERGEridge){
         os << " MERGEridge" << endl;
         return os;
     }
     if(f.getFacetT()==qh_DUPLICATEridge){
         os << " DUPLICATEridge" << endl;
         return os;
     }
     os << f.printHeader(pr.run_id);
     if(!f.ridges().isEmpty()){
         os << f.printRidges(pr.run_id);
     }
     return os;
 }//operator<< PrintFacet
 
 //! Print Voronoi center or facet centrum to stream.  Same as qh_printcenter [io.c]
 //! Code duplicated for PrintCenter and getCenter
 //! Sets center if needed
 ostream &
 operator<<(ostream &os, const QhullFacet::PrintCenter &pr)
 {
     facetT *f= pr.facet->getFacetT();
     if(qh CENTERtype!=qh_ASvoronoi && qh CENTERtype!=qh_AScentrum){
         return os;
     }
     if (pr.message){
         os << pr.message;
     }
     int numCoords;
     if(qh CENTERtype==qh_ASvoronoi){
         numCoords= qh hull_dim-1;
         if(!f->normal || !f->upperdelaunay || !qh ATinfinity){
             if(!f->center){
                 f->center= qh_facetcenter(f->vertices);
             }
             for(int k=0; k<numCoords; k++){
                 os << f->center[k] << " "; // FIXUP QH11010 qh_REAL_1
             }
         }else{
             for(int k=0; k<numCoords; k++){
                 os << qh_INFINITE << " "; // FIXUP QH11010 qh_REAL_1
             }
         }
     }else{ // qh CENTERtype==qh_AScentrum
         numCoords= qh hull_dim;
         if(pr.print_format==qh_PRINTtriangles && qh DELAUNAY){
             numCoords--;
         }
         if(!f->center){
             f->center= qh_getcentrum(f);
         }
         for(int k=0; k<numCoords; k++){
             os << f->center[k] << " "; // FIXUP QH11010 qh_REAL_1
         }
     }
     if(pr.print_format==qh_PRINTgeom && numCoords==2){
         os << " 0";
     }
     os << endl;
     return os;
 }//operator<< PrintCenter
 
 //! Print flags for facet to stream.  Space prefix.  From qh_printfacetheader [io.c]
 ostream &
 operator<<(ostream &os, const QhullFacet::PrintFlags &p)
 {
     const facetT *f= p.facet->getFacetT();
     if(p.message){
         os << p.message;
     }
 
     os << (p.facet->isTopOrient() ? " top" : " bottom");
     if(p.facet->isSimplicial()){
         os << " simplicial";
     }
     if(p.facet->isTriCoplanar()){
         os << " tricoplanar";
     }
     if(p.facet->isUpperDelaunay()){
         os << " upperDelaunay";
     }
     if(f->visible){
         os << " visible";
     }
     if(f->newfacet){
         os << " new";
     }
     if(f->tested){
         os << " tested";
     }
     if(!f->good){
         os << " notG";
     }
     if(f->seen){
         os << " seen";
     }
     if(f->coplanar){
         os << " coplanar";
     }
     if(f->mergehorizon){
         os << " mergehorizon";
     }
     if(f->keepcentrum){
         os << " keepcentrum";
     }
     if(f->dupridge){
         os << " dupridge";
     }
     if(f->mergeridge && !f->mergeridge2){
         os << " mergeridge1";
     }
     if(f->mergeridge2){
         os << " mergeridge2";
     }
     if(f->newmerge){
         os << " newmerge";
     }
     if(f->flipped){
         os << " flipped";
     }
     if(f->notfurthest){
         os << " notfurthest";
     }
     if(f->degenerate){
         os << " degenerate";
     }
     if(f->redundant){
         os << " redundant";
     }
     os << endl;
     return os;
 }//operator<< PrintFlags
 
 //! Print header for facet to stream. Space prefix.  From qh_printfacetheader [io.c]
 ostream &
 operator<<(ostream &os, const QhullFacet::PrintHeader &pr)
 {
     QhullFacet facet= *pr.facet;
     facetT *f= facet.getFacetT();
     os << "- f" << facet.id() << endl;
     os << facet.printFlags("    - flags:");
     if(f->isarea){
         os << "    - area: " << f->f.area << endl; //FIXUP QH11010 2.2g
     }else if(qh NEWfacets && f->visible && f->f.replace){
         os << "    - replacement: f" << f->f.replace->id << endl;
     }else if(f->newfacet){
         if(f->f.samecycle && f->f.samecycle != f){
             os << "    - shares same visible/horizon as f" << f->f.samecycle->id << endl;
         }
     }else if(f->tricoplanar /* !isarea */){
         if(f->f.triowner){
             os << "    - owner of normal & centrum is facet f" << f->f.triowner->id << endl;
         }
     }else if(f->f.newcycle){
         os << "    - was horizon to f" << f->f.newcycle->id << endl;
     }
     if(f->nummerge){
         os << "    - merges: " << f->nummerge << endl;
     }
     os << facet.hyperplane().print("    - normal: ", "\n    - offset: "); // FIXUP QH11010 %10.7g
     if(qh CENTERtype==qh_ASvoronoi || f->center){
         os << facet.printCenter(pr.run_id, qh_PRINTfacets, "    - center: ");
     }
 #if qh_MAXoutside
     if(f->maxoutside > qh DISTround){
         os << "    - maxoutside: " << f->maxoutside << endl; //FIXUP QH11010 %10.7g
     }
 #endif
     QhullPointSet ps= facet.outsidePoints();
     if(!ps.isEmpty()){
         QhullPoint furthest= ps.last();
         if (ps.size() < 6) {
             os << "    - outside set(furthest p" << furthest.id(pr.run_id) << "):" << endl;
             for(QhullPointSet::iterator i=ps.begin(); i!=ps.end(); ++i){
                 QhullPoint p= *i;
                 os << p.print(pr.run_id, "     ");
             }
         }else if(ps.size()<21){
             os << ps.print(pr.run_id, "    - outside set:");
         }else{
             os << "    - outside set:  " << ps.size() << " points.";
             os << furthest.print(pr.run_id, "  Furthest");
         }
 #if !qh_COMPUTEfurthest
         os << "    - furthest distance= " << f->furthestdist << endl; //FIXUP QH11010 %2.2g
 #endif
     }
     QhullPointSet cs= facet.coplanarPoints();
     if(!cs.isEmpty()){
         QhullPoint furthest= cs.last();
         if (cs.size() < 6) {
             os << "    - coplanar set(furthest p" << furthest.id(pr.run_id) << "):" << endl;
             for(QhullPointSet::iterator i=cs.begin(); i!=cs.end(); ++i){
                 QhullPoint p= *i;
                 os << p.print(pr.run_id, "     ");
             }
         }else if(cs.size()<21){
             os << cs.print(pr.run_id, "    - coplanar set:");
         }else{
             os << "    - coplanar set:  " << cs.size() << " points.";
             os << furthest.print(pr.run_id, "  Furthest");
         }
         zinc_(Zdistio);
         double d= facet.distance(furthest);
         os << "      furthest distance= " << d << endl; //FIXUP QH11010 %2.2g
     }
     QhullVertexSet vs= facet.vertices();
     if(!vs.isEmpty()){
         os << vs.print(pr.run_id, "    - vertices:");
     }
     QhullFacetSet fs= facet.neighborFacets();
     fs.selectAll();
     if(!fs.isEmpty()){
         os << fs.printIdentifiers("    - neighboring facets:");
     }
     return os;
 }//operator<< PrintHeader
 
 
 //! Print ridges of facet to stream.  Same as qh_printfacetridges [io.c]
 //! If qhRunId==UsingLibQhull::NOqhRunId, does not use qh
 ostream &
 operator<<(ostream &os, const QhullFacet::PrintRidges &pr)
 {
     const QhullFacet facet= *pr.facet;
     facetT *f= facet.getFacetT();
     QhullRidgeSet rs= facet.ridges();
     if(!rs.isEmpty()){
         if(pr.run_id!=UsingLibQhull::NOqhRunId){
             UsingLibQhull q(pr.run_id);
             // No calls to libqhull
             if(f->visible && qh NEWfacets){
                 os << "    - ridges(ids may be garbage):";
                 for(QhullRidgeSet::iterator i=rs.begin(); i!=rs.end(); ++i){
                     QhullRidge r= *i;
                     os << " r" << r.id();
                 }
                 os << endl;
             }else{
                 os << "    - ridges:" << endl;
             }
         }else{
             os << "    - ridges:" << endl;
         }
 
         // Keep track of printed ridges
         for(QhullRidgeSet::iterator i=rs.begin(); i!=rs.end(); ++i){
             QhullRidge r= *i;
             r.getRidgeT()->seen= false;
         }
         int ridgeCount= 0;
         if(facet.dimension()==3){
             for(QhullRidge r= rs.first(); !r.getRidgeT()->seen; r= r.nextRidge3d(facet)){
                 r.getRidgeT()->seen= true;
                 os << r.print(pr.run_id);
                 ++ridgeCount;
                 if(!r.hasNextRidge3d(facet)){
                     break;
                 }
             }
         }else {
             QhullFacetSet ns(facet.neighborFacets());
             for(QhullFacetSet::iterator i=ns.begin(); i!=ns.end(); ++i){
                 QhullFacet neighbor= *i;
                 QhullRidgeSet nrs(neighbor.ridges());
                 for(QhullRidgeSet::iterator j=nrs.begin(); j!=nrs.end(); ++j){
                     QhullRidge r= *j;
                     if(r.otherFacet(neighbor)==facet){
                         r.getRidgeT()->seen= true;
                         os << r.print(pr.run_id);
                         ridgeCount++;
                     }
                 }
             }
         }
         if(ridgeCount!=rs.count()){
             os << "     - all ridges:";
             for(QhullRidgeSet::iterator i=rs.begin(); i!=rs.end(); ++i){
                 QhullRidge r= *i;
                 os << " r" << r.id();
             }
             os << endl;
         }
         for(QhullRidgeSet::iterator i=rs.begin(); i!=rs.end(); ++i){
             QhullRidge r= *i;
             if(!r.getRidgeT()->seen){
                 os << r.print(pr.run_id);
             }
         }
     }
     return os;
 }//operator<< PrintRidges
 
 // "No conversion" error if defined inline
 ostream &
 operator<<(ostream &os, QhullFacet &f)
 {
     os << f.print(UsingLibQhull::NOqhRunId);
     return os;
 }//<< QhullFacet
diff --git a/src/libqhullrcpp/QhullFacet.h b/src/libqhullpcpp/QhullFacet.h
similarity index 98%
rename from src/libqhullrcpp/QhullFacet.h
rename to src/libqhullpcpp/QhullFacet.h
index c310db0..a183196 100644
--- a/src/libqhullrcpp/QhullFacet.h
+++ b/src/libqhullpcpp/QhullFacet.h
@@ -1,155 +1,155 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullFacet.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullFacet.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLFACET_H
 #define QHULLFACET_H
 
 #include "Coordinates.h"
 #include "QhullHyperplane.h"
 #include "QhullPoint.h"
 #include "QhullSet.h"
 #include "QhullPointSet.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <string>
 #include <vector>
 #include <ostream>
 
 namespace orgQhull {
 
 #//ClassRef
     class QhullFacetSet;
     class QhullRidge;
     typedef QhullSet<QhullRidge>  QhullRidgeSet;
     class QhullVertex;
     class QhullVertexSet;
 
 #//Types
     //! QhullFacet -- Qhull's facet structure, facetT [libqhull.h], as a C++ class
     class QhullFacet;
 
 //! A QhullFacet is the C++ equivalent to Qhull's facetT*
 class QhullFacet {
 
 private:
 #//Fields -- no additions (QhullFacetSet of facetT*)
     facetT             *qh_facet;  //! May be 0 (!isDefined) for corner cases (e.g., *facetSet.end()==0) and tricoplanarOwner()
 
 #//Class objects
     static facetT       s_empty_facet; // needed for shallow copy
 
 public:
 #//Constants
 
 #//Constructors
                         QhullFacet() : qh_facet(&s_empty_facet) {}
                         // Creates an alias.  Does not copy QhullFacet.  Needed for return by value and parameter passing
                         QhullFacet(const QhullFacet &o) : qh_facet(o.qh_facet ? o.qh_facet : &s_empty_facet) {}
                         // Creates an alias.  Does not copy QhullFacet.  Needed for vector<QhullFacet>
     QhullFacet         &operator=(const QhullFacet &o) { qh_facet= o.qh_facet ? o.qh_facet : &s_empty_facet; return *this; }
                        ~QhullFacet() {}
 
 #//Conversion
                         //Implicit conversion from facetT
                         QhullFacet(facetT *f) : qh_facet(f ? f : &s_empty_facet) {}
                         // Do not define facetT().  It conflicts with return type facetT*
     facetT             *getFacetT() const { return qh_facet; }
 
 #//QhullSet<QhullFacet>
     facetT             *getBaseT() const { return getFacetT(); }
 
 #//getSet
     int                 dimension() const;
     QhullPoint          getCenter(int qhRunId) { return getCenter(qhRunId, qh_PRINTpoints); }
     QhullPoint          getCenter(int qhRunId, qh_PRINT printFormat);
     QhullHyperplane     hyperplane() const { return QhullHyperplane(dimension(), qh_facet->normal, qh_facet->offset); }
     int                 id() const { return qh_facet ? qh_facet->id : -1; }
     QhullHyperplane     innerplane(int qhRunId) const;
     bool                isDefined() const { return qh_facet && qh_facet != &s_empty_facet; }
     bool                isGood() const { return qh_facet && qh_facet->good; }
     bool                isSimplicial() const { return qh_facet->simplicial; }
     bool                isTopOrient() const { return qh_facet->toporient; }
     bool                isTriCoplanar() const { return qh_facet->tricoplanar; }
     bool                isUpperDelaunay() const { return qh_facet->upperdelaunay; }
     QhullFacet          next() const { return qh_facet->next; }
     bool                operator==(const QhullFacet &o) const { return qh_facet==o.qh_facet; }
     bool                operator!=(const QhullFacet &o) const { return !operator==(o); }
     QhullHyperplane     outerplane(int qhRunId) const;
     QhullFacet          previous() const { return qh_facet->previous; }
     QhullFacet          tricoplanarOwner() const;
     QhullPoint          voronoiVertex(int qhRunId);
 
 #//value
     //! Undefined if c.size() != dimension()
     double              distance(const Coordinates &c) const { return distance(c.data()); }
     double              distance(const pointT *p) const { return distance(QhullPoint(dimension(), const_cast<coordT *>(p))); }
     double              distance(const QhullPoint &p) const { return hyperplane().distance(p); }
     double              facetArea(int qhRunId);
 
 #//foreach
     // Can not inline.  Otherwise circular reference
     QhullPointSet       coplanarPoints() const;
     QhullFacetSet       neighborFacets() const;
     QhullPointSet       outsidePoints() const;
     QhullRidgeSet       ridges() const;
     QhullVertexSet      vertices() const;
 
 #//IO
     struct PrintCenter{
         QhullFacet     *facet;  // non-const due to facet.center()
         const char     *message;
         int             run_id;
         qh_PRINT        print_format;
                         PrintCenter(int qhRunId, QhullFacet &f, qh_PRINT printFormat, const char * s) : facet(&f), message(s), run_id(qhRunId), print_format(printFormat){}
     };//PrintCenter
     PrintCenter         printCenter(int qhRunId, qh_PRINT printFormat, const char *message) { return PrintCenter(qhRunId, *this, printFormat, message); }
 
     struct PrintFacet{
         QhullFacet     *facet;  // non-const due to f->center()
         int             run_id;
                         PrintFacet(int qhRunId, QhullFacet &f) : facet(&f), run_id(qhRunId) {}
     };//PrintFacet
     PrintFacet          print(int qhRunId) { return PrintFacet(qhRunId, *this); }
 
     struct PrintFlags{
         const QhullFacet *facet;
         const char     *message;
                         PrintFlags(const QhullFacet &f, const char *s) : facet(&f), message(s) {}
     };//PrintFlags
     PrintFlags          printFlags(const char *message) const { return PrintFlags(*this, message); }
 
     struct PrintHeader{
         QhullFacet     *facet;  // non-const due to f->center()
         int             run_id;
                         PrintHeader(int qhRunId, QhullFacet &f) : facet(&f), run_id(qhRunId) {}
     };//PrintHeader
     PrintHeader         printHeader(int qhRunId) { return PrintHeader(qhRunId, *this); }
 
     struct PrintRidges{
         const QhullFacet *facet;
         int             run_id;
                         PrintRidges(int qhRunId, QhullFacet &f) : facet(&f), run_id(qhRunId) {}
     };//PrintRidges
     PrintRidges         printRidges(int qhRunId) { return PrintRidges(qhRunId, *this); }
 
 };//class QhullFacet
 
 }//namespace orgQhull
 
 #//Global functions
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacet::PrintCenter &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacet::PrintFlags &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacet::PrintHeader &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacet::PrintRidges &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacet::PrintFacet &pr);
 std::ostream &operator<<(std::ostream &os, orgQhull::QhullFacet &f); // non-const due to qh_getcenter()
 
 #endif // QHULLFACET_H
diff --git a/src/libqhullrcpp/QhullFacetList.cpp b/src/libqhullpcpp/QhullFacetList.cpp
similarity index 95%
rename from src/libqhullrcpp/QhullFacetList.cpp
rename to src/libqhullpcpp/QhullFacetList.cpp
index 05f2422..22d4052 100644
--- a/src/libqhullrcpp/QhullFacetList.cpp
+++ b/src/libqhullpcpp/QhullFacetList.cpp
@@ -1,164 +1,164 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullFacetList.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullFacetList.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullFacetList -- Qhull's linked facets, as a C++ class
 
 #include "QhullFacet.h"
 #include "QhullFacetList.h"
 #include "QhullPoint.h"
 #include "QhullRidge.h"
 #include "QhullVertex.h"
 
 using std::string;
 using std::vector;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  // interaction between '_setjmp' and C++ object destruction is non-portable
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//Conversion
 
 // See qt_qhull.cpp for QList conversions
 
 #ifndef QHULL_NO_STL
 std::vector<QhullFacet> QhullFacetList::
 toStdVector() const
 {
     QhullLinkedListIterator<QhullFacet> i(*this);
     std::vector<QhullFacet> vs;
     while(i.hasNext()){
         QhullFacet f= i.next();
         if(isSelectAll() || f.isGood()){
             vs.push_back(f);
         }
     }
     return vs;
 }//toStdVector
 #endif //QHULL_NO_STL
 
 #ifndef QHULL_NO_STL
 //! Same as PrintVertices
 std::vector<QhullVertex> QhullFacetList::
 vertices_toStdVector(int qhRunId) const
 {
     std::vector<QhullVertex> vs;
     QhullVertexSet qvs(qhRunId, first().getFacetT(), NULL, isSelectAll());
 
     for(QhullVertexSet::iterator i=qvs.begin(); i!=qvs.end(); ++i){
         vs.push_back(*i);
     }
     return vs;
 }//vertices_toStdVector
 #endif //QHULL_NO_STL
 
 #//Read-only
 
 bool QhullFacetList::
 contains(const QhullFacet &facet) const
 {
     if(isSelectAll()){
         return QhullLinkedList<QhullFacet>::contains(facet);
     }
     for(QhullFacetList::const_iterator i=begin(); i != end(); ++i){
         QhullFacet f= *i;
         if(f==facet && f.isGood()){
             return true;
         }
     }
     return false;
 }//contains
 
 int QhullFacetList::
 count() const
 {
     if(isSelectAll()){
         return QhullLinkedList<QhullFacet>::count();
     }
     int counter= 0;
     for(QhullFacetList::const_iterator i=begin(); i != end(); ++i){
         if((*i).isGood()){
             counter++;
         }
     }
     return counter;
 }//count
 
 int QhullFacetList::
 count(const QhullFacet &facet) const
 {
     if(isSelectAll()){
         return QhullLinkedList<QhullFacet>::count(facet);
     }
     int counter= 0;
     for(QhullFacetList::const_iterator i=begin(); i != end(); ++i){
         QhullFacet f= *i;
         if(f==facet && f.isGood()){
             counter++;
         }
     }
     return counter;
 }//count
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::ostream;
 using orgQhull::QhullFacet;
 using orgQhull::QhullFacetList;
 using orgQhull::QhullVertex;
 using orgQhull::QhullVertexSet;
 using orgQhull::UsingLibQhull;
 
 ostream &
 operator<<(ostream &os, const QhullFacetList::PrintFacetList &pr)
 {
     QhullFacetList fs= *pr.facet_list;
     os << "Vertices for " << fs.count() << " facets" << endl;
     os << fs.printVertices(pr.run_id);
     os << fs.printFacets(pr.run_id);
     return os;
 }//operator<<
 
 //! Print facet list to stream.  From qh_printafacet [io.c]
 ostream &
 operator<<(ostream &os, const QhullFacetList::PrintFacets &pr)
 {
     for(QhullFacetList::const_iterator i= pr.facet_list->begin(); i != pr.facet_list->end(); ++i){
         QhullFacet f= *i;
         if(pr.facet_list->isSelectAll() || f.isGood()){
             os << f.print(pr.run_id);
         }
     }
     return os;
 }//printFacets
 
 //! Print vertices of good faces in facet list to stream.  From qh_printvertexlist [io.c]
 //! Same as vertices_toStdVector
 ostream &
 operator<<(ostream &os, const QhullFacetList::PrintVertices &pr)
 {
     QhullVertexSet vs(pr.run_id, pr.facet_list->first().getFacetT(), NULL, pr.facet_list->isSelectAll());
     for(QhullVertexSet::iterator i=vs.begin(); i!=vs.end(); ++i){
         QhullVertex v= *i;
         os << v.print(pr.run_id);
     }
     return os;
 }//printVertices
 
 std::ostream &
 operator<<(ostream &os, const QhullFacetList &fs)
 {
     os << fs.printFacets(UsingLibQhull::NOqhRunId);
     return os;
 }//QhullFacetList
 
diff --git a/src/libqhullrcpp/QhullFacetList.h b/src/libqhullpcpp/QhullFacetList.h
similarity index 96%
rename from src/libqhullrcpp/QhullFacetList.h
rename to src/libqhullpcpp/QhullFacetList.h
index 1c1d9fb..afe510e 100644
--- a/src/libqhullrcpp/QhullFacetList.h
+++ b/src/libqhullpcpp/QhullFacetList.h
@@ -1,102 +1,102 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullFacetList.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullFacetList.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLFACETLIST_H
 #define QHULLFACETLIST_H
 
 #include "QhullLinkedList.h"
 #include "QhullFacet.h"
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//ClassRef
     class               QhullFacet;
 
 #//Types
     //! QhullFacetList -- List of Qhull facets, as a C++ class.  See QhullFacetSet.h
     class               QhullFacetList;
     //! QhullFacetListIterator -- if(f.isGood()){ ... }
     typedef QhullLinkedListIterator<QhullFacet>
                         QhullFacetListIterator;
 
 class QhullFacetList : public QhullLinkedList<QhullFacet> {
 
 #// Fields
 private:
     bool                select_all;   //! True if include bad facets.  Default is false.
 
 #//Constructors
 public:
                         QhullFacetList(QhullFacet b, QhullFacet e) : QhullLinkedList<QhullFacet>(b, e), select_all(false) {}
                         //Copy constructor copies pointer but not contents.  Needed for return by value and parameter passing.
                         QhullFacetList(const QhullFacetList &o) : QhullLinkedList<QhullFacet>(*o.begin(), *o.end()), select_all(o.select_all) {}
                        ~QhullFacetList() {}
 
 private:
                         //!Disable default constructor and copy assignment.  See QhullLinkedList
                         QhullFacetList();
     QhullFacetList     &operator=(const QhullFacetList &);
 public:
 
 #//Conversion
 #ifndef QHULL_NO_STL
     std::vector<QhullFacet> toStdVector() const;
     std::vector<QhullVertex> vertices_toStdVector(int qhRunId) const;
 #endif //QHULL_NO_STL
 #ifdef QHULL_USES_QT
     QList<QhullFacet>   toQList() const;
     QList<QhullVertex>  vertices_toQList(int qhRunId) const;
 #endif //QHULL_USES_QT
 
 #//GetSet
     bool                isSelectAll() const { return select_all; }
     void                selectAll() { select_all= true; }
     void                selectGood() { select_all= false; }
 
 #//Read-only
                         //! Filtered by facet.isGood().  May be 0 when !isEmpty().
     int                 count() const;
     bool                contains(const QhullFacet &f) const;
     int                 count(const QhullFacet &f) const;
                         //! operator==() does not depend on isGood()
 
 #//IO
     struct PrintFacetList{
         const QhullFacetList *facet_list;
         int             run_id;
                         PrintFacetList(int qhRunId, const QhullFacetList &fl) : facet_list(&fl), run_id(qhRunId) {}
     };//PrintFacetList
     PrintFacetList     print(int qhRunId) const  { return PrintFacetList(qhRunId, *this); }
 
     struct PrintFacets{
         const QhullFacetList *facet_list;
         int             run_id;
                         PrintFacets(int qhRunId, const QhullFacetList &fl) : facet_list(&fl), run_id(qhRunId) {}
     };//PrintFacets
     PrintFacets     printFacets(int qhRunId) const { return PrintFacets(qhRunId, *this); }
 
     struct PrintVertices{
         const QhullFacetList *facet_list;
         int             run_id;   //! Can not be NOrunId due to qh_facetvertices
                         PrintVertices(int qhRunId, const QhullFacetList &fl) : facet_list(&fl), run_id(qhRunId) {}
     };//PrintVertices
     PrintVertices   printVertices(int qhRunId) const { return PrintVertices(qhRunId, *this); }
 };//class QhullFacetList
 
 }//namespace orgQhull
 
 #//== Global namespace =========================================
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacetList::PrintFacetList &p);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacetList::PrintFacets &p);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacetList::PrintVertices &p);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacetList &fs);
 
 #endif // QHULLFACETLIST_H
diff --git a/src/libqhullrcpp/QhullFacetSet.cpp b/src/libqhullpcpp/QhullFacetSet.cpp
similarity index 94%
rename from src/libqhullrcpp/QhullFacetSet.cpp
rename to src/libqhullpcpp/QhullFacetSet.cpp
index 2dd843b..d8e684c 100644
--- a/src/libqhullrcpp/QhullFacetSet.cpp
+++ b/src/libqhullpcpp/QhullFacetSet.cpp
@@ -1,145 +1,145 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullFacetSet.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullFacetSet.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullFacetSet -- Qhull's linked facets, as a C++ class
 
 #include "QhullFacet.h"
 #include "QhullFacetSet.h"
 #include "QhullPoint.h"
 #include "QhullRidge.h"
 #include "QhullVertex.h"
 
 using std::string;
 using std::vector;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  // interaction between '_setjmp' and C++ object destruction is non-portable
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//Conversion
 
 // See qt-qhull.cpp for QList conversions
 
 #ifndef QHULL_NO_STL
 std::vector<QhullFacet> QhullFacetSet::
 toStdVector() const
 {
     QhullSetIterator<QhullFacet> i(*this);
     std::vector<QhullFacet> vs;
     while(i.hasNext()){
         QhullFacet f= i.next();
         if(isSelectAll() || f.isGood()){
             vs.push_back(f);
         }
     }
     return vs;
 }//toStdVector
 #endif //QHULL_NO_STL
 
 #//Read-only
 
 bool QhullFacetSet::
 contains(const QhullFacet &facet) const
 {
     if(isSelectAll()){
         return QhullSet<QhullFacet>::contains(facet);
     }
     for(QhullFacetSet::const_iterator i=begin(); i != end(); ++i){
         QhullFacet f= *i;
         if(f==facet && f.isGood()){
             return true;
         }
     }
     return false;
 }//contains
 
 int QhullFacetSet::
 count() const
 {
     if(isSelectAll()){
         return QhullSet<QhullFacet>::count();
     }
     int counter= 0;
     for(QhullFacetSet::const_iterator i=begin(); i != end(); ++i){
         QhullFacet f= *i;
         if(f.isGood()){
             counter++;
         }
     }
     return counter;
 }//count
 
 int QhullFacetSet::
 count(const QhullFacet &facet) const
 {
     if(isSelectAll()){
         return QhullSet<QhullFacet>::count(facet);
     }
     int counter= 0;
     for(QhullFacetSet::const_iterator i=begin(); i != end(); ++i){
         QhullFacet f= *i;
         if(f==facet && f.isGood()){
             counter++;
         }
     }
     return counter;
 }//count
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::ostream;
 using orgQhull::QhullFacet;
 using orgQhull::QhullFacetSet;
 using orgQhull::UsingLibQhull;
 
 ostream &
 operator<<(ostream &os, const QhullFacetSet &fs)
 {
     os << fs.print(UsingLibQhull::NOqhRunId, "");
     return os;
 }//<<QhullFacetSet
 
 ostream &
 
 operator<<(ostream &os, const QhullFacetSet::PrintFacetSet &pr)
 {
     QhullFacetSet fs= *pr.facet_set;
     for(QhullFacetSet::iterator i=fs.begin(); i != fs.end(); ++i){
         QhullFacet f= *i;
         if(fs.isSelectAll() || f.isGood()){
             os << f.print(pr.run_id);
         }
     }
     return os;
 }//<< QhullFacetSet::PrintFacetSet
 
 //! Print facet identifiers to stream.  Space prefix.  From qh_printfacetheader [io.c]
 ostream &
 operator<<(ostream &os, const QhullFacetSet::PrintIdentifiers &p)
 {
     os << p.print_message;
     for(QhullFacetSet::const_iterator i=p.facet_set->begin(); i!=p.facet_set->end(); ++i){
         const QhullFacet f= *i;
         if(f.getFacetT()==qh_MERGEridge){
             os << " MERGE";
         }else if(f.getFacetT()==qh_DUPLICATEridge){
             os << " DUP";
         }else if(p.facet_set->isSelectAll() || f.isGood()){
             os << " f" << f.id();
         }
     }
     os << endl;
     return os;
 }//<<QhullFacetSet::PrintIdentifiers
 
diff --git a/src/libqhullrcpp/QhullFacetSet.h b/src/libqhullpcpp/QhullFacetSet.h
similarity index 96%
rename from src/libqhullrcpp/QhullFacetSet.h
rename to src/libqhullpcpp/QhullFacetSet.h
index 99daac3..95af11c 100644
--- a/src/libqhullrcpp/QhullFacetSet.h
+++ b/src/libqhullpcpp/QhullFacetSet.h
@@ -1,94 +1,94 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullFacetSet.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullFacetSet.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLFACETSET_H
 #define QHULLFACETSET_H
 
 #include "QhullSet.h"
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//ClassRef
     class               QhullFacet;
 
 #//Types
     //! QhullFacetSet -- a set of Qhull facets, as a C++ class.  See QhullFacetList.h
     class               QhullFacetSet;
     typedef QhullSetIterator<QhullFacet>
                         QhullFacetSetIterator;
 
 class QhullFacetSet : public QhullSet<QhullFacet> {
 
 private:
 #//Fields
     bool                select_all;   //! True if include bad facets.  Default is false.
 
 public:
 #//Constructor
                         //Conversion from setT* is not type-safe.  Implicit conversion for void* to T
    explicit             QhullFacetSet(setT *s) : QhullSet<QhullFacet>(s), select_all(false) {}
                         //Copy constructor copies pointer but not contents.  Needed for return by value and parameter passing.
                         QhullFacetSet(const QhullFacetSet &o) : QhullSet<QhullFacet>(o), select_all(o.select_all) {}
 
 private:
                         //!Disable default constructor and copy assignment.  See QhullSetBase
                         QhullFacetSet();
     QhullFacetSet      &operator=(const QhullFacetSet &);
 public:
 
 #//Conversion
 #ifndef QHULL_NO_STL
     std::vector<QhullFacet> toStdVector() const;
 #endif //QHULL_NO_STL
 #ifdef QHULL_USES_QT
     QList<QhullFacet>   toQList() const;
 #endif //QHULL_USES_QT
 
 #//GetSet
     bool                isSelectAll() const { return select_all; }
     void                selectAll() { select_all= true; }
     void                selectGood() { select_all= false; }
 
 #//Read-only
                         //! Filtered by facet.isGood().  May be 0 when !isEmpty().
     int                 count() const;
     bool                contains(const QhullFacet &f) const;
     int                 count(const QhullFacet &f) const;
                         //! operator==() does not depend on isGood()
 
 #//IO
     // Not same as QhullFacetList#IO.  A QhullFacetSet is a component of a QhullFacetList.
 
     struct PrintFacetSet{
         const QhullFacetSet *facet_set;
         const char     *print_message;
         int             run_id;
                         PrintFacetSet(int qhRunId, const char *message, const QhullFacetSet *s) : facet_set(s), print_message(message), run_id(qhRunId) {}
     };//PrintFacetSet
     const PrintFacetSet       print(int qhRunId, const char *message) const { return PrintFacetSet(qhRunId, message, this); }
 
     struct PrintIdentifiers{
         const QhullFacetSet *facet_set;
         const char     *print_message;
                         PrintIdentifiers(const char *message, const QhullFacetSet *s) : facet_set(s), print_message(message) {}
     };//PrintIdentifiers
     PrintIdentifiers    printIdentifiers(const char *message) const { return PrintIdentifiers(message, this); }
 
 };//class QhullFacetSet
 
 }//namespace orgQhull
 
 #//== Global namespace =========================================
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacetSet &fs);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacetSet::PrintFacetSet &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullFacetSet::PrintIdentifiers &p);
 
 #endif // QHULLFACETSET_H
diff --git a/src/libqhullrcpp/QhullHyperplane.cpp b/src/libqhullpcpp/QhullHyperplane.cpp
similarity index 95%
rename from src/libqhullrcpp/QhullHyperplane.cpp
rename to src/libqhullpcpp/QhullHyperplane.cpp
index 4cba3c3..efaf4e9 100644
--- a/src/libqhullrcpp/QhullHyperplane.cpp
+++ b/src/libqhullpcpp/QhullHyperplane.cpp
@@ -1,166 +1,166 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullHyperplane.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullHyperplane.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include "QhullHyperplane.h"
 #include "QhullPoint.h"
 
 #include <iostream>
 
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//Conversion
 
 // See qt-qhull.cpp for QList conversions
 
 #ifndef QHULL_NO_STL
 std::vector<coordT> QhullHyperplane::
 toStdVector() const
 {
     QhullHyperplaneIterator i(*this);
     std::vector<coordT> fs;
     while(i.hasNext()){
         fs.push_back(i.next());
     }
     fs.push_back(hyperplane_offset);
     return fs;
 }//toStdVector
 #endif //QHULL_NO_STL
 
 #//Value
 
 //! Return distance from point to hyperplane.
 //!   If greater than zero, the point is above the facet (i.e., outside).
 // qh_distplane [geom.c], QhullFacet::distance, and QhullHyperplane::distance are copies
 //    Does not support RANDOMdist or logging
 double QhullHyperplane::
 distance(const QhullPoint &p) const
 {
     const coordT *point= p.coordinates();
     int dim= p.dimension();
     QHULL_ASSERT(dim==dimension());
     const coordT *normal= coordinates();
     double dist;
 
     switch (dim){
   case 2:
       dist= offset() + point[0] * normal[0] + point[1] * normal[1];
       break;
   case 3:
       dist= offset() + point[0] * normal[0] + point[1] * normal[1] + point[2] * normal[2];
       break;
   case 4:
       dist= offset()+point[0]*normal[0]+point[1]*normal[1]+point[2]*normal[2]+point[3]*normal[3];
       break;
   case 5:
       dist= offset()+point[0]*normal[0]+point[1]*normal[1]+point[2]*normal[2]+point[3]*normal[3]+point[4]*normal[4];
       break;
   case 6:
       dist= offset()+point[0]*normal[0]+point[1]*normal[1]+point[2]*normal[2]+point[3]*normal[3]+point[4]*normal[4]+point[5]*normal[5];
       break;
   case 7:
       dist= offset()+point[0]*normal[0]+point[1]*normal[1]+point[2]*normal[2]+point[3]*normal[3]+point[4]*normal[4]+point[5]*normal[5]+point[6]*normal[6];
       break;
   case 8:
       dist= offset()+point[0]*normal[0]+point[1]*normal[1]+point[2]*normal[2]+point[3]*normal[3]+point[4]*normal[4]+point[5]*normal[5]+point[6]*normal[6]+point[7]*normal[7];
       break;
   default:
       dist= offset();
       for (int k=dim; k--; )
           dist += *point++ * *normal++;
       break;
     }
     return dist;
 }//distance
 
 double QhullHyperplane::
 norm() const {
     double d= 0.0;
     const coordT *c= coordinates();
     for (int k=dimension(); k--; ){
         d += *c * *c;
         ++c;
     }
     return sqrt(d);
 }//norm
 
 #//Operator
 
 bool QhullHyperplane::
 operator==(const QhullHyperplane &other) const
 {
     if(hyperplane_dimension!=other.hyperplane_dimension){
         return false;
     }
     double d= fabs(hyperplane_offset-other.hyperplane_offset);
     if(d>UsingLibQhull::globalDistanceEpsilon()){
         return false;
     }
     const coordT *c= hyperplane_coordinates;
     const coordT *c2= other.hyperplane_coordinates;
     if(c==c2){
         return true;
     }
     double dist2= 0.0;
     for(int k= hyperplane_dimension; k--; ){
         double diff= *c++ - *c2++;
         dist2 += diff*diff;
     }
     if(dist2 > UsingLibQhull::globalAngleEpsilon()){
         return false;
     }
     return true;
 }//operator==
 
 #//GetSet
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::ostream;
 using orgQhull::QhullHyperplane;
 using orgQhull::UsingLibQhull;
 
 #//operator<<
 
 ostream &
 operator<<(ostream &os, const QhullHyperplane &p)
 {
     os << p.print();
     return os;
 }
 
 ostream &
 operator<<(ostream &os, const QhullHyperplane::PrintHyperplane &pr)
 {
     QhullHyperplane p= *pr.hyperplane;
     if(pr.print_message){
         os << pr.print_message;
     }
     const realT *c= p.coordinates();
     for(int k=p.dimension(); k--; ){
         realT r= *c++;
         if(pr.print_message){
             os << " " << r; // FIXUP QH11010 %8.4g
         }else{
             os << " " << r; // FIXUP QH11010 qh_REAL_1
         }
     }
     if(pr.hyperplane_offset_message){
         os << pr.hyperplane_offset_message << " " << p.offset();
     }else{
         os << " " << p.offset();
     }
     os << std::endl;
     return os;
 }//PrintHyperplane
 
diff --git a/src/libqhullrcpp/QhullHyperplane.h b/src/libqhullpcpp/QhullHyperplane.h
similarity index 97%
rename from src/libqhullrcpp/QhullHyperplane.h
rename to src/libqhullpcpp/QhullHyperplane.h
index 99b4871..8655f26 100644
--- a/src/libqhullrcpp/QhullHyperplane.h
+++ b/src/libqhullpcpp/QhullHyperplane.h
@@ -1,122 +1,122 @@
 /****************************************************************************
 **
 ** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullHyperplane.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullHyperplane.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHHYPERPLANE_H
 #define QHHYPERPLANE_H
 
 #include "QhullError.h"
 #include "QhullIterator.h"
 #include "UsingLibQhull.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <ostream>
 
 namespace orgQhull {
 #//ClassRef
     class QhullPoint;
 
 #//Types
     //! QhullHyperplane as an offset, dimension, and pointer to coordinates
     class QhullHyperplane;
     //! Java-style iterator for QhullHyperplane coordinates
     class QhullHyperplaneIterator;
 
 class QhullHyperplane { // Similar to QhullPoint
 
 private:
 #//Fields
     coordT             *hyperplane_coordinates;  // Keep pointers aligned
     int                 hyperplane_dimension;
     coordT              hyperplane_offset;
 
 public:
 #//Subtypes
     typedef const coordT *                  iterator;
     typedef const coordT *                  const_iterator;
     typedef QhullHyperplane::iterator       Iterator;
     typedef QhullHyperplane::const_iterator ConstIterator;
 
 #//Construct
                         QhullHyperplane() : hyperplane_coordinates(0), hyperplane_dimension(0), hyperplane_offset(0.0) {};
                         QhullHyperplane(int hyperplaneDimension, coordT *c, coordT hyperplaneOffset) : hyperplane_coordinates(c), hyperplane_dimension(hyperplaneDimension), hyperplane_offset(hyperplaneOffset) {}
                         // Creates an alias.  Does not copy the hyperplane's coordinates.  Needed for return by value and parameter passing.
                         QhullHyperplane(const QhullHyperplane &other)  : hyperplane_coordinates(other.hyperplane_coordinates), hyperplane_dimension(other.hyperplane_dimension), hyperplane_offset(other.hyperplane_offset) {}
                         // Creates an alias.  Does not copy the hyperplane's coordinates.  Needed for vector<QhullHyperplane>
     QhullHyperplane    &operator=(const QhullHyperplane &other) { hyperplane_coordinates= other.hyperplane_coordinates; hyperplane_dimension= other.hyperplane_dimension; hyperplane_offset= other.hyperplane_offset; return *this; }
                        ~QhullHyperplane() {}
 
 #//Conversions --
 //! Includes offset at end
 #ifndef QHULL_NO_STL
     std::vector<coordT> toStdVector() const;
 #endif //QHULL_NO_STL
 #ifdef QHULL_USES_QT
     QList<coordT>       toQList() const;
 #endif //QHULL_USES_QT
 
 #//Read-only
 public:
     const coordT       *coordinates() const { return hyperplane_coordinates; }
     coordT             *coordinates() { return hyperplane_coordinates; }
     int                 dimension() const { return hyperplane_dimension; }
     bool                isDefined() const { return hyperplane_coordinates!=0 && hyperplane_dimension>0; }
     coordT              offset() const { return hyperplane_offset; }
 
 #//Define
     void                defineAs(int hyperplaneDimension, coordT *c, coordT hyperplaneOffset) { QHULL_ASSERT(hyperplaneDimension>=0); hyperplane_coordinates= c; hyperplane_dimension= hyperplaneDimension; hyperplane_offset= hyperplaneOffset; }
     //! Creates an alias to other
     void                defineAs(QhullHyperplane &other) { hyperplane_coordinates= other.coordinates(); hyperplane_dimension= other.dimension();  hyperplane_offset= other.offset(); }
     void                setCoordinates(coordT *c) { hyperplane_coordinates= c; }
     void                setDimension(int hyperplaneDimension) { hyperplane_dimension= hyperplaneDimension; }
     void                setOffset(coordT hyperplaneOffset) { hyperplane_offset= hyperplaneOffset; }
 
 #//value
     double              distance(const QhullPoint &p) const;
     double              norm() const;
 
 #//iterator
     iterator            begin() { return hyperplane_coordinates; }
     const_iterator      begin() const { return hyperplane_coordinates; }
     const_iterator      constBegin() const { return hyperplane_coordinates; }
     const_iterator      constEnd() const { return hyperplane_coordinates+hyperplane_dimension; }
     int                 count() { return dimension(); }
     iterator            end() { return hyperplane_coordinates+hyperplane_dimension; }
     const_iterator      end() const { return hyperplane_coordinates+hyperplane_dimension; }
     size_t              size() { return (size_t)dimension(); }
 
 #//Operator
     bool                operator==(const QhullHyperplane &other) const;
     bool                operator!=(const QhullHyperplane &other) const { return !operator==(other); }
     const coordT       &operator[](int idx) const { QHULL_ASSERT(idx>=0 && idx<hyperplane_dimension); return *(hyperplane_coordinates+idx); }
     coordT             &operator[](int idx) { QHULL_ASSERT(idx>=0 && idx<hyperplane_dimension); return *(hyperplane_coordinates+idx); }
 
 #//IO
     struct PrintHyperplane{
         const QhullHyperplane  *hyperplane;  
         const char     *print_message;
         const char     *hyperplane_offset_message;
                         PrintHyperplane(const char *message, const char *offsetMessage, const QhullHyperplane &p) : hyperplane(&p), print_message(message), hyperplane_offset_message(offsetMessage) {}
     };//PrintHyperplane
     PrintHyperplane          print() const { return  PrintHyperplane(0, 0, *this); }
     PrintHyperplane          print(const char *message, const char *offsetMessage) const { return PrintHyperplane(message, offsetMessage, *this); }
 
 };//QhullHyperplane
 
 QHULL_DECLARE_SEQUENTIAL_ITERATOR(QhullHyperplane, coordT)
 
 }//namespace orgQhull
 
 #//Global functions
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullHyperplane::PrintHyperplane &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullHyperplane &p); //FIXUP QH11015 -- multiple instances if define here
 
 #endif // QHHYPERPLANE_H
 
diff --git a/src/libqhullrcpp/QhullIterator.h b/src/libqhullpcpp/QhullIterator.h
similarity index 98%
rename from src/libqhullrcpp/QhullIterator.h
rename to src/libqhullpcpp/QhullIterator.h
index bc38b1c..a101886 100644
--- a/src/libqhullrcpp/QhullIterator.h
+++ b/src/libqhullpcpp/QhullIterator.h
@@ -1,171 +1,171 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullIterator.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullIterator.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLITERATOR_H
 #define QHULLITERATOR_H
 
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <assert.h>
 #include <string>
 #include <vector>
 //! Avoid dependence on <iterator>
 namespace std { struct bidirectional_iterator_tag; struct random_access_iterator_tag; }
 
 namespace orgQhull {
 
 #//Defined here
     //! QHULL_DECLARE_SEQUENTIAL_ITERATOR(C) -- Declare a Java-style iterator
     //! QHULL_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(C) -- Declare a mutable Java-style iterator
     //! QHULL_DECLARE_SET_ITERATOR(C) -- Declare a set iterator
     //! QHULL_DECLARE_MUTABLE_SET_ITERATOR(C) -- Declare a mutable set iterator
     //! Derived from Qt/core/tools/qiterator.h and qset.h/FOREACHsetelement_()
 
 // Changed c to C* as in Mutable...  Assumes c does not go away.
 #define QHULL_DECLARE_SEQUENTIAL_ITERATOR(C, T) \
     \
     class C##Iterator \
     { \
         typedef C::const_iterator const_iterator; \
         const C *c; \
         const_iterator i; \
         public: \
         inline C##Iterator(const C &container) \
         : c(&container), i(c->constBegin()) {} \
         inline C##Iterator &operator=(const C &container) \
         { c = &container; i = c->constBegin(); return *this; } \
         inline void toFront() { i = c->constBegin(); } \
         inline void toBack() { i = c->constEnd(); } \
         inline bool hasNext() const { return i != c->constEnd(); } \
         inline const T &next() { return *i++; } \
         inline const T &peekNext() const { return *i; } \
         inline bool hasPrevious() const { return i != c->constBegin(); } \
         inline const T &previous() { return *--i; } \
         inline const T &peekPrevious() const { const_iterator p = i; return *--p; } \
         inline bool findNext(const T &t) \
         { while (i != c->constEnd()) if (*i++ == t) return true; return false; } \
         inline bool findPrevious(const T &t) \
         { while (i != c->constBegin()) if (*(--i) == t) return true; \
         return false;  } \
     };//C##Iterator
 
 // Remove setShareable() from Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR
 // Uses QHULL_ASSERT (assert.h)
 // Duplicated in MutablePointIterator without insert or remove
 #define QHULL_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(C, T) \
     class Mutable##C##Iterator \
     { \
         typedef C::iterator iterator; \
         typedef C::const_iterator const_iterator; \
         C *c; \
         iterator i, n; \
         inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } \
         public: \
         inline Mutable##C##Iterator(C &container) \
         : c(&container) \
         { i = c->begin(); n = c->end(); } \
         inline ~Mutable##C##Iterator() \
         {} \
         inline Mutable##C##Iterator &operator=(C &container) \
         { c = &container; \
         i = c->begin(); n = c->end(); return *this; } \
         inline void toFront() { i = c->begin(); n = c->end(); } \
         inline void toBack() { i = c->end(); n = i; } \
         inline bool hasNext() const { return c->constEnd() != const_iterator(i); } \
         inline T &next() { n = i++; return *n; } \
         inline T &peekNext() const { return *i; } \
         inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } \
         inline T &previous() { n = --i; return *n; } \
         inline T &peekPrevious() const { iterator p = i; return *--p; } \
         inline void remove() \
         { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } \
         inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } \
         inline T &value() { QHULL_ASSERT(item_exists()); return *n; } \
         inline const T &value() const { QHULL_ASSERT(item_exists()); return *n; } \
         inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } \
         inline bool findNext(const T &t) \
         { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } \
         inline bool findPrevious(const T &t) \
         { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; \
         n = c->end(); return false;  } \
     };//Mutable##C##Iterator
 
 #define QHULL_DECLARE_SET_ITERATOR(C) \
 \
     template <class T> \
     class Qhull##C##Iterator \
     { \
         typedef typename Qhull##C<T>::const_iterator const_iterator; \
         Qhull##C<T> c; \
         const_iterator i; \
     public: \
         inline Qhull##C##Iterator(const Qhull##C<T> &container) \
         : c(container), i(c.constBegin()) {} \
         inline Qhull##C##Iterator &operator=(const Qhull##C<T> &container) \
         { c = container; i = c.constBegin(); return *this; } \
         inline void toFront() { i = c.constBegin(); } \
         inline void toBack() { i = c.constEnd(); } \
         inline bool hasNext() const { return i != c.constEnd(); } \
         inline const T &next() { return *i++; } \
         inline const T &peekNext() const { return *i; } \
         inline bool hasPrevious() const { return i != c.constBegin(); } \
         inline const T &previous() { return *--i; } \
         inline const T &peekPrevious() const { const_iterator p = i; return *--p; } \
         inline bool findNext(const T &t) \
         { while (i != c.constEnd()) if (*i++ == t) return true; return false; } \
         inline bool findPrevious(const T &t) \
         { while (i != c.constBegin()) if (*(--i) == t) return true; \
         return false;  } \
     };//Qhull##C##Iterator
 
 #define QHULL_DECLARE_MUTABLE_SET_ITERATOR(C) \
 \
 template <class T> \
 class QhullMutable##C##Iterator \
 { \
     typedef typename Qhull##C::iterator iterator; \
     typedef typename Qhull##C::const_iterator const_iterator; \
     Qhull##C *c; \
     iterator i, n; \
     inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } \
 public: \
     inline Mutable##C##Iterator(Qhull##C &container) \
         : c(&container) \
     { c->setSharable(false); i = c->begin(); n = c->end(); } \
     inline ~Mutable##C##Iterator() \
     { c->setSharable(true); } \
     inline Mutable##C##Iterator &operator=(Qhull##C &container) \
     { c->setSharable(true); c = &container; c->setSharable(false); \
       i = c->begin(); n = c->end(); return *this; } \
     inline void toFront() { i = c->begin(); n = c->end(); } \
     inline void toBack() { i = c->end(); n = i; } \
     inline bool hasNext() const { return c->constEnd() != const_iterator(i); } \
     inline T &next() { n = i++; return *n; } \
     inline T &peekNext() const { return *i; } \
     inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } \
     inline T &previous() { n = --i; return *n; } \
     inline T &peekPrevious() const { iterator p = i; return *--p; } \
     inline void remove() \
     { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } \
     inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } \
     inline T &value() { Q_ASSERT(item_exists()); return *n; } \
     inline const T &value() const { Q_ASSERT(item_exists()); return *n; } \
     inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } \
     inline bool findNext(const T &t) \
     { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } \
     inline bool findPrevious(const T &t) \
     { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; \
       n = c->end(); return false;  } \
 };//QhullMutable##C##Iterator
 
 }//namespace orgQhull
 
 #endif // QHULLITERATOR_H
 
diff --git a/src/libqhullrcpp/QhullLinkedList.h b/src/libqhullpcpp/QhullLinkedList.h
similarity index 98%
rename from src/libqhullrcpp/QhullLinkedList.h
rename to src/libqhullpcpp/QhullLinkedList.h
index d3627ff..1a83805 100644
--- a/src/libqhullrcpp/QhullLinkedList.h
+++ b/src/libqhullpcpp/QhullLinkedList.h
@@ -1,377 +1,377 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullLinkedList.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullLinkedList.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLLINKEDLIST_H
 #define QHULLLINKEDLIST_H
 
 namespace std { struct bidirectional_iterator_tag; struct random_access_iterator_tag; }
 
 #include "QhullError.h"
 
 #ifdef QHULL_USES_QT
 #include <QtCore/QList>
 #endif
 
 #ifndef QHULL_NO_STL
 #include <algorithm>
 #endif
 
 namespace orgQhull {
 
 #//Type
     //! QhullLinkedList<T> -- A linked list modeled on QLinkedList.
     //!   T is an opaque type with T(B *b), b=t.getBaseT(), t=t.next(), and t=t.prev().  The end node is a sentinel.
     //!   libqhull owns the contents.
     //!   QhullLinkedList does not define erase(), clear(), removeFirst(), removeLast(), pop_back(), pop_front(), fromStdList()
     //!   Derived from Qt/core/tools/qlinkedlist.h and libqhull.h/FORALLfacets_()
     //! QhullLinkedList<T>::const_iterator -- STL-style iterator
     //! QhullLinkedList<T>::iterator -- STL-style iterator
     //! QhullLinkedListIterator<T> -- Java-style iterator
     //!   Derived from Qt/core/tools/qiterator.h
     //!   Works with Qt's foreach keyword [Qt/src/corelib/global/qglobal.h]
 
 template <typename T>
 class QhullLinkedList
 {
 private:
 #//Fields
     T                   begin_node;
     T                   end_node;     //! Sentinel node at end of list
 
 public:
 #//Subtypes and types
     class               const_iterator;
     class               iterator;
     typedef const_iterator  ConstIterator;
     typedef iterator    Iterator;
     typedef ptrdiff_t   difference_type;
     typedef int         size_type;
     typedef T           value_type;
     typedef const value_type *const_pointer;
     typedef const value_type &const_reference;
     typedef value_type *pointer;
     typedef value_type &reference;
 
 #//Constructors
                         QhullLinkedList<T>(T b, T e) : begin_node(b), end_node(e) {}
                         //Copy constructor copies pointer but not contents.  Needed for return by value and parameter passing.
                         QhullLinkedList<T>(const QhullLinkedList<T> &o) : begin_node(o.begin_node), end_node(o.end_node) {}
                        ~QhullLinkedList<T>() {}
 
 private:
                         //!disabled since a sentinel must be allocated as the private type
                         QhullLinkedList<T>() {}
                         //!disabled since qs= qs2 is ambiguous (pointer vs. contents)
     QhullLinkedList<T> &operator=(const QhullLinkedList<T> &l) {}
 public:
 
 #//Conversions
 #ifndef QHULL_NO_STL
     std::vector<T>      toStdVector() const;
 #endif
 #ifdef QHULL_USES_QT
     QList<T>            toQList() const;
 #endif
 
 #//Read-only
     int                 count() const;
                         //count(t) under #//Search
     bool                empty() const { return isEmpty(); }
     bool                isEmpty() const { return (begin_node==end_node); }
     bool                operator==(const QhullLinkedList<T> &o) const;
     bool                operator!=(const QhullLinkedList<T> &o) const { return !operator==(o); }
     size_t              size() const { return count(); }
 
 #//Element access
     //! Return by value which contains a pointer (e.g., typedef vertexT * QhullVertex).  A reference does not make sense.
     T                   back() const { return last(); }
     T                   first() const { QHULL_ASSERT(!isEmpty()); return *begin(); }
     T                   front() const { return first(); }
     T                   last() const { QHULL_ASSERT(!isEmpty()); return *--end(); }
 
 #//Modify -- Allocation of opaque types not implemented.
 
 #//Search
     bool                contains(const T &t) const;
     int                 count(const T &t) const;
 
 #//Iterator
     iterator            begin() { return begin_node; }
     const_iterator      begin() const { return begin_node; }
     const_iterator      constBegin() const { return begin_node; }
     const_iterator      constEnd() const { return end_node; }
     iterator            end() { return end_node; }
     const_iterator      end() const { return end_node; }
 
     class iterator {
 
     private:
         T               i;
         friend class    const_iterator;
 
     public:
         typedef std::bidirectional_iterator_tag  iterator_category;
         typedef T           value_type;
         typedef value_type *pointer;
         typedef value_type &reference;
         typedef ptrdiff_t   difference_type;
 
                         iterator() : i() {}
                         iterator(T t) : i(t) {}
                         iterator(const iterator &o) : i(o.i) {}
         iterator       &operator=(const iterator &o) { i= o.i; return *this; }
 
         T               operator*() const { return i; }
         T               operator->() const { return i; }
         bool            operator==(const iterator &o) const { return i == o.i; }
         bool            operator!=(const iterator &o) const { return !operator==(o); }
         bool            operator==(const const_iterator &o) const { return i==reinterpret_cast<const iterator &>(o).i; }
         bool            operator!=(const const_iterator &o) const { return !operator==(o); }
         iterator       &operator++() { i= i.next(); return *this; }
         iterator        operator++(int) { iterator o= i; i= i.next(); return o; }
         iterator       &operator--() { i= i.previous(); return *this; }
         iterator        operator--(int) { iterator o= i; i= i.previous(); return o; }
         iterator        operator+(int j) const;
         iterator        operator-(int j) const { return operator+(-j); }
         iterator       &operator+=(int j) { return *this= *this + j; }
         iterator       &operator-=(int j) { return *this= *this - j; }
     };//QhullLinkedList::iterator
 
     class const_iterator {
 
     private:
         T               i;
 
     public:
         typedef std::bidirectional_iterator_tag  iterator_category;
         typedef T                 value_type;
         typedef const value_type *pointer;
         typedef const value_type &reference;
         typedef ptrdiff_t         difference_type;
 
                         const_iterator() : i() {}
                         const_iterator(T t) : i(t) {}
                         const_iterator(const const_iterator &o) : i(o.i) {}
                         const_iterator(iterator o) : i(o.i) {}
         const_iterator &operator=(const const_iterator &o) { i= o.i; return *this; }
 
         T               operator*() const { return i; }
         T               operator->() const { return i; }
         bool            operator==(const const_iterator &o) const { return i == o.i; }
         bool            operator!=(const const_iterator &o) const { return !operator==(o); }
                         // No comparisons or iterator diff
         const_iterator &operator++() { i= i.next(); return *this; }
         const_iterator  operator++(int) { const_iterator o= i; i= i.next(); return o; }
         const_iterator &operator--() { i= i.previous(); return *this; }
         const_iterator  operator--(int) { const_iterator o= i; i= i.previous(); return o; }
         const_iterator  operator+(int j) const;
         const_iterator  operator-(int j) const { return operator+(-j); }
         const_iterator &operator+=(int j) { return *this= *this + j; }
         const_iterator &operator-=(int j) { return *this= *this - j; }
     };//QhullLinkedList::const_iterator
 
 };//QhullLinkedList
 
 template <typename T>
 class QhullLinkedListIterator // FIXUP QH11016 define QhullMutableLinkedListIterator
 {
     typedef typename QhullLinkedList<T>::const_iterator const_iterator;
     const QhullLinkedList<T> *c;
     const_iterator      i;
 
 public:
                         QhullLinkedListIterator(const QhullLinkedList<T> &container) : c(&container), i(c->constBegin()) {}
                         QhullLinkedListIterator &operator=(const QhullLinkedList<T> &container) { c= &container; i= c->constBegin(); return *this; }
     bool                findNext(const T &t);
     bool                findPrevious(const T &t);
     bool                hasNext() const { return i != c->constEnd(); }
     bool                hasPrevious() const { return i != c->constBegin(); }
     T                   next() { return *i++; }
     T                   peekNext() const { return *i; }
     T                   peekPrevious() const { const_iterator p= i; return *--p; }
     T                   previous() { return *--i; }
     void                toFront() { i= c->constBegin(); }
     void                toBack() { i= c->constEnd(); }
 };//QhullLinkedListIterator
 
 #//== Definitions =========================================
 
 #//Conversion
 
 #ifndef QHULL_NO_STL
 template <typename T>
 std::vector<T> QhullLinkedList<T>::
 toStdVector() const
 {
     std::vector<T> tmp;
     std::copy(constBegin(), constEnd(), std::back_inserter(tmp));
     return tmp;
 }//toStdVector
 #endif
 
 #ifdef QHULL_USES_QT
 template <typename T>
 QList<T>  QhullLinkedList<T>::
 toQList() const
 {
     QhullLinkedListIterator<T> i(*this);
     QList<T> ls;
     while(i.hasNext()){
         ls.append(i.next());
     }
     return ls;
 }//toQList
 #endif
 
 #//Read-only
 
 template <typename T>
 int QhullLinkedList<T>::
 count() const
 {
     const_iterator i= begin_node;
     int c= 0;
     while(i != end_node){
         c++;
         i++;
     }
     return c;
 }//count
 
 #//Search
 
 template <typename T>
 bool QhullLinkedList<T>::
 contains(const T &t) const
 {
     const_iterator i= begin_node;
     while(i != end_node){
         if(i==t){
             return true;
         }
         i++;
     }
     return false;
 }//contains
 
 template <typename T>
 int QhullLinkedList<T>::
 count(const T &t) const
 {
     const_iterator i= begin_node;
     int c= 0;
     while(i != end_node){
         if(i==t){
             c++;
         }
         i++;
     }
     return c;
 }//count
 
 template <typename T>
 bool QhullLinkedList<T>::
 operator==(const QhullLinkedList<T> &l) const
 {
     if(begin_node==l.begin_node){
         return (end_node==l.end_node);
     }
     T i= begin_node;
     T il= l.begin_node;
     while(i != end_node){
         if(i != il){
             return false;
         }
         i= static_cast<T>(i.next());
         il= static_cast<T>(il.next());
     }
     if(il != l.end_node){
         return false;
     }
     return true;
 }//operator==
 
 #//Iterator
 
 template <typename T>
 typename QhullLinkedList<T>::iterator  QhullLinkedList<T>::iterator::
 operator+(int j) const
 {
     T n= i;
     if(j>0){
         while(j--){
             n= n.next();
         }
     }else{
         while(j++){
             n= n.previous();
         }
     }
     return iterator(n);
 }//operator+
 
 template <typename T>
 typename QhullLinkedList<T>::const_iterator  QhullLinkedList<T>::const_iterator::
 operator+(int j) const
 {
     T n= i;
     if(j>0){
         while(j--){
             n= n.next();
         }
     }else{
         while(j++){
             n= n.previous();
         }
     }
     return const_iterator(n);
 }//operator+
 
 #//QhullLinkedListIterator
 
 template <typename T>
 bool QhullLinkedListIterator<T>::
 findNext(const T &t)
 {
     while(i != c->constEnd()){
         if (*i++ == t){
             return true;
         }
     }
     return false;
 }//findNext
 
 template <typename T>
 bool QhullLinkedListIterator<T>::
 findPrevious(const T &t)
 {
     while(i!=c->constBegin()){
         if(*(--i)==t){
             return true;
         }
     }
     return false;
 }//findNext
 
 }//namespace orgQhull
 
 #//Global functions
 
 template <typename T>
 std::ostream &
 operator<<(std::ostream &os, const orgQhull::QhullLinkedList<T> &qs)
 {
     typename orgQhull::QhullLinkedList<T>::const_iterator i;
     for(i= qs.begin(); i != qs.end(); ++i){
         os << *i;
     }
     return os;
 }//operator<<
 
 #endif // QHULLLINKEDLIST_H
 
diff --git a/src/libqhullrcpp/QhullPoint.cpp b/src/libqhullpcpp/QhullPoint.cpp
similarity index 96%
rename from src/libqhullrcpp/QhullPoint.cpp
rename to src/libqhullpcpp/QhullPoint.cpp
index 77a4e76..ffe8f3e 100644
--- a/src/libqhullrcpp/QhullPoint.cpp
+++ b/src/libqhullpcpp/QhullPoint.cpp
@@ -1,177 +1,177 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullPoint.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullPoint.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include "UsingLibQhull.h"
 #include "QhullPoint.h"
 
 #include <iostream>
 #include <algorithm>
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//Class public variables and methods
 
 //! If qhRundID undefined uses QhullPoint::s_points_begin and dimension
 int QhullPoint::
 id(int qhRunId, int dimension, const coordT *c)
 {
     QHULL_UNUSED(dimension);
 
     if(UsingLibQhull::hasPoints()){
         if(qhRunId==UsingLibQhull::NOqhRunId){
             const coordT *pointsEnd;
             int dim;
             const coordT *points= UsingLibQhull::globalPoints(&dim, &pointsEnd);
             if(c>=points && c<pointsEnd){
                 int offset= (int)(c-points); // WARN64
                 return offset/dim;
             }
         }else{
             UsingLibQhull q(qhRunId);
             // NOerrors from qh_pointid or qh_setindex
             return qh_pointid(const_cast<coordT *>(c));
         }
     }
     long long i=(long long)c;
     return (int)i; // WARN64
 }//id
 
 #//Conversion
 
 // See qt-qhull.cpp for QList conversion
 
 #ifndef QHULL_NO_STL
 std::vector<coordT> QhullPoint::
 toStdVector() const
 {
     QhullPointIterator i(*this);
     std::vector<coordT> vs;
     while(i.hasNext()){
         vs.push_back(i.next());
     }
     return vs;
 }//toStdVector
 #endif //QHULL_NO_STL
 
 #//Operator
 
 bool QhullPoint::
 operator==(const QhullPoint &other) const
 {
     if(point_dimension!=other.point_dimension){
         return false;
     }
     const coordT *c= point_coordinates;
     const coordT *c2= other.point_coordinates;
     if(c==c2){
         return true;
     }
     double dist2= 0.0;
     for(int k= point_dimension; k--; ){
         double diff= *c++ - *c2++;
         dist2 += diff*diff;
     }
     double epsilon= UsingLibQhull::globalDistanceEpsilon();
     // std::cout << "DEBUG dist2 " << dist2 << " epsilon^2 " << epsilon*epsilon << std::endl;
     return (dist2<=(epsilon*epsilon));
 }//operator==
 
 
 #//Value
 
 //! Return distance betweeen two points.
 double QhullPoint::
 distance(const QhullPoint &p) const
 {
     const coordT *c= coordinates();
     const coordT *c2= p.coordinates();
     int dim= dimension();
     QHULL_ASSERT(dim==p.dimension());
     double dist;
 
     switch(dim){
   case 2:
       dist= (c[0]-c2[0])*(c[0]-c2[0]) + (c[1]-c2[1])*(c[1]-c2[1]);
       break;
   case 3:
       dist= (c[0]-c2[0])*(c[0]-c2[0]) + (c[1]-c2[1])*(c[1]-c2[1]) + (c[2]-c2[2])*(c[2]-c2[2]);
       break;
   case 4:
       dist= (c[0]-c2[0])*(c[0]-c2[0]) + (c[1]-c2[1])*(c[1]-c2[1]) + (c[2]-c2[2])*(c[2]-c2[2]) + (c[3]-c2[3])*(c[3]-c2[3]);
       break;
   case 5:
       dist= (c[0]-c2[0])*(c[0]-c2[0]) + (c[1]-c2[1])*(c[1]-c2[1]) + (c[2]-c2[2])*(c[2]-c2[2]) + (c[3]-c2[3])*(c[3]-c2[3]) + (c[4]-c2[4])*(c[4]-c2[4]);
       break;
   case 6:
       dist= (c[0]-c2[0])*(c[0]-c2[0]) + (c[1]-c2[1])*(c[1]-c2[1]) + (c[2]-c2[2])*(c[2]-c2[2]) + (c[3]-c2[3])*(c[3]-c2[3]) + (c[4]-c2[4])*(c[4]-c2[4]) + (c[5]-c2[5])*(c[5]-c2[5]);
       break;
   case 7:
       dist= (c[0]-c2[0])*(c[0]-c2[0]) + (c[1]-c2[1])*(c[1]-c2[1]) + (c[2]-c2[2])*(c[2]-c2[2]) + (c[3]-c2[3])*(c[3]-c2[3]) + (c[4]-c2[4])*(c[4]-c2[4]) + (c[5]-c2[5])*(c[5]-c2[5]) + (c[6]-c2[6])*(c[6]-c2[6]);
       break;
   case 8:
       dist= (c[0]-c2[0])*(c[0]-c2[0]) + (c[1]-c2[1])*(c[1]-c2[1]) + (c[2]-c2[2])*(c[2]-c2[2]) + (c[3]-c2[3])*(c[3]-c2[3]) + (c[4]-c2[4])*(c[4]-c2[4]) + (c[5]-c2[5])*(c[5]-c2[5]) + (c[6]-c2[6])*(c[6]-c2[6]) + (c[7]-c2[7])*(c[7]-c2[7]);
       break;
   default:
       dist= 0.0;
       for(int k=dim; k--; ){
           dist += (*c - *c2) * (*c - *c2);
           ++c;
           ++c2;
       }
       break;
     }
     return sqrt(dist);
 }//distance
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::ostream;
 using orgQhull::QhullPoint;
 using orgQhull::UsingLibQhull;
 
 #//operator<<
 
 ostream &
 operator<<(ostream &os, const QhullPoint &p)
 {
     os << p.printWithIdentifier(UsingLibQhull::NOqhRunId, "");
     return os;
 }
 
 //! Same as qh_printpointid [io.c]
 ostream &
 operator<<(ostream &os, const QhullPoint::PrintPoint &pr)
 {
     QhullPoint p= *pr.point; 
     int i= p.id(pr.run_id);
     if(pr.point_message){
         if(*pr.point_message){
             os << pr.point_message << " ";
         }
         if(pr.with_identifier && (i!=-1)){
             os << "p" << i << ": ";
         }
     }
     const realT *c= p.coordinates();
     for(int k=p.dimension(); k--; ){
         realT r= *c++;
         if(pr.point_message){
             os << " " << r; // FIXUP QH11010 %8.4g
         }else{
             os << " " << r; // FIXUP QH11010 qh_REAL_1
         }
     }
     os << std::endl;
     return os;
 }//printPoint
 
diff --git a/src/libqhullrcpp/QhullPoint.h b/src/libqhullpcpp/QhullPoint.h
similarity index 97%
rename from src/libqhullrcpp/QhullPoint.h
rename to src/libqhullpcpp/QhullPoint.h
index d733cc2..ca3dc0b 100644
--- a/src/libqhullrcpp/QhullPoint.h
+++ b/src/libqhullpcpp/QhullPoint.h
@@ -1,130 +1,130 @@
 /****************************************************************************
 **
 ** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullPoint.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullPoint.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHPOINT_H
 #define QHPOINT_H
 
 #include "QhullError.h"
 #include "QhullIterator.h"
 #include "UsingLibQhull.h"
 #include "Coordinates.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//Types
     //! QhullPoint as a pointer and dimension to shared memory
     class QhullPoint;
     //! Java-style iterator for QhullPoint coordinates
     class QhullPointIterator;
 
 class QhullPoint {
 
     //! A point is a pointer into an array of coordinates.
 
 private:
 #//Fields
     coordT             *point_coordinates;  // Keep pointers aligned
     int                 point_dimension;
 
 public:
 #//Subtypes
     typedef const coordT *              iterator;
     typedef const coordT *              const_iterator;
     typedef QhullPoint::iterator        Iterator;
     typedef QhullPoint::const_iterator  ConstIterator;
 
 #//Class methods -- Convert point to id w/o QhullQh data structure
     static int          id(const coordT *c) { return QhullPoint::id(UsingLibQhull::NOqhRunId, 0, c); }
     static int          id(int qhRunId, const coordT *c) { return QhullPoint::id(qhRunId, 0, c); }
     static int          id(int qhRunId, int dimension, const coordT *c);
 
 #//Construct
                         QhullPoint() : point_coordinates(0), point_dimension(0) {};
                         QhullPoint(int pointDimension, coordT *c) : point_coordinates(c), point_dimension(pointDimension) {}
     explicit            QhullPoint(Coordinates &c) : point_coordinates(c.data()), point_dimension(c.count()) {}
                         // Creates an alias.  Does not copy the point.  Needed for return by value and parameter passing.
                         QhullPoint(const QhullPoint &other)  : point_coordinates(other.point_coordinates), point_dimension(other.point_dimension) {}
                         // Creates an alias.  Does not copy the point.  Needed for vector<QhullPoint>
     QhullPoint         &operator=(const QhullPoint &other) { point_coordinates= other.point_coordinates; point_dimension= other.point_dimension; return *this; }
                        ~QhullPoint() {}
 
 #//Conversions
     // see coordinates()
 #ifndef QHULL_NO_STL
     std::vector<coordT> toStdVector() const;
 #endif //QHULL_NO_STL
 #ifdef QHULL_USES_QT
     QList<coordT>       toQList() const;
 #endif //QHULL_USES_QT
 
 #//Read-only
 public:
     const coordT       *coordinates() const { return point_coordinates; }
     coordT             *coordinates() { return point_coordinates; }
     int                 dimension() const { return point_dimension; }
     int                 id(int qhRunId) const { return id(qhRunId, dimension(), coordinates()); }
     int                 id() const { return id(UsingLibQhull::NOqhRunId, dimension(), coordinates()); }
     bool                isDefined() const { return point_coordinates!=0 && point_dimension>0; }
 
 #//Define
     void                advancePoint(int idx) { point_coordinates += idx*point_dimension; }
     void                defineAs(int pointDimension, coordT *c) { QHULL_ASSERT(pointDimension>=0); point_coordinates= c; point_dimension= pointDimension; }
     //! Creates an alias to other
     void                defineAs(QhullPoint &other) { point_coordinates= other.coordinates(); point_dimension= other.dimension(); }
     void                setCoordinates(coordT *c) { point_coordinates= c; }
     void                setDimension(int pointDimension) { point_dimension= pointDimension; }
 
 #//value
     double              distance(const QhullPoint &p) const;
 
 #//iterator
     iterator            begin() { return point_coordinates; }
     const_iterator      begin() const { return point_coordinates; }
     const_iterator      constBegin() const { return point_coordinates; }
     const_iterator      constEnd() const { return point_coordinates+point_dimension; }
     int                 count() { return dimension(); }
     iterator            end() { return point_coordinates+point_dimension; }
     const_iterator      end() const { return point_coordinates+point_dimension; }
     size_t              size() { return (size_t)dimension(); }
 
 #//Operator
     bool                operator==(const QhullPoint &other) const;
     bool                operator!=(const QhullPoint &other) const { return !operator==(other); }
     const coordT       &operator[](int idx) const { QHULL_ASSERT(idx>=0 && idx<point_dimension); return *(point_coordinates+idx); }
     coordT             &operator[](int idx) { QHULL_ASSERT(idx>=0 && idx<point_dimension); return *(point_coordinates+idx); }
 
     struct PrintPoint{
         const QhullPoint  *point;
         const char     *point_message;
         int             run_id;
         bool            with_identifier;
                         PrintPoint(int qhRunId, const char *message, bool withIdentifier, const QhullPoint &p) : point(&p), point_message(message), run_id(qhRunId), with_identifier(withIdentifier) {}
     };//PrintPoint
     PrintPoint          print() const { return  PrintPoint(UsingLibQhull::NOqhRunId, "", false, *this); }
     PrintPoint          print(int qhRunId) const { return PrintPoint(qhRunId, "", true, *this); }
     PrintPoint          print(int qhRunId, const char *message) const { return PrintPoint(qhRunId, message, false, *this); }
     PrintPoint          printWithIdentifier(int qhRunId, const char *message) const { return PrintPoint(qhRunId, message, true, *this); }
 
 };//QhullPoint
 
 QHULL_DECLARE_SEQUENTIAL_ITERATOR(QhullPoint, coordT)
 
 }//namespace orgQhull
 
 #//Global functions
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullPoint::PrintPoint &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullPoint &p); // FIXUP QH11017 OK in c program but not inline { os << p.print(orgQhull::UsingLibQhull::NOqhRunId, ""); return os; }
 
 #endif // QHPOINT_H
 
diff --git a/src/libqhullrcpp/QhullPointSet.cpp b/src/libqhullpcpp/QhullPointSet.cpp
similarity index 95%
rename from src/libqhullrcpp/QhullPointSet.cpp
rename to src/libqhullpcpp/QhullPointSet.cpp
index 0affb5a..e944f2f 100644
--- a/src/libqhullrcpp/QhullPointSet.cpp
+++ b/src/libqhullpcpp/QhullPointSet.cpp
@@ -1,217 +1,217 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullPointSet.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullPointSet.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include "QhullPointSet.h"
 
 #include <iostream>
 #include <algorithm>
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #// Conversion
 
 // See qt-qhull.cpp for QList conversion
 
 #ifndef QHULL_NO_STL
 std::vector<QhullPoint> QhullPointSet::
 toStdVector() const
 {
     QhullPointSetIterator i(*this);
     std::vector<QhullPoint> vs;
     while(i.hasNext()){
         vs.push_back(i.next());
     }
     return vs;
 }//toStdVector
 #endif //QHULL_NO_STL
 
 #//Element-access
 //! Derived from QhullSet::value
 QhullPoint QhullPointSet::
 value(int idx) const
 {
     // Avoid call to qh_setsize() and assert in elementPointer()
     //const T *n= reinterpret_cast<const T *>(&SETelem_(getSetT(), idx));
     void **n= reinterpret_cast<void **>(&SETelem_(getSetT(), idx));
     coordT **n2= reinterpret_cast<coordT **>(n);
     if(idx>=0 && n<endPointer()){
         return QhullPoint(dimension(), *n2);
     }else{
         return QhullPoint();
     }
 }//value
 
 //! Non-const since copy is an alias
 //! Derived from QhullSet::value
 QhullPoint QhullPointSet::
 value(int idx, QhullPoint &defaultValue) const
 {
     // Avoid call to qh_setsize() and assert in elementPointer()
     void **n= reinterpret_cast<void **>(&SETelem_(getSetT(), idx));
     coordT **n2= reinterpret_cast<coordT **>(n);
     if(idx>=0 && n<endPointer()){
         return QhullPoint(dimension(), *n2);
     }else{
         return defaultValue;
     }
 }//value
 
 #//Read-only
 
 bool QhullPointSet::
 operator==(const QhullPointSet &o) const
 {
     if(dimension()!=o.dimension() || count()!=o.count()){
         return false;
     }
     QhullPointSetIterator i(*this);
     QhullPointSetIterator j(o);
     while(i.hasNext()){
         if(i.next()!=j.next()){
             return false;
         }
     }
     return true;
 }//operator==
 
 #//Search
 bool QhullPointSet::
 contains(const QhullPoint &t) const
 {
     QhullPointSetIterator i(*this);
     while(i.hasNext()){
         if(i.next()==t){
             return true;
         }
     }
     return false;
 }//contains
 
 int QhullPointSet::
 count(const QhullPoint &t) const
 {
     int n= 0;
     QhullPointSetIterator i(*this);
     while(i.hasNext()){
         if(i.next()==t){
             ++n;
         }
     }
     return n;
 }//count
 
 int QhullPointSet::
 indexOf(const QhullPoint &t) const
 {
     int idx= 0;
     QhullPointSetIterator i(*this);
     while(i.hasNext()){
         if(i.next()==t){
             return idx;
         }
         ++idx;
     }
     return -1;
 }//indexOf
 
 int QhullPointSet::
 lastIndexOf(const QhullPoint &t) const
 {
     int idx= count()-1;
     QhullPointSetIterator i(*this);
     i.toBack();
     while(i.hasPrevious()){
         if(i.previous()==t){
             break;
         }
         --idx;
     }
     return idx;
 }//lastIndexOf
 
 
 #//QhullPointSetIterator
 
 bool QhullPointSetIterator::
 findNext(const QhullPoint &p)
 {
     while(i!=c->constEnd()){
         if(*i++ == p){
             return true;
         }
     }
     return false;
 }//findNext
 
 bool QhullPointSetIterator::
 findPrevious(const QhullPoint &p)
 {
     while(i!=c->constBegin()){
         if(*(--i) == p){
             return true;
         }
     }
     return false;
 }//findPrevious
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::ostream;
 using orgQhull::QhullPoint;
 using orgQhull::QhullPointSet;
 using orgQhull::UsingLibQhull;
 
 #//operator<<
 
 ostream &
 operator<<(ostream &os, const QhullPointSet &ps)
 {
     os << ps.print(UsingLibQhull::NOqhRunId);
     return os;
 }//<<QhullPointSet
 
 ostream &
 operator<<(ostream &os, const QhullPointSet::PrintIdentifiers &pr)
 {
     const QhullPointSet s= *pr.point_set;
     if (pr.print_message) {
         os << pr.print_message;
     }
     for(QhullPointSet::const_iterator i=s.begin(); i != s.end(); ++i){
         if(i!=s.begin()){
             os << " ";
         }
         const QhullPoint point= *i;
         int id= point.id(pr.run_id);
         os << "p" << id;
     }
     os << endl;
     return os;
 }//PrintIdentifiers
 
 ostream &
 operator<<(ostream &os, const QhullPointSet::PrintPointSet &pr)
 {
     const QhullPointSet s= *pr.point_set;
     if (pr.print_message) {
         os << pr.print_message;
     }
     for(QhullPointSet::const_iterator i=s.begin(); i != s.end(); ++i){
         const QhullPoint point= *i;
         os << point.print(pr.run_id);
     }
     return os;
 }//printPointSet
 
 
diff --git a/src/libqhullrcpp/QhullPointSet.h b/src/libqhullpcpp/QhullPointSet.h
similarity index 98%
rename from src/libqhullrcpp/QhullPointSet.h
rename to src/libqhullpcpp/QhullPointSet.h
index 7de5f66..e50e9fe 100644
--- a/src/libqhullrcpp/QhullPointSet.h
+++ b/src/libqhullpcpp/QhullPointSet.h
@@ -1,254 +1,254 @@
 /****************************************************************************
 **
 ** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullPointSet.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullPointSet.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLPOINTSET_H
 #define QHULLPOINTSET_H
 
 #include "QhullSet.h"
 #include "QhullPoint.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//Types
     //! QhullPointSet -- a set of coordinate pointers with dimension
     // with const_iterator and iterator
     class               QhullPointSet;
     //! Java-style iterator
     class QhullPointsIterator;
 
 #//Classref
     class               QhullPoint;
 
 class QhullPointSet : public QhullSet<coordT *> {
 
 private:
 #//Field
     int                 point_dimension;
 
 public:
 #//Subtypes and types
     class               const_iterator;
     class               iterator;
     typedef QhullPointSet::const_iterator ConstIterator;
     typedef QhullPointSet::iterator Iterator;
 
     typedef QhullPoint  value_type;
     typedef ptrdiff_t   difference_type;
     typedef int         size_type;
     //typedef const value_type *const_pointer;    // FIXUP QH11019: QhullPointSet does not define pointer or reference due to point_dimension
     //typedef const value_type &const_reference;
     //typedef value_type *pointer;
     //typedef value_type &reference;
 
 #//Construct
                         //Conversion from setT* is not type-safe.  Implicit conversion for void* to T
                         QhullPointSet(int pointDimension, setT *s) : QhullSet<coordT *>(s), point_dimension(pointDimension) {}
                         //Copy constructor copies pointer but not contents.  Needed for return by value and parameter passing.
                         QhullPointSet(const QhullPointSet &o) : QhullSet<coordT *>(o), point_dimension(o.point_dimension) {}
                        ~QhullPointSet() {}
 
 //Default constructor and copy assignment disabled since p= p2 is ambiguous (coord* vs coord)
 private:
                         QhullPointSet();
     QhullPointSet      &operator=(const QhullPointSet &);
 public:
 
 #//Conversions
     // inherited -- constData, data
 #ifndef QHULL_NO_STL
     std::vector<QhullPoint> toStdVector() const;
 #endif
 #ifdef QHULL_USES_QT
     QList<QhullPoint>   toQList() const;
 #endif
 
 #//Read-only
     //inherits count, empty, isEmpty, size
     using QhullSetBase::count;
     int                 dimension() const { return point_dimension; }
     bool                operator==(const QhullPointSet &o) const;
     bool                operator!=(const QhullPointSet &o) const { return !operator==(o); }
 
 #//Element access -- can not return references since QhullPoint must be generated
     QhullPoint          at(int idx) const { return operator[](idx); }
     QhullPoint          back() const { return last(); }
     //! end element is NULL
     QhullPoint          first() const { QHULL_ASSERT(!isEmpty()); return *begin(); }
     QhullPoint          front() const { return first(); }
     QhullPoint          last() const { QHULL_ASSERT(!isEmpty()); return *(end()-1); }
     // mid() not available.  No setT constructor
     QhullPoint          operator[](int idx) const { return QhullPoint(dimension(), QhullSet<coordT *>::operator[](idx)); }
     QhullPoint          second()  const { return operator[](1); }
     QhullPoint          value(int idx) const;
     // Non-const since copy is an alias
     QhullPoint          value(int idx, QhullPoint &defaultValue) const;
 
 #//iterator
     iterator            begin() { return iterator(dimension(), reinterpret_cast<coordT **>(beginPointer())); }
     const_iterator      begin() const { return const_iterator(dimension(), reinterpret_cast<coordT **>(beginPointer())); }
     const_iterator      constBegin() const { return const_iterator(dimension(), reinterpret_cast<coordT **>(beginPointer())); }
     const_iterator      constEnd() const { return const_iterator(dimension(), reinterpret_cast<coordT **>(endPointer())); }
     iterator            end() { return iterator(dimension(), reinterpret_cast<coordT **>(endPointer())); }
     const_iterator      end() const { return const_iterator(dimension(), reinterpret_cast<coordT **>(endPointer())); }
 
 //Read-write -- Not available, no setT constructor
 
 #//Search
     bool                contains(const QhullPoint &t) const;
     int                 count(const QhullPoint &t) const;
     int                 indexOf(const QhullPoint &t) const;
     int                 lastIndexOf(const QhullPoint &t) const;
 
     // before const_iterator for conversion with comparison operators
     class iterator {
         friend class    const_iterator;
 
     private:
         coordT        **i;
         int             point_dimension;
 
     public:
         typedef ptrdiff_t   difference_type;
         typedef std::bidirectional_iterator_tag  iterator_category;
         typedef QhullPoint *pointer;
         typedef QhullPoint &reference;
         typedef QhullPoint  value_type;
 
                         iterator() : i(0), point_dimension(0) {}
                         iterator(int dimension, coordT **c) : i(c), point_dimension(dimension) {}
                         iterator(const iterator &o) : i(o.i), point_dimension(o.point_dimension) {}
         iterator       &operator=(const iterator &o) { i= o.i; point_dimension= o.point_dimension; return *this; }
 
         QhullPoint      operator*() const { return QhullPoint(point_dimension, *i); }
                       //operator->() n/a, value-type
         QhullPoint      operator[](int idx) { return QhullPoint(point_dimension, *(i+idx)); }
         bool            operator==(const iterator &o) const { return i == o.i && point_dimension == o.point_dimension; }
         bool            operator!=(const iterator &o) const { return !operator==(o); }
         bool            operator==(const const_iterator &o) const
         { return i == reinterpret_cast<const iterator &>(o).i && point_dimension == reinterpret_cast<const iterator &>(o).point_dimension; }
         bool            operator!=(const const_iterator &o) const { return !operator==(o); }
 
         //! Assumes same point set
         int             operator-(const iterator &o) { return (int)(i-o.i); } //WARN64
         bool            operator>(const iterator &o) const { return i>o.i; }
         bool            operator<=(const iterator &o) const { return !operator>(o); }
         bool            operator<(const iterator &o) const { return i<o.i; }
         bool            operator>=(const iterator &o) const { return !operator<(o); }
         bool            operator>(const const_iterator &o) const
         { return i > reinterpret_cast<const iterator &>(o).i; }
         bool            operator<=(const const_iterator &o) const { return !operator>(o); }
         bool            operator<(const const_iterator &o) const
         { return i < reinterpret_cast<const iterator &>(o).i; }
         bool            operator>=(const const_iterator &o) const { return !operator<(o); }
 
         iterator       &operator++() { ++i; return *this; }
         iterator        operator++(int) { iterator o= *this; ++i; return o; }
         iterator       &operator--() { --i; return *this; }
         iterator        operator--(int) { iterator o= *this; --i; return o; }
         iterator        operator+(int j) const { return iterator(point_dimension, i+j); }
         iterator        operator-(int j) const { return operator+(-j); }
         iterator       &operator+=(int j) { i += j; return *this; }
         iterator       &operator-=(int j) { i -= j; return *this; }
     };//QhullPointSet::iterator
 
     class const_iterator {
     private:
         coordT        **i;
         int             point_dimension;
 
     public:
         typedef std::random_access_iterator_tag  iterator_category;
         typedef QhullPoint value_type;
         typedef value_type *pointer;
         typedef value_type &reference;
         typedef ptrdiff_t  difference_type;
 
                         const_iterator() : i(0), point_dimension(0) {}
                         const_iterator(int dimension, coordT **c) : i(c), point_dimension(dimension) {}
                         const_iterator(const const_iterator &o) : i(o.i), point_dimension(o.point_dimension) {}
                         const_iterator(iterator o) : i(o.i), point_dimension(o.point_dimension) {}
         const_iterator &operator=(const const_iterator &o) { i= o.i; point_dimension= o.point_dimension; return *this; }
 
         QhullPoint      operator*() const { return QhullPoint(point_dimension, *i); }
         QhullPoint      operator[](int idx) { return QhullPoint(point_dimension, *(i+idx)); }
                       //operator->() n/a, value-type
         bool            operator==(const const_iterator &o) const { return i == o.i && point_dimension == o.point_dimension; }
         bool            operator!=(const const_iterator &o) const { return !operator==(o); }
 
         //! Assumes same point set
         int             operator-(const const_iterator &o) { return (int)(i-o.i); } //WARN64
         bool            operator>(const const_iterator &o) const { return i>o.i; }
         bool            operator<=(const const_iterator &o) const { return !operator>(o); }
         bool            operator<(const const_iterator &o) const { return i<o.i; }
         bool            operator>=(const const_iterator &o) const { return !operator<(o); }
 
         const_iterator &operator++() { ++i; return *this; }
         const_iterator  operator++(int) { const_iterator o= *this; ++i; return o; }
         const_iterator &operator--() { --i; return *this; }
         const_iterator  operator--(int) { const_iterator o= *this; --i; return o; }
         const_iterator  operator+(int j) const { return const_iterator(point_dimension, i+j); }
         const_iterator  operator-(int j) const { return operator+(-j); }
         const_iterator &operator+=(int j) { i += j; return *this; }
         const_iterator &operator-=(int j) { i -= j; return *this; }
     };//QhullPointSet::const_iterator
 
 #//IO
     struct PrintIdentifiers{
         const QhullPointSet *point_set;
         const char     *print_message;
         int             run_id;
         PrintIdentifiers(const char *message, const QhullPointSet *s) : point_set(s), print_message(message) {}
     };//PrintIdentifiers
     PrintIdentifiers printIdentifiers(const char *message) const { return PrintIdentifiers(message, this); }
 
     struct PrintPointSet{
         const QhullPointSet *point_set;
         const char     *print_message;
         int             run_id;
         PrintPointSet(int qhRunId, const char *message, const QhullPointSet &s) : point_set(&s), print_message(message), run_id(qhRunId) {}
     };//PrintPointSet
     PrintPointSet       print(int qhRunId) const { return PrintPointSet(qhRunId, 0, *this); }
     PrintPointSet       print(int qhRunId, const char *message) const { return PrintPointSet(qhRunId, message, *this); }
 
 };//QhullPointSet
 
 //derived from qiterator.h
 class QhullPointSetIterator { // FIXUP QH11020 define QhullMutablePointSetIterator
     typedef QhullPointSet::const_iterator const_iterator;
     const QhullPointSet *c;
     const_iterator      i;
 
 public:
                         QhullPointSetIterator(const QhullPointSet &container) : c(&container), i(c->constBegin()) {}
     QhullPointSetIterator &operator=(const QhullPointSet &container) { c= &container; i= c->constBegin(); return *this; }
     bool                findNext(const QhullPoint &p);
     bool                findPrevious(const QhullPoint &p);
     bool                hasNext() const { return i != c->constEnd(); }
     bool                hasPrevious() const { return i != c->constBegin(); }
     QhullPoint          next() { return *i++; }
     QhullPoint          peekNext() const { return *i; }
     QhullPoint          peekPrevious() const { const_iterator p= i; return *--p; }
     QhullPoint          previous() { return *--i; }
     void                toBack() { i= c->constEnd(); }
     void                toFront() { i= c->constBegin(); }
 };//QhullPointSetIterator
 
 }//namespace orgQhull
 
 #//Global functions
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullPointSet &fs); // Not inline to avoid using statement
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullPointSet::PrintIdentifiers &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullPointSet::PrintPointSet &pr);
 
 #endif // QHULLPOINTSET_H
diff --git a/src/libqhullrcpp/QhullPoints.cpp b/src/libqhullpcpp/QhullPoints.cpp
similarity index 96%
rename from src/libqhullrcpp/QhullPoints.cpp
rename to src/libqhullpcpp/QhullPoints.cpp
index 6402964..efc94cb 100644
--- a/src/libqhullrcpp/QhullPoints.cpp
+++ b/src/libqhullpcpp/QhullPoints.cpp
@@ -1,235 +1,235 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullPoints.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullPoints.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include "QhullPoints.h"
 
 #include <iostream>
 #include <algorithm>
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//Conversion
 // See qt-qhull.cpp for QList conversion
 
 #ifndef QHULL_NO_STL
 std::vector<QhullPoint> QhullPoints::
 toStdVector() const
 {
     QhullPointsIterator i(*this);
     std::vector<QhullPoint> vs;
     while(i.hasNext()){
         vs.push_back(i.next());
     }
     return vs;
 }//toStdVector
 #endif //QHULL_NO_STL
 
 #//Read-only
 
 bool QhullPoints::
 operator==(const QhullPoints &other) const
 {
     if(point_dimension!=other.point_dimension || (point_end-point_first) != (other.point_end-other.point_first)){
         return false;
     }
     const coordT *c= point_first;
     const coordT *c2= other.point_first;
     while(c<point_end){
         if(*c++!=*c2++){
             return false;
         }
     }
     return true;
 }//operator==
 
 
 #//ElementAccess
 QhullPoints QhullPoints::
 mid(int idx, int length) const
 {
     int n= count();
     if(idx<0 || idx>=n){
         n= 0;
     }else if(length<0 || idx+length>=n){
         n -= idx;
     }else{
         n -= idx+length;
     }
     return QhullPoints(point_dimension, n*point_dimension, point_first+idx*point_dimension);
 }//mid
 
 QhullPoint QhullPoints::
 value(int idx) const
 {
     QhullPoint p;
     if(idx>=0 && idx<count()){
         p.defineAs(point_dimension, point_first+idx*point_dimension);
     }
     return p;
 }//value
 
 QhullPoint QhullPoints::
 value(int idx, QhullPoint &defaultValue) const
 {
     QhullPoint p;
     if(idx>=0 && idx<count()){
         p.defineAs(point_dimension, point_first+idx*point_dimension);
     }else{
         p.defineAs(defaultValue);
     }
     return p;
 }//value
 
 #//Search
 
 bool QhullPoints::
 contains(const QhullPoint &t) const
 {
     const_iterator i= begin();
     while(i != end()){
         if(*i==t){
             return true;
         }
         i++;
     }
     return false;
 }//contains
 
 int QhullPoints::
 count(const QhullPoint &t) const
 {
     int n= 0;
     const_iterator i= begin();
     while(i != end()){
         if(*i==t){
             ++n;
         }
         i++;
     }
     return n;
 }//count
 
 int QhullPoints::
 indexOf(const coordT *pointCoordinates) const
 {
     if(!includesCoordinates(pointCoordinates) || dimension()==0){
         return -1;
     }
     size_t offset= pointCoordinates-point_first;
     int idx= (int)(offset/(size_t)dimension()); // int for error reporting
     int extra= (int)(offset%(size_t)dimension());
     if(extra!=0){
         throw QhullError(10066, "Qhull error: coordinates %x are not at point boundary (extra %d at index %d)", extra, idx, 0.0, pointCoordinates);
     }
     return idx;
 }//indexOf coordT
 
 int QhullPoints::
 indexOf(const coordT *pointCoordinates, int noThrow) const
 {
     size_t extra= 0;
     if(noThrow){
         if(!includesCoordinates(pointCoordinates) || dimension()==0){
             return -1;
         }
         extra= (pointCoordinates-point_first)%(size_t)dimension();
     }
     return indexOf(pointCoordinates-extra);
 }//indexOf coordT noThrow
 
 int QhullPoints::
 indexOf(const QhullPoint &t) const
 {
     int j=0;
     const_iterator i= begin();
     while(i!=end()){
         if(*i==t){
             return j;
         }
         ++i;
         ++j;
     }
     return -1;
 }//indexOf
 
 int QhullPoints::
 lastIndexOf(const QhullPoint &t) const
 {
     int j=count();
     const_iterator i= end();
     while(i != begin()){
         --i;
         --j;
         if(*i==t){
             return j;
         }
     }
     return -1;
 }//lastIndexOf
 
 #//QhullPointsIterator
 
 bool QhullPointsIterator::
 findNext(const QhullPoint &p)
 {
     while(i!=ps->constEnd()){
         if(*i++ == p){
             return true;
         }
     }
     return false;
 }//findNext
 
 bool QhullPointsIterator::
 findPrevious(const QhullPoint &p)
 {
     while(i!=ps->constBegin()){
         if(*--i == p){
             return true;
         }
     }
     return false;
 }//findPrevious
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::ostream;
 using orgQhull::QhullPoint;
 using orgQhull::QhullPoints;
 using orgQhull::QhullPointsIterator;
 
 ostream &
 operator<<(ostream &os, const QhullPoints &p)
 {
     QhullPointsIterator i(p);
     while(i.hasNext()){
         os << i.next();
     }
     return os;
 }//operator<<QhullPoints
 
 ostream &
 operator<<(ostream &os, const QhullPoints::PrintPoints &pr)
 {
     os << pr.point_message;
     QhullPoints ps= *pr.points;
     for(QhullPoints::iterator i=ps.begin(); i != ps.end(); ++i){
         QhullPoint p= *i;
         if(pr.with_identifier){
             os << p.printWithIdentifier(pr.run_id, "");
         }else{
             os << p.print(pr.run_id, "");
         }
     }
     return os;
 }//<<PrintPoints
diff --git a/src/libqhullrcpp/QhullPoints.h b/src/libqhullpcpp/QhullPoints.h
similarity index 99%
rename from src/libqhullrcpp/QhullPoints.h
rename to src/libqhullpcpp/QhullPoints.h
index f701013..ed1041e 100644
--- a/src/libqhullrcpp/QhullPoints.h
+++ b/src/libqhullpcpp/QhullPoints.h
@@ -1,246 +1,246 @@
 /****************************************************************************
 **
 ** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullPoints.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullPoints.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLPOINTS_H
 #define QHULLPOINTS_H
 
 #include "QhullPoint.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//Types
     //! coordinate pointer with dimension
     // with const_iterator and iterator
     class QhullPoints;
     //! Java-style iterator
     class QhullPointsIterator;
 
 class QhullPoints {
 
     // QhullPoints consists of pointers into an array of coordinates.
 
 private:
 #//Field
     coordT             *point_first;
     coordT             *point_end;  // end>=first.  Trailing coordinates ignored
     int                 point_dimension;  // >= 0
 
 public:
 #//Subtypes
     class               const_iterator;
     class               iterator;
     typedef QhullPoints::const_iterator ConstIterator;
     typedef QhullPoints::iterator Iterator;
 
 #//Construct
                         QhullPoints() : point_first(0), point_end(0), point_dimension(0) {};
                         QhullPoints(int pointDimension) : point_first(0), point_end(0), point_dimension(pointDimension) { QHULL_ASSERT(pointDimension>=0); }
                         QhullPoints(int pointDimension, int coordinateCount2, coordT *c) : point_first(c), point_end(c+coordinateCount2), point_dimension(pointDimension) { QHULL_ASSERT(pointDimension>=0 && coordinateCount2>=0 ); }
                         //Copy constructor copies pointers but not contents.  Needed for return by value and parameter passing.
                         QhullPoints(const QhullPoints &other)  : point_first(other.point_first), point_end(other.point_end), point_dimension(other.point_dimension) {}
                        ~QhullPoints() {}
 
 //disabled since p= p2 is ambiguous (coord* vs coord)
 private:
     QhullPoints        &operator=(const QhullPoints &other) { point_first= other.point_first; point_end= other.point_end; point_dimension= other.point_dimension; return *this; }
 public:
 
 #//Conversion
     const coordT       *constData() const { return coordinates(); }
     // See coordinates()
     coordT             *data() { return coordinates(); }
     const coordT       *data() const { return coordinates(); }
 #ifndef QHULL_NO_STL
     std::vector<QhullPoint> toStdVector() const;
 #endif //QHULL_NO_STL
 #ifdef QHULL_USES_QT
     QList<QhullPoint>   toQList() const;
 #endif //QHULL_USES_QT
 
 #//GetSet
     coordT             *coordinates() const { return point_first; }
     int                 coordinateCount() const { return (int)(point_end-point_first); } // WARN64
     int                 count() const { return (int)size(); } // WARN64
     void                defineAs(int pointDimension, int coordinatesCount, coordT *c) { QHULL_ASSERT(pointDimension>=0 && coordinatesCount>=0 && c!=0); point_first= c; point_end= c+coordinatesCount; point_dimension= pointDimension; }
     void                defineAs(int coordinatesCount, coordT *c) { QHULL_ASSERT((coordinatesCount>=0 && c!=0) || (c==0 && coordinatesCount==0)); point_first= c; point_end= c+coordinatesCount; }
     void                defineAs(const QhullPoints &other) { point_first= other.point_first; point_end= other.point_end; point_dimension= other.point_dimension; }
     int                 dimension() const { return point_dimension; }
     bool                empty() const { return point_end==point_first; }
     coordT             *extraCoordinates() const { return extraCoordinatesCount() ? (point_end-extraCoordinatesCount()) : 0; }
     int                 extraCoordinatesCount() const { return point_dimension>0 ? (int)((point_end-point_first)%(size_t)point_dimension) : 0; }  // WARN64
     bool                includesCoordinates(const coordT *c) const { return c>=point_first && c<point_end; }
     bool                isEmpty() const { return empty(); }
     bool                operator==(const QhullPoints &other) const;
     bool                operator!=(const QhullPoints &other) const { return !operator==(other); }
     void                setDimension(int pointDimension) { QHULL_ASSERT(pointDimension>=0); point_dimension= pointDimension; }
     size_t              size() const { return (point_dimension ? (point_end-point_first)/point_dimension : 0); }
 
 #//ElementAccess -- can not return references to QhullPoint
     QhullPoint          at(int idx) const { coordT *p= point_first+idx*point_dimension; QHULL_ASSERT(p<point_end); return QhullPoint(point_dimension, p); }
     QhullPoint          back() const { return last(); }
     QhullPoint          first() const { return QhullPoint(point_dimension, point_first); }
     QhullPoint          front() const { return first(); }
     QhullPoint          last() const { return QhullPoint(point_dimension, point_end - point_dimension); }
     //! Returns a subset of the points, not a copy
     QhullPoints         mid(int idx, int length= -1) const;
     QhullPoint          operator[](int idx) const { return at(idx); }
     QhullPoint          value(int idx) const;
     // Non-const since copy is an alias
     QhullPoint          value(int idx, QhullPoint &defaultValue) const;
 
 #//Foreach
     ConstIterator       begin() const { return ConstIterator(*this); }
     Iterator            begin() { return Iterator(*this); }
     ConstIterator       constBegin() const { return ConstIterator(*this); }
     ConstIterator       constEnd() const { return ConstIterator(point_dimension, point_end); }
     ConstIterator       end() const { return ConstIterator(point_dimension, point_end); }
     Iterator            end() { return Iterator(point_dimension, point_end); }
 
 #//Search
     bool                contains(const QhullPoint &t) const;
     int                 count(const QhullPoint &t) const;
     int                 indexOf(const coordT *pointCoordinates) const;
     int                 indexOf(const coordT *pointCoordinates, int noThrow) const;
     int                 indexOf(const QhullPoint &t) const;
     int                 lastIndexOf(const QhullPoint &t) const;
 
 #//QhullPoints::iterator -- modeled on qvector.h and qlist.h
     // before const_iterator for conversion with comparison operators
     // See: QhullSet.h
     class iterator : public QhullPoint {
 
     public:
         typedef std::random_access_iterator_tag  iterator_category;
         typedef QhullPoint  value_type;
         typedef value_type *pointer;
         typedef value_type &reference;
         typedef ptrdiff_t   difference_type;
 
                         iterator() : QhullPoint() {}
                         iterator(const iterator &other): QhullPoint(*other) {}
         explicit        iterator(const QhullPoints &ps) : QhullPoint(ps.dimension(), ps.coordinates()) {}
         explicit        iterator(int pointDimension, coordT *c): QhullPoint(pointDimension, c) {}
         iterator       &operator=(const iterator &other) { defineAs( const_cast<iterator &>(other)); return *this; }
         QhullPoint     *operator->() { return this; }
         // value instead of reference since advancePoint() modifies self
         QhullPoint      operator*() const { return *this; }
         QhullPoint      operator[](int idx) const { QhullPoint n= *this; n.advancePoint(idx); return n; }
         bool            operator==(const iterator &other) const { QHULL_ASSERT(dimension()==other.dimension()); return coordinates()==other.coordinates(); }
         bool            operator!=(const iterator &other) const { return !operator==(other); }
         bool            operator<(const iterator &other) const  { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() < other.coordinates(); }
         bool            operator<=(const iterator &other) const { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() <= other.coordinates(); }
         bool            operator>(const iterator &other) const  { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() > other.coordinates(); }
         bool            operator>=(const iterator &other) const { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() >= other.coordinates(); }
         // reinterpret_cast to break circular dependency
         bool            operator==(const QhullPoints::const_iterator &other) const { QHULL_ASSERT(dimension()==reinterpret_cast<const iterator &>(other).dimension()); return coordinates()==reinterpret_cast<const iterator &>(other).coordinates(); }
         bool            operator!=(const QhullPoints::const_iterator &other) const { return !operator==(reinterpret_cast<const iterator &>(other)); }
         bool            operator<(const QhullPoints::const_iterator &other) const  { QHULL_ASSERT(dimension()==reinterpret_cast<const iterator &>(other).dimension()); return coordinates() < reinterpret_cast<const iterator &>(other).coordinates(); }
         bool            operator<=(const QhullPoints::const_iterator &other) const { QHULL_ASSERT(dimension()==reinterpret_cast<const iterator &>(other).dimension()); return coordinates() <= reinterpret_cast<const iterator &>(other).coordinates(); }
         bool            operator>(const QhullPoints::const_iterator &other) const  { QHULL_ASSERT(dimension()==reinterpret_cast<const iterator &>(other).dimension()); return coordinates() > reinterpret_cast<const iterator &>(other).coordinates(); }
         bool            operator>=(const QhullPoints::const_iterator &other) const { QHULL_ASSERT(dimension()==reinterpret_cast<const iterator &>(other).dimension()); return coordinates() >= reinterpret_cast<const iterator &>(other).coordinates(); }
         iterator       &operator++() { advancePoint(1); return *this; }
         iterator        operator++(int) { iterator n= *this; operator++(); return iterator(n); }
         iterator       &operator--() { advancePoint(-1); return *this; }
         iterator        operator--(int) { iterator n= *this; operator--(); return iterator(n); }
         iterator       &operator+=(int idx) { advancePoint(idx); return *this; }
         iterator       &operator-=(int idx) { advancePoint(-idx); return *this; }
         iterator        operator+(int idx) const { iterator n= *this; n.advancePoint(idx); return n; }
         iterator        operator-(int idx) const { iterator n= *this; n.advancePoint(-idx); return n; }
         difference_type operator-(iterator other) const { QHULL_ASSERT(dimension()==other.dimension()); return (coordinates()-other.coordinates())/dimension(); }
     };//QhullPoints::iterator
 
 #//QhullPoints::const_iterator -- FIXUP QH11018 const_iterator same as iterator
     class const_iterator : public QhullPoint {
 
     public:
         typedef std::random_access_iterator_tag  iterator_category;
         typedef QhullPoint          value_type;
         typedef const value_type   *pointer;
         typedef const value_type   &reference;
         typedef ptrdiff_t           difference_type;
 
                         const_iterator() : QhullPoint() {}
                         const_iterator(const const_iterator &other) : QhullPoint(*other) {}
                         const_iterator(const QhullPoints::iterator &other) : QhullPoint(*other) {}
         explicit        const_iterator(const QhullPoints &ps) : QhullPoint(ps.dimension(), ps.coordinates()) {}
         explicit        const_iterator(int pointDimension, coordT *c): QhullPoint(pointDimension, c) {}
         const_iterator &operator=(const const_iterator &other) { defineAs(const_cast<const_iterator &>(other)); return *this; }
         // value/non-const since advancePoint(1), etc. modifies self
         QhullPoint      operator*() const { return *this; }
         QhullPoint     *operator->() { return this; }
         QhullPoint      operator[](int idx) const { QhullPoint n= *this; n.advancePoint(idx); return n; }
         bool            operator==(const const_iterator &other) const { QHULL_ASSERT(dimension()==other.dimension()); return coordinates()==other.coordinates(); }
         bool            operator!=(const const_iterator &other) const { return !operator==(other); }
         bool            operator<(const const_iterator &other) const  { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() < other.coordinates(); }
         bool            operator<=(const const_iterator &other) const { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() <= other.coordinates(); }
         bool            operator>(const const_iterator &other) const  { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() > other.coordinates(); }
         bool            operator>=(const const_iterator &other) const { QHULL_ASSERT(dimension()==other.dimension()); return coordinates() >= other.coordinates(); }
         const_iterator &operator++() { advancePoint(1); return *this; }
         const_iterator  operator++(int) { const_iterator n= *this; operator++(); return const_iterator(n); }
         const_iterator &operator--() { advancePoint(-1); return *this; }
         const_iterator  operator--(int) { const_iterator n= *this; operator--(); return const_iterator(n); }
         const_iterator &operator+=(int idx) { advancePoint(idx); return *this; }
         const_iterator &operator-=(int idx) { advancePoint(-idx); return *this; }
         const_iterator  operator+(int idx) const { const_iterator n= *this; n.advancePoint(idx); return n; }
         const_iterator  operator-(int idx) const { const_iterator n= *this; n.advancePoint(-idx); return n; }
         difference_type operator-(const_iterator other) const { QHULL_ASSERT(dimension()==other.dimension()); return (coordinates()-other.coordinates())/dimension(); }
     };//QhullPoints::const_iterator
 
 #//IO
     struct PrintPoints{
         const QhullPoints  *points;
         const char     *point_message;
         int             run_id;
         bool            with_identifier;
         PrintPoints(int qhRunId, const char *message, bool withIdentifier, const QhullPoints &ps) : points(&ps), point_message(message), run_id(qhRunId), with_identifier(withIdentifier) {}
     };//PrintPoints
     PrintPoints          print() const { return  PrintPoints(UsingLibQhull::NOqhRunId, "", false, *this); }
     PrintPoints          print(int qhRunId) const { return PrintPoints(qhRunId, "", true, *this); }
     PrintPoints          print(int qhRunId, const char *message) const { return PrintPoints(qhRunId, message, false, *this); }
     PrintPoints          printWithIdentifier(int qhRunId, const char *message) const { return PrintPoints(qhRunId, message, true, *this); }
     //FIXUP remove message for print()?
 };//QhullPoints
 
 // can't use QHULL_DECLARE_SEQUENTIAL_ITERATOR because next(),etc would return a reference to a temporary
 class QhullPointsIterator
 {
     typedef QhullPoints::const_iterator const_iterator;
 
 private:
 #//Fields
     const QhullPoints  *ps;
     const_iterator      i;
 
 public:
                         QhullPointsIterator(const QhullPoints &other) : ps(&other), i(ps->constBegin()) {}
     QhullPointsIterator &operator=(const QhullPoints &other) { ps = &other; i = ps->constBegin(); return *this; }
     bool                findNext(const QhullPoint &t);
     bool                findPrevious(const QhullPoint &t);
     bool                hasNext() const { return i != ps->constEnd(); }
     bool                hasPrevious() const { return i != ps->constBegin(); }
     QhullPoint          next() { return *i++; }
     QhullPoint          peekNext() const { return *i; }
     QhullPoint          peekPrevious() const { const_iterator p = i; return *--p; }
     QhullPoint          previous() { return *--i; }
     void                toBack() { i = ps->constEnd(); }
     void                toFront() { i = ps->constBegin(); }
 };//QhullPointsIterator
 
 }//namespace orgQhull
 
 #//Global functions
 
 std::ostream           &operator<<(std::ostream &os, const orgQhull::QhullPoints &p);
 std::ostream           &operator<<(std::ostream &os, const orgQhull::QhullPoints::PrintPoints &pr);
 
 #endif // QHULLPOINTS_H
diff --git a/src/libqhullrcpp/QhullQh.cpp b/src/libqhullpcpp/QhullQh.cpp
similarity index 94%
rename from src/libqhullrcpp/QhullQh.cpp
rename to src/libqhullpcpp/QhullQh.cpp
index f108f5c..89cb850 100644
--- a/src/libqhullrcpp/QhullQh.cpp
+++ b/src/libqhullpcpp/QhullQh.cpp
@@ -1,104 +1,104 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullQh.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullQh.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullQh -- Qhull's global data structure, qhT, as a C++ class
 
 
 
 #include "QhullError.h"
 #include "QhullQh.h"
 #include "QhullStat.h"
 
 #include <sstream>
 #include <iostream>
 
 using std::cerr;
 using std::string;
 using std::vector;
 using std::ostream;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  // interaction between '_setjmp' and C++ object destruction is non-portable
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//Global variables
 
 #//Constructor, destructor, etc.
 
 //! If qh_QHpointer==0, invoke with placement new on qh_qh;
 //! Sets qh_qh and qh_qhstat.  Need to reset before UsingLibQhull.
 //! Derived from qh_new_qhull[user.c]
 QhullQh::
 QhullQh()
 {
     static boolT firstcall = True;
 
     if(firstcall){
         if(qhmem.BUFinit!=0){
             throw QhullError(10017, "Qhull error: qhmem already initialized by another class.");
         }
         qh_meminit(NULL);
         firstcall= False;
     }
     // QhullQh() and UsingLibQhull() are the same
 #if qh_QHpointer
     if(qh_qh){
         if(qh old_qhstat){
             throw QhullError(10041, "Qhull internal error: qh_qh.old_qhstat defined (%x) but qh_qh is active.  qh_qh not restored correctly.", 0, 0, 0.0, qh old_qhstat);
         }
         qh old_qhstat= qh_qhstat;
         qh old_tempstack= qhmem.tempstack;
         qh_qhstat= 0;
         qhmem.tempstack= 0;
     }
     qh_qh= static_cast<qhT*>(this);
 #else
     if(strncmp(qh qhull, "qhull", 5) == 0){
         throw QhullError(10022, "Qhull error: Qhull already initialized as run %d", qh run_id);
     }
 #endif
     // NOerrors -- Does not call qh_errexit()
     qh_initstatistics();
     // NOerrors -- Does not call qh_errexit()
     qh_initqhull_start2(NULL, NULL, qh_FILEstderr);
 }//QhullQh
 
 //! UsingLibQhull must be declared along with QhullQh
 QhullQh::
 ~QhullQh()
 {
 #if qh_QHpointer
     if(!qh_qh){
         QhullError e(10042, "Qhull internal error: qh_qh undefined.  Was ~QhullQh() invoked independent of UsingLibQhull?", qh run_id, 0, 0, qh_qh);
         e.logError();
     }else if(!qh_qhstat){
         QhullError e(10043, "Qhull internal error: qh_qhstat null.  Is another thread running?");
         e.logError();
     }else if(qh_qh!=this){
         QhullError e(10044, "Qhull error: ~QhullQh() invoked independent of UsingLibQhull. qh_qh %x (runId %d) vs. QhullQh.runId %d.", qh run_id, run_id, 0.0, qh_qh);
         e.logError();
     }else{
         qh_freeqhull2(qh_ALL); // sets qh.NOerrexit.  Clears struct *qh_qh including run_id, but not qh_qh itself
     }
 #else
     if(&qh_qh!=this){
         QhullError e(10045, "Qhull error: ~QhullQh() invoked independent of UsingLibQhull. qh_qh %x (runId %d) vs. QhullQh.runId %d.", qh run_id, run_id, 0.0, qh_qh);
         e.logError();
     }else{
         qh_freeqhull2(qh_ALL); // sets qh.NOerrexit.  Clears struct *qh_qh including run_id, but not qh_qh itself
     }
 #endif
 }//~QhullQh
 
 #//Parallel Access
 
 }//namespace orgQhull
 
diff --git a/src/libqhullrcpp/QhullQh.h b/src/libqhullpcpp/QhullQh.h
similarity index 90%
rename from src/libqhullrcpp/QhullQh.h
rename to src/libqhullpcpp/QhullQh.h
index bb0439a..59782f9 100644
--- a/src/libqhullrcpp/QhullQh.h
+++ b/src/libqhullpcpp/QhullQh.h
@@ -1,51 +1,51 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullQh.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullQh.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLQH_H
 #define QHULLQH_H
 
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <string>
 #include <vector>
 
 namespace orgQhull {
 
 #//defined here
     //! QhullQh -- Qhull's global data structure, qhT, as a C++ class
     //! See UsingLibQhull.h for C++/C interface to qhT
     class QhullQh;
 
 class QhullQh : public qhT {
 
 #//Constants
     // Set ignored.  PointSet needs explicit dimension
     // Facet from vertices or ridges.vertices.count
     // Ridge from vertices.count
     // Vertex stored in vertexT?  1->16?
     // QhullPoint needs explicit dimension
 
 #//members (empty) -- POD type equivalent to qhT.  No data or virtual members
 
 public:
 #//constructor, assignment, destructor, invariant
     QhullQh();
     ~QhullQh();
 
 private:
     //!disable copy constructor and assignment
                         QhullQh(const QhullQh &);
     QhullQh            &operator=(const QhullQh &);
 
 };//class QhullQh
 
 }//namespace orgQhull
 
 #endif // QHULLQH_H
diff --git a/src/libqhullrcpp/QhullRidge.cpp b/src/libqhullpcpp/QhullRidge.cpp
similarity index 93%
rename from src/libqhullrcpp/QhullRidge.cpp
rename to src/libqhullpcpp/QhullRidge.cpp
index 139bc2b..bde6bd3 100644
--- a/src/libqhullrcpp/QhullRidge.cpp
+++ b/src/libqhullpcpp/QhullRidge.cpp
@@ -1,102 +1,102 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullRidge.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullRidge.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullRidge -- Qhull's ridge structure, ridgeT, as a C++ class
 
 #include "QhullSets.h"
 #include "QhullVertex.h"
 #include "QhullRidge.h"
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  // interaction between '_setjmp' and C++ object destruction is non-portable
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//class statics
 ridgeT QhullRidge::
 s_empty_ridge= {0,0,0,0,0,
                 0,0};
 
 #//Constructor, destructor, etc.
 
 #//Accessors
 
 //! Return True if nextRidge3d
 //! Simplicial facets may have incomplete ridgeSets
 //! Does not use qh_qh or qh_errexit()
 bool QhullRidge::
 hasNextRidge3d(const QhullFacet f) const
 {
     vertexT *v= 0;
     ridgeT *ridge= qh_nextridge3d(getRidgeT(), f.getFacetT(), &v);
     return (ridge!=0);
 }//hasNextRidge3d
 
 
 
 //! Return next ridge and optional vertex for a 3d facet and ridge
 //! Does not use qh_qh or qh_errexit()
 QhullRidge QhullRidge::
 nextRidge3d(const QhullFacet f, QhullVertex *nextVertex) const
 {
     vertexT *v= 0;
     ridgeT *ridge= qh_nextridge3d(getRidgeT(), f.getFacetT(), &v);
     if(!ridge){
         throw QhullError(10030, "Qhull error nextRidge3d:  missing next ridge for facet %d ridge %d.  Does facet contain ridge?", f.id(), id());
     }
     if(nextVertex!=0){
         *nextVertex= QhullVertex(v);
     }
     return QhullRidge(ridge);
 }//nextRidge3d
 
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::ostream;
 using orgQhull::QhullRidge;
 using orgQhull::QhullVertex;
 using orgQhull::UsingLibQhull;
 
 ostream &
 operator<<(ostream &os, const QhullRidge &r)
 {
     os << r.print(UsingLibQhull::NOqhRunId);
     return os;
 }//<< QhullRidge
 
 //! Duplicate of qh_printridge [io.c]
 //!  if pr.run_id==UsingLibQhull::NOqhRunId, no access to qh [needed for QhullVertex/QhullPoint]
 ostream &
 operator<<(ostream &os, const QhullRidge::PrintRidge &pr)
 {
     QhullRidge r= *pr.ridge;
     os << "     - r" << r.id();
     if(r.getRidgeT()->tested){
         os << " tested";
     }
     if(r.getRidgeT()->nonconvex){
         os << " nonconvex";
     }
     os << endl;
     os << r.vertices().print(pr.run_id, "           vertices:");
     if(r.getRidgeT()->top && r.getRidgeT()->bottom){
         os << "           between f" << r.topFacet().id() << " and f" << r.bottomFacet().id() << endl;
     }else if(r.getRidgeT()->top){
         os << "           top f" << r.topFacet().id() << endl;
     }else if(r.getRidgeT()->bottom){
         os << "           bottom f" << r.bottomFacet().id() << endl;
     }
 
     return os;
 }//<< PrintRidge
diff --git a/src/libqhullrcpp/QhullRidge.h b/src/libqhullpcpp/QhullRidge.h
similarity index 96%
rename from src/libqhullrcpp/QhullRidge.h
rename to src/libqhullpcpp/QhullRidge.h
index 111e678..a3e7e4c 100644
--- a/src/libqhullrcpp/QhullRidge.h
+++ b/src/libqhullpcpp/QhullRidge.h
@@ -1,110 +1,110 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullRidge.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullRidge.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLRIDGE_H
 #define QHULLRIDGE_H
 
 #include "QhullSet.h"
 #include "QhullVertex.h"
 #include "QhullVertexSet.h"
 #include "QhullFacet.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//ClassRef
     class QhullVertex;
     class QhullVertexSet;
     class QhullFacet;
 
 #//Types
     //! QhullRidge -- Qhull's ridge structure, ridgeT [libqhull.h], as a C++ class
     class QhullRidge;
     typedef QhullSet<QhullRidge>  QhullRidgeSet;
     typedef QhullSetIterator<QhullRidge>  QhullRidgeSetIterator;
 
     // see QhullSets.h for QhullRidgeSet and QhullRidgeSetIterator -- avoids circular references
 
 /************************
 a ridge is hull_dim-1 simplex between two neighboring facets.  If the
 facets are non-simplicial, there may be more than one ridge between
 two facets.  E.G. a 4-d hypercube has two triangles between each pair
 of neighboring facets.
 
 topological information:
     vertices            a set of vertices
     top,bottom          neighboring facets with orientation
 
 geometric information:
     tested              True if ridge is clearly convex
     nonconvex           True if ridge is non-convex
 */
 
 class QhullRidge {
 
 #//Fields
     ridgeT             *qh_ridge;
 
 #//Class objects
     static ridgeT       s_empty_ridge;
 
 public:
 #//Constants
 
 #//Constructors
                         QhullRidge() : qh_ridge(&s_empty_ridge) {}
                         // Creates an alias.  Does not copy QhullRidge.  Needed for return by value and parameter passing
                         QhullRidge(const QhullRidge &o) : qh_ridge(o.qh_ridge) {}
                         // Creates an alias.  Does not copy QhullRidge.  Needed for vector<QhullRidge>
     QhullRidge         &operator=(const QhullRidge &o) { qh_ridge= o.qh_ridge; return *this; }
                        ~QhullRidge() {}
 
 #//Conversion
                         //Implicit conversion from ridgeT
                         QhullRidge(ridgeT *r) : qh_ridge(r ? r : &s_empty_ridge) {}
     ridgeT             *getRidgeT() const { return qh_ridge; }
 
 #//QhullSet<QhullRidge>
     ridgeT             *getBaseT() const { return getRidgeT(); }
 
 #//getSet
     QhullFacet          bottomFacet() const { return QhullFacet(qh_ridge->bottom); }
     int                 dimension() const { return QhullSetBase::count(qh_ridge->vertices); }
     int                 id() const { return qh_ridge->id; }
     bool                isDefined() const { return qh_ridge != &s_empty_ridge; }
     bool                operator==(const QhullRidge &o) const { return qh_ridge==o.qh_ridge; }
     bool                operator!=(const QhullRidge &o) const { return !operator==(o); }
     QhullFacet          otherFacet(QhullFacet f) const { return QhullFacet(qh_ridge->top==f.getFacetT() ? qh_ridge->bottom : qh_ridge->top); }
     QhullFacet          topFacet() const { return QhullFacet(qh_ridge->top); }
 
 #//forEach
     bool                hasNextRidge3d(const QhullFacet f) const;
     QhullRidge          nextRidge3d(const QhullFacet f) const { return nextRidge3d(f, 0); }
     QhullRidge          nextRidge3d(const QhullFacet f, QhullVertex *nextVertex) const;
     QhullVertexSet      vertices() const { return QhullVertexSet(qh_ridge->vertices); }
 
 #//IO
 
     struct PrintRidge{
         const QhullRidge *ridge;
         int             run_id;
                         PrintRidge(int qhRunId, const QhullRidge &r) : ridge(&r), run_id(qhRunId) {}
     };//PrintRidge
     PrintRidge          print(int qhRunId) const { return PrintRidge(qhRunId, *this); }
 };//class QhullRidge
 
 }//namespace orgQhull
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullRidge &r); 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullRidge::PrintRidge &pr);
 
 #endif // QHULLRIDGE_H
diff --git a/src/libqhullrcpp/QhullSet.cpp b/src/libqhullpcpp/QhullSet.cpp
similarity index 84%
rename from src/libqhullrcpp/QhullSet.cpp
rename to src/libqhullpcpp/QhullSet.cpp
index d7965ef..0c03e66 100644
--- a/src/libqhullrcpp/QhullSet.cpp
+++ b/src/libqhullpcpp/QhullSet.cpp
@@ -1,47 +1,47 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullSet.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullSet.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullSet -- Qhull's facet structure, facetT, as a C++ class
 
 #include "QhullError.h"
 #include "QhullSet.h"
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//static members
 
 setT QhullSetBase::
 s_empty_set;
 
 // Same code for qh_setsize [qset.c] and QhullSetBase::count
 int QhullSetBase::count(const setT *set)
 {
     int size;
     const setelemT *sizep;
 
     if (!set)
         return(0);
     sizep= SETsizeaddr_(set);
     if ((size= sizep->i)) {
         size--;
         if (size > set->maxsize) {
             // FIXUP QH11022 How to add additional output to a error? -- qh_setprint(qhmem.ferr, "set: ", set);
             throw QhullError(10032, "QhullSet internal error: current set size %d is greater than maximum size %d\n",
                 size, set->maxsize);
         }
     }else
         size= set->maxsize;
     return size;
 }
 
 
 }//namespace orgQhull
 
diff --git a/src/libqhullrcpp/QhullSet.h b/src/libqhullpcpp/QhullSet.h
similarity index 98%
rename from src/libqhullrcpp/QhullSet.h
rename to src/libqhullpcpp/QhullSet.h
index 0559274..b4b2eb9 100644
--- a/src/libqhullrcpp/QhullSet.h
+++ b/src/libqhullpcpp/QhullSet.h
@@ -1,360 +1,360 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullSet.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullSet.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QhullSet_H
 #define QhullSet_H
 
 #include "QhullError.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 
 #ifndef QHULL_NO_STL
 #include <vector>
 #endif
 
 #ifdef QHULL_USES_QT
  #include <QtCore/QList>
 #endif
 
 namespace orgQhull {
 
 #//Type
     class QhullSetBase;  //! Base class for QhullSet<T>
     //! QhullSet<T> -- A read-only wrapper to Qhull's collection class, setT.
     //!  QhullSet is similar to STL's <vector> and Qt's QVector.
     //!  QhullSet is unrelated to STL and Qt's set and map types (e.g., QSet and QMap)
     //!  For STL efficiency, QhullSet caches endPointer()
     //!  T must be a pointer type
     //!  A QhullSet does not own its contents -- erase(), clear(), removeFirst(), removeLast(), pop_back(), pop_front(), fromStdList() not defined
     //!  Qhull's FOREACHelement_() [qset.h] is more efficient than QhullSet.  It uses a NULL terminator instead of an end pointer.  STL requires an end pointer.
     //!  Derived from QhullLinkedList.h and Qt/core/tools/qvector.h
 
     //! QhullSetIterator<T> defined below
     //See: QhullPointSet, QhullLinkedList<T>
 
 class QhullSetBase {
 
 private:
 #//Fields --
     setT               *qh_set;
 
 #//Class objects
     static setT         s_empty_set;  //! Workaround for no setT allocator.  Used if setT* is NULL
 
 public:
 #//Class methods
     static int          count(const setT *set);
     //s may be null
     static bool         isEmpty(const setT *s) { return SETempty_(s); }
 
 
 #//Constructors
                         //! Copy constructor copies the pointer but not the set.  Needed for return by value and parameter passing.
                         QhullSetBase(const QhullSetBase &o) : qh_set(o.qh_set) {}
     explicit            QhullSetBase(setT *s) : qh_set(s ? s : &s_empty_set) {}
                        ~QhullSetBase() {}
 
 private:
                         //!disabled since memory allocation for QhullSet not defined
                         QhullSetBase() {}
                         //!disabled since qs= qs2 is ambiguous (pointer vs. contents)
     QhullSetBase       &operator=(const QhullSetBase &);
 public:
 
 #//Conversions
                         //! Not type-safe since setT may contain any type
     void                defineAs(setT *s) { qh_set= s ? s : &s_empty_set; }
     setT               *getSetT() const { return qh_set; }
     setT              **referenceSetT() { return &qh_set; }
 
 #//Read-only
     int                 count() const { return QhullSetBase::count(qh_set); }
     bool                empty() const { return SETfirst_(qh_set)==0; }
     bool                isEmpty() const { return empty(); }
     size_t              size() const { return count(); }
 
 #//Element
 protected:
     void              **beginPointer() const { return &qh_set->e[0].p; }
     void              **elementPointer(int idx) const { QHULL_ASSERT(idx>=0 && idx<qh_set->maxsize); return &SETelem_(qh_set, idx); }
                         //! Always points to 0
     void              **endPointer() const { return qh_setendpointer(qh_set); }
 };//QhullSetBase
 
 
 //! set of pointers to baseT, T.getBaseT()
 template <typename T>
 class QhullSet : public QhullSetBase {
 
 private:
 #//Fields -- see QhullSetBase
 
 #//Class objects
     static setT         s_empty_set;  //! Workaround for no setT allocator.  Used if setT* is NULL
 
 public:
 #//Subtypes
     typedef T         *iterator;
     typedef const T   *const_iterator;
     typedef typename QhullSet<T>::iterator Iterator;
     typedef typename QhullSet<T>::const_iterator ConstIterator;
 
 #//Class methods
     static int          count(const setT *set);
                         //s may be null
     static bool         isEmpty(const setT *s) { return SETempty_(s); }
 
 #//Constructors
                         //Copy constructor copies pointer but not contents.  Needed for return by value.
                         QhullSet<T>(const QhullSet<T> &o) : QhullSetBase(o) {}
                         //Conversion from setT* is not type-safe.  Implicit conversion for void* to T
     explicit            QhullSet<T>(setT *s) : QhullSetBase(s) { QHULL_ASSERT(sizeof(T)==sizeof(void *)); }
                        ~QhullSet<T>() {}
 
 private:
                         //!Disable default constructor and copy assignment.  See QhullSetBase
                         QhullSet<T>();
     QhullSet<T>        &operator=(const QhullSet<T> &);
 public:
 
 #//Conversion
 
 #ifndef QHULL_NO_STL
     std::vector<T>      toStdVector() const;
 #endif
 #ifdef QHULL_USES_QT
     QList<T>            toQList() const;
 #endif
 
 #//Read-only -- see QhullSetBase for count(), empty(), isEmpty(), size()
     using QhullSetBase::count;
     using QhullSetBase::isEmpty;
     // operator== defined for QhullSets of the same type
     bool                operator==(const QhullSet<T> &other) const { return qh_setequal(getSetT(), other.getSetT()); }
     bool                operator!=(const QhullSet<T> &other) const { return !operator==(other); }
 
 #//Element access
     const T            &at(int idx) const { return operator[](idx); }
     T                  &back() { return last(); }
     T                  &back() const { return last(); }
     //! end element is NULL
     const T            *constData() const { return constBegin(); }
     T                  *data() { return begin(); }
     const T            *data() const { return begin(); }
     T                  &first() { QHULL_ASSERT(!isEmpty()); return *begin(); }
     const T            &first() const { QHULL_ASSERT(!isEmpty()); return *begin(); }
     T                  &front() { return first(); }
     const T            &front() const { return first(); }
     T                  &last() { QHULL_ASSERT(!isEmpty()); return *(end()-1); }
     const T            &last() const {  QHULL_ASSERT(!isEmpty()); return *(end()-1); }
     // mid() not available.  No setT constructor
     T                  &operator[](int idx) { T *n= reinterpret_cast<T *>(elementPointer(idx)); QHULL_ASSERT(idx>=0 && n < reinterpret_cast<T *>(endPointer())); return *n; }
     const T            &operator[](int idx) const { const T *n= reinterpret_cast<const T *>(elementPointer(idx)); QHULL_ASSERT(idx>=0 && n < reinterpret_cast<T *>(endPointer())); return *n; }
     T                  &second() { return operator[](1); }
     const T            &second() const { return operator[](1); }
     T                   value(int idx) const;
     T                   value(int idx, const T &defaultValue) const;
 
 #//Read-write -- Not available, no setT constructor
 
 #//iterator
     iterator            begin() { return iterator(beginPointer()); }
     const_iterator      begin() const { return const_iterator(beginPointer()); }
     const_iterator      constBegin() const { return const_iterator(beginPointer()); }
     const_iterator      constEnd() const { return const_iterator(endPointer()); }
     iterator            end() { return iterator(endPointer()); }
     const_iterator      end() const { return const_iterator(endPointer()); }
 
 #//Search
     bool                contains(const T &t) const;
     int                 count(const T &t) const;
     int                 indexOf(const T &t) const { /* no qh_qh */ return qh_setindex(getSetT(), t.getBaseT()); }
     int                 lastIndexOf(const T &t) const;
 
 };//class QhullSet
 
 // FIXUP? can't use QHULL_DECLARE_SEQUENTIAL_ITERATOR because it is not a template
 
 template <typename T>
 class QhullSetIterator {
 
 #//Subtypes
     typedef typename QhullSet<T>::const_iterator const_iterator;
 
 private:
 #//Fields
     const_iterator      i;
     const_iterator      begin_i;
     const_iterator      end_i;
 
 public:
 #//Constructors
                         QhullSetIterator<T>(const QhullSet<T> &s) : i(s.begin()), begin_i(i), end_i(s.end()) {}
                         QhullSetIterator<T>(const QhullSetIterator<T> &o) : i(o.i), begin_i(o.begin_i), end_i(o.end_i) {}
     QhullSetIterator<T> &operator=(const QhullSetIterator<T> &o) { i= o.i; begin_i= o.begin_i; end_i= o.end_i; return *this; }
 
 #//ReadOnly
     int                 countRemaining() { return (int)(end_i-begin_i); } // WARN64
 
 #//Search
     bool                findNext(const T &t);
     bool                findPrevious(const T &t);
 
 #//Foreach
     bool                hasNext() const { return i != end_i; }
     bool                hasPrevious() const { return i != begin_i; }
     T                   next() { return *i++; }
     T                   peekNext() const { return *i; }
     T                   peekPrevious() const { const_iterator p = i; return *--p; }
     T                   previous() { return *--i; }
     void                toBack() { i = end_i; }
     void                toFront() { i = begin_i; }
 };//class QhullSetIterator
 
 #//== Definitions =========================================
 
 #//Conversion
 
 #ifndef QHULL_NO_STL
 template <typename T>
 std::vector<T> QhullSet<T>::
 toStdVector() const
 {
     QhullSetIterator<T> i(*this);
     std::vector<T> vs;
     vs.reserve(i.countRemaining());
     while(i.hasNext()){
         vs.push_back(i.next());
     }
     return vs;
 }//toStdVector
 #endif
 
 #ifdef QHULL_USES_QT
 template <typename T>
 QList<T> QhullSet<T>::
 toQList() const
 {
     QhullSetIterator<T> i(*this);
     QList<T> vs;
     while(i.hasNext()){
         vs.append(i.next());
     }
     return vs;
 }//toQList
 #endif
 
 #//Element
 
 template <typename T>
 T QhullSet<T>::
 value(int idx) const
 {
     // Avoid call to qh_setsize() and assert in elementPointer()
     const T *n= reinterpret_cast<const T *>(&SETelem_(getSetT(), idx));
     return (idx>=0 && n<end()) ? *n : T();
 }//value
 
 template <typename T>
 T QhullSet<T>::
 value(int idx, const T &defaultValue) const
 {
     // Avoid call to qh_setsize() and assert in elementPointer()
     const T *n= reinterpret_cast<const T *>(&SETelem_(getSetT(), idx));
     return (idx>=0 && n<end()) ? *n : defaultValue;
 }//value
 
 #//Search
 
 template <typename T>
 bool QhullSet<T>::
 contains(const T &t) const
 {
     setT *s= getSetT();
     void *e= t.getBaseT();  // contains() is not inline for better error reporting
     int result= qh_setin(s, e);
     return result!=0;
 }//contains
 
 template <typename T>
 int QhullSet<T>::
 count(const T &t) const
 {
     int c= 0;
     const T *i= data();
     const T *e= end();
     while(i<e){
         if(*i==t){
             c++;
         }
         i++;
     }
     return c;
 }//count
 
 template <typename T>
 int QhullSet<T>::
 lastIndexOf(const T &t) const
 {
     const T *b= begin();
     const T *i= end();
     while(--i>=b){
         if(*i==t){
             break;
         }
     }
     return (int)(i-b); // WARN64
 }//lastIndexOf
 
 #//QhullSetIterator
 
 template <typename T>
 bool QhullSetIterator<T>::
 findNext(const T &t)
 {
     while(i!=end_i){
         if(*(++i)==t){
             return true;
         }
     }
     return false;
 }//findNext
 
 template <typename T>
 bool QhullSetIterator<T>::
 findPrevious(const T &t)
 {
     while(i!=begin_i){
         if(*(--i)==t){
             return true;
         }
     }
     return false;
 }//findPrevious
 
 }//namespace orgQhull
 
 
 #//== Global namespace =========================================
 
 template <typename T>
 std::ostream &
 operator<<(std::ostream &os, const orgQhull::QhullSet<T> &qs)
 {
     const T *i= qs.begin();
     const T *e= qs.end();
     while(i!=e){
         os << *i;
         ++i;
     }
     return os;
 }//operator<<
 
 #endif // QhullSet_H
diff --git a/src/libqhullrcpp/QhullSets.h b/src/libqhullpcpp/QhullSets.h
similarity index 83%
rename from src/libqhullrcpp/QhullSets.h
rename to src/libqhullpcpp/QhullSets.h
index d3c61f8..245ebee 100644
--- a/src/libqhullrcpp/QhullSets.h
+++ b/src/libqhullpcpp/QhullSets.h
@@ -1,27 +1,27 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullSets.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullSets.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLSETS_H
 #define QHULLSETS_H
 
 #include "QhullSet.h"
 
 namespace orgQhull {
 
     //See: QhullFacetSet.h
     //See: QhullPointSet.h
     //See: QhullVertexSet.h
 
     // Avoid circular references between QhullFacet, QhullRidge, and QhullVertex
     class QhullRidge;
     typedef QhullSet<QhullRidge>  QhullRidgeSet;
     typedef QhullSetIterator<QhullRidge>  QhullRidgeSetIterator;
 
 }//namespace orgQhull
 
 #endif // QHULLSETS_H
diff --git a/src/libqhullrcpp/QhullStat.cpp b/src/libqhullpcpp/QhullStat.cpp
similarity index 78%
rename from src/libqhullrcpp/QhullStat.cpp
rename to src/libqhullpcpp/QhullStat.cpp
index d806f7e..fd11936 100644
--- a/src/libqhullrcpp/QhullStat.cpp
+++ b/src/libqhullpcpp/QhullStat.cpp
@@ -1,42 +1,42 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullStat.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullStat.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullStat -- Qhull's global data structure, statT, as a C++ class
 
 
 #include "QhullError.h"
 #include "QhullStat.h"
 
 #include <sstream>
 #include <iostream>
 
 using std::cerr;
 using std::string;
 using std::vector;
 using std::ostream;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//Constructor, destructor, etc.
 
 //! If qh_QHpointer==0, invoke with placement new on qh_stat;
 QhullStat::
 QhullStat()
 {
 }//QhullStat
 
 QhullStat::
 ~QhullStat()
 {
 }//~QhullStat
 
 }//namespace orgQhull
 
diff --git a/src/libqhullrcpp/QhullStat.h b/src/libqhullpcpp/QhullStat.h
similarity index 90%
rename from src/libqhullrcpp/QhullStat.h
rename to src/libqhullpcpp/QhullStat.h
index ba213dc..44a594a 100644
--- a/src/libqhullrcpp/QhullStat.h
+++ b/src/libqhullpcpp/QhullStat.h
@@ -1,52 +1,52 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullStat.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullStat.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLSTAT_H
 #define QHULLSTAT_H
 
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <string>
 #include <vector>
 
 namespace orgQhull {
 
 #//defined here
     //! QhullStat -- Qhull's statistics, qhstatT, as a C++ class
     //! Statistics defined with zzdef_() control Qhull's behavior, summarize its result, and report precision problems.
     class QhullStat;
 
 class QhullStat : public qhstatT {
 
 private:
 #//Fields (empty) -- POD type equivalent to qhstatT.  No data or virtual members
 
 public:
 #//Constants
 
 #//class methods
     static void         clearStatistics();
 
 #//constructor, assignment, destructor, invariant
                         QhullStat();
                        ~QhullStat();
 
 private:
     //!disable copy constructor and assignment
                         QhullStat(const QhullStat &);
     QhullStat          &operator=(const QhullStat &);
 public:
 
 #//Access
 };//class QhullStat
 
 }//namespace orgQhull
 
 #endif // QHULLSTAT_H
diff --git a/src/libqhullrcpp/QhullVertex.cpp b/src/libqhullpcpp/QhullVertex.cpp
similarity index 93%
rename from src/libqhullrcpp/QhullVertex.cpp
rename to src/libqhullpcpp/QhullVertex.cpp
index f5583a5..3cd6498 100644
--- a/src/libqhullrcpp/QhullVertex.cpp
+++ b/src/libqhullpcpp/QhullVertex.cpp
@@ -1,94 +1,94 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullVertex.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullVertex.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullVertex -- Qhull's vertex structure, vertexT, as a C++ class
 
 #include "UsingLibQhull.h"
 #include "QhullPoint.h"
 #include "QhullFacetSet.h"
 #include "QhullVertex.h"
 #include "QhullVertexSet.h"
 #include "QhullFacet.h"
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  // interaction between '_setjmp' and C++ object destruction is non-portable
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//class statics
 vertexT QhullVertex::
 s_empty_vertex= {0,0,0,0,0,
                  0,0,0,0,0,
                  0,0};
 
 #//ForEach
 
 //! Return neighboring facets for a vertex
 //! If neither merging nor Voronoi diagram, requires Qhull::defineVertexNeighborFacets() beforehand.
 QhullFacetSet QhullVertex::
 neighborFacets() const
 {
     if(!neighborFacetsDefined()){
         throw QhullError(10034, "Qhull error: neighboring facets of vertex %d not defined.  Please call Qhull::defineVertexNeighborFacets() beforehand.", id());
     }
     return QhullFacetSet(qh_vertex->neighbors);
 }//neighborFacets
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::ostream;
 using std::string;
 using std::vector;
 using orgQhull::QhullPoint;
 using orgQhull::QhullFacet;
 using orgQhull::QhullFacetSet;
 using orgQhull::QhullFacetSetIterator;
 using orgQhull::QhullVertex;
 using orgQhull::UsingLibQhull;
 
 //! Duplicate of qh_printvertex [io.c]
 ostream &
 operator<<(ostream &os, const QhullVertex::PrintVertex &pr)
 {
     QhullVertex v= *pr.vertex;
     QhullPoint p= v.point();
     os << "- p" << p.id(pr.run_id) << " (v" << v.id() << "): ";
     const realT *c= p.coordinates();
     for(int k= p.dimension(); k--; ){
         os << " " << *c++; // FIXUP QH11010 %5.2g
     }
     if(v.getVertexT()->deleted){
         os << " deleted";
     }
     if(v.getVertexT()->delridge){
         os << " ridgedeleted";
     }
     os << endl;
     if(v.neighborFacetsDefined()){
         QhullFacetSetIterator i= v.neighborFacets();
         if(i.hasNext()){
             os << " neighborFacets:";
             int count= 0;
             while(i.hasNext()){
                 if(++count % 100 == 0){
                     os << endl << "     ";
                 }
                 QhullFacet f= i.next();
                 os << " f" << f.id();
             }
             os << endl;
         }
     }
     return os;
 }//<< PrintVertex
 
diff --git a/src/libqhullrcpp/QhullVertex.h b/src/libqhullpcpp/QhullVertex.h
similarity index 96%
rename from src/libqhullrcpp/QhullVertex.h
rename to src/libqhullpcpp/QhullVertex.h
index 22b29ae..58a0a4f 100644
--- a/src/libqhullrcpp/QhullVertex.h
+++ b/src/libqhullpcpp/QhullVertex.h
@@ -1,103 +1,103 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullVertex.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullVertex.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLVERTEX_H
 #define QHULLVERTEX_H
 
 #include "UsingLibQhull.h"
 #include "QhullPoint.h"
 #include "QhullLinkedList.h"
 #include "QhullSet.h"
 extern "C" {
     #include "libqhull/qhull_a.h"
 }
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//ClassRef
     class QhullFacetSet;
 
 #//Types
     //! QhullVertex -- Qhull's vertex structure, vertexT [libqhull.h], as a C++ class
     class QhullVertex;
     typedef QhullLinkedList<QhullVertex> QhullVertexList;
     typedef QhullLinkedListIterator<QhullVertex> QhullVertexListIterator;
 
 
 /*********************
   topological information:
     next,previous       doubly-linked list of all vertices
     neighborFacets           set of adjacent facets (only if qh.VERTEXneighbors)
 
   geometric information:
     point               array of DIM coordinates
 */
 
 class QhullVertex {
 
 private:
 #//Fields
     vertexT            *qh_vertex;
 
 #//Class objects
     static vertexT      s_empty_vertex;  // needed for shallow copy
 
 public:
 #//Constants
 
 #//Constructors
                         QhullVertex() : qh_vertex(&s_empty_vertex) {}
                         // Creates an alias.  Does not copy QhullVertex.  Needed for return by value and parameter passing
                         QhullVertex(const QhullVertex &o) : qh_vertex(o.qh_vertex) {}
                         // Creates an alias.  Does not copy QhullVertex.  Needed for vector<QhullVertex>
     QhullVertex        &operator=(const QhullVertex &o) { qh_vertex= o.qh_vertex; return *this; }
                        ~QhullVertex() {}
 
 #//Conversion
                         //Implicit conversion from vertexT
                         QhullVertex(vertexT *v) : qh_vertex(v ? v : &s_empty_vertex) {}
     vertexT            *getVertexT() const { return qh_vertex; }
 
 #//QhullSet<QhullVertex>
     vertexT            *getBaseT() const { return getVertexT(); }
 
 #//getSet
     int                 dimension() const { return (qh_vertex->dim || !isDefined()) ? qh_vertex->dim : UsingLibQhull::globalVertexDimension(); }
     int                 id() const { return qh_vertex->id; }
     bool                isDefined() const { return qh_vertex != &s_empty_vertex; }
                         //! True if defineVertexNeighborFacets() already called.  Auotomatically set for facet merging, Voronoi diagrams
     bool                neighborFacetsDefined() const { return qh_vertex->neighbors != 0; }
     QhullVertex         next() const { return qh_vertex->next; }
     bool                operator==(const QhullVertex &o) const { return qh_vertex==o.qh_vertex; }
     bool                operator!=(const QhullVertex &o) const { return !operator==(o); }
     QhullPoint          point() const { return QhullPoint(dimension(), qh_vertex->point); }
     QhullVertex         previous() const { return qh_vertex->previous; }
 
 #//ForEach
     //See also QhullVertexList
     QhullFacetSet       neighborFacets() const;
 
 #//IO
     struct PrintVertex{
         const QhullVertex *vertex;
         int             run_id;
                         PrintVertex(int qhRunId, const QhullVertex &v) : vertex(&v), run_id(qhRunId) {}
     };//PrintVertex
     PrintVertex         print(int qhRunId) const { return PrintVertex(qhRunId, *this); }
 };//class QhullVertex
 
 }//namespace orgQhull
 
 #//GLobal
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullVertex::PrintVertex &pr);
 inline std::ostream &operator<<(std::ostream &os, const orgQhull::QhullVertex &v) { os << v.print(orgQhull::UsingLibQhull::NOqhRunId); return os; }
 
 #endif // QHULLVERTEX_H
diff --git a/src/libqhullrcpp/QhullVertexSet.cpp b/src/libqhullpcpp/QhullVertexSet.cpp
similarity index 94%
rename from src/libqhullrcpp/QhullVertexSet.cpp
rename to src/libqhullpcpp/QhullVertexSet.cpp
index e03c661..ed46135 100644
--- a/src/libqhullrcpp/QhullVertexSet.cpp
+++ b/src/libqhullpcpp/QhullVertexSet.cpp
@@ -1,110 +1,110 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullVertexSet.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullVertexSet.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! QhullVertexSet -- Qhull's linked Vertexs, as a C++ class
 
 #include "QhullVertex.h"
 #include "QhullVertexSet.h"
 #include "QhullPoint.h"
 #include "QhullRidge.h"
 #include "QhullVertex.h"
 
 using std::string;
 using std::vector;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4611)  /* interaction between '_setjmp' and C++ object destruction is non-portable */
                                     /* setjmp should not be implemented with 'catch' */
 #endif
 
 namespace orgQhull {
 
 QhullVertexSet::
 QhullVertexSet(int qhRunId, facetT *facetlist, setT *facetset, bool allfacets)
 : QhullSet<QhullVertex>(0)
 , qhsettemp_qhull(0)
 , qhsettemp_defined(false)
 {
     UsingLibQhull q(qhRunId);
     int exitCode = setjmp(qh errexit);
     if(!exitCode){ // no object creation -- destructors skipped on longjmp()
         setT *vertices= qh_facetvertices(facetlist, facetset, allfacets);
         defineAs(vertices);
         qhsettemp_qhull= s_qhull_output;
         qhsettemp_defined= true;
     }
     q.maybeThrowQhullMessage(exitCode);
 }//QhullVertexSet facetlist facetset
 
 void QhullVertexSet::
 freeQhSetTemp()
 {
     if(qhsettemp_defined){
         UsingLibQhull q(qhsettemp_qhull, QhullError::NOthrow);
         if(q.defined()){
             int exitCode = setjmp(qh errexit);
             if(!exitCode){ // no object creation -- destructors skipped on longjmp()
                 qh_settempfree(referenceSetT()); // errors if not top of tempstack or if qhmem corrupted
             }
             q.maybeThrowQhullMessage(exitCode, QhullError::NOthrow);
         }
     }
 }//freeQhSetTemp
 
 QhullVertexSet::
 ~QhullVertexSet()
 {
     freeQhSetTemp();
 }//~QhullVertexSet
 
 }//namespace orgQhull
 
 #//Global functions
 
 using std::endl;
 using std::ostream;
 using orgQhull::QhullPoint;
 using orgQhull::QhullVertex;
 using orgQhull::QhullVertexSet;
 using orgQhull::QhullVertexSetIterator;
 using orgQhull::UsingLibQhull;
 
 //! Print Vertex identifiers to stream.  Space prefix.  From qh_printVertexheader [io.c]
 ostream &
 operator<<(ostream &os, const QhullVertexSet::PrintIdentifiers &pr)
 {
     if(pr.print_message && *pr.print_message){
         os << pr.print_message;
     }
     for(QhullVertexSet::const_iterator i=pr.Vertex_set->begin(); i!=pr.Vertex_set->end(); ++i){
         const QhullVertex v= *i;
         os << " v" << v.id();
     }
     os << endl;
     return os;
 }//<<QhullVertexSet::PrintIdentifiers
 
 //! Duplicate of printvertices [io.c]
 //! If pr.run_id==UsingLibQhull::NOqhRunId, no access to qh [needed for QhullPoint]
 ostream &
 operator<<(ostream &os, const QhullVertexSet::PrintVertexSet &pr){
 
     os << pr.print_message;
     const QhullVertexSet *vs= pr.Vertex_set;
     QhullVertexSetIterator i= *vs;
     while(i.hasNext()){
         const QhullVertex v= i.next();
         const QhullPoint p= v.point();
         os << " p" << p.id(pr.run_id) << "(v" << v.id() << ")";
     }
     os << endl;
 
     return os;
 }//<< PrintVertexSet
 
 
diff --git a/src/libqhullrcpp/QhullVertexSet.h b/src/libqhullpcpp/QhullVertexSet.h
similarity index 95%
rename from src/libqhullrcpp/QhullVertexSet.h
rename to src/libqhullpcpp/QhullVertexSet.h
index 59fe0d5..d912bda 100644
--- a/src/libqhullrcpp/QhullVertexSet.h
+++ b/src/libqhullpcpp/QhullVertexSet.h
@@ -1,79 +1,79 @@
 /****************************************************************************
 **
 ** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/QhullVertexSet.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/QhullVertexSet.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHULLVERTEXSET_H
 #define QHULLVERTEXSET_H
 
 #include "QhullSet.h"
 
 #include <ostream>
 
 namespace orgQhull {
 
 #//ClassRef
     class               QhullVertex;
 
 #//Types
     //! QhullVertexSet -- a set of Qhull Vertices, as a C++ class.
     //! See Qhull
     class               QhullVertexSet;
     typedef QhullSetIterator<QhullVertex>
                         QhullVertexSetIterator;
 
 class QhullVertexSet : public QhullSet<QhullVertex> {
 
 private:
 #//Fields
     Qhull              *qhsettemp_qhull; //! For sets allocated with qh_settemp()
     bool                qhsettemp_defined;  //! Set was allocated with q_memalloc()
 
 public:
 #//Constructor
                         //Conversion from setT* is not type-safe.  Implicit conversion for void* to T
    explicit             QhullVertexSet(setT *s) : QhullSet<QhullVertex>(s), qhsettemp_qhull(0), qhsettemp_defined(false) {}
                         QhullVertexSet(int qhRunId, facetT *facetlist, setT *facetset, bool allfacets);
                         //Copy constructor copies pointer but not contents.  Needed for return by value.
                         QhullVertexSet(const QhullVertexSet &o) : QhullSet<QhullVertex>(o), qhsettemp_qhull(o.qhsettemp_qhull), qhsettemp_defined(o.qhsettemp_defined) {}
                        ~QhullVertexSet();
 
 private:
                         //!Disable default constructor and copy assignment.  See QhullSetBase
                         QhullVertexSet();
     QhullVertexSet      &operator=(const QhullVertexSet &);
 public:
 
 #//Constructor, destructor
     void                freeQhSetTemp();
 
 #//IO
     struct PrintVertexSet{
         const QhullVertexSet *Vertex_set;
         const char     *print_message;
         int             run_id;
                         PrintVertexSet(int qhRunId, const char *message, const QhullVertexSet *s) : Vertex_set(s), print_message(message), run_id(qhRunId) {}
     };//PrintVertexSet
     const PrintVertexSet       print(int qhRunId, const char *message) const { return PrintVertexSet(qhRunId, message, this); }
 
     struct PrintIdentifiers{
         const QhullVertexSet *Vertex_set;
         const char     *print_message;
                         PrintIdentifiers(const char *message, const QhullVertexSet *s) : Vertex_set(s), print_message(message) {}
     };//PrintIdentifiers
     PrintIdentifiers    printIdentifiers(const char *message) const { return PrintIdentifiers(message, this); }
 
 };//class QhullVertexSet
 
 }//namespace orgQhull
 
 #//== Global namespace =========================================
 
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullVertexSet::PrintVertexSet &pr);
 std::ostream &operator<<(std::ostream &os, const orgQhull::QhullVertexSet::PrintIdentifiers &p);
 inline std::ostream &operator<<(std::ostream &os, const orgQhull::QhullVertexSet &vs) { os << vs.print(orgQhull::UsingLibQhull::NOqhRunId, ""); return os; }
 
 #endif // QHULLVERTEXSET_H
diff --git a/src/libqhullrcpp/RboxPoints.cpp b/src/libqhullpcpp/RboxPoints.cpp
similarity index 96%
rename from src/libqhullrcpp/RboxPoints.cpp
rename to src/libqhullpcpp/RboxPoints.cpp
index fd69940..e25960e 100644
--- a/src/libqhullrcpp/RboxPoints.cpp
+++ b/src/libqhullpcpp/RboxPoints.cpp
@@ -1,219 +1,219 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/RboxPoints.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/RboxPoints.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include "QhullError.h"
 #include "RboxPoints.h"
 
 #include <iostream>
 
 using std::cerr;
 using std::endl;
 using std::istream;
 using std::ostream;
 using std::ostringstream;
 using std::string;
 using std::vector;
 using std::ws;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #pragma warning( disable : 4996)  // function was declared deprecated(strcpy, localtime, etc.)
 #endif
 
 namespace orgQhull {
 
 #//! RboxPoints -- generate random PointCoordinates for qhull (rbox)
 
 #//Global
 
 //! pointer to RboxPoints for qh_fprintf callback
 RboxPoints *rbox_output= 0;
 
 #//Construct
 RboxPoints::
 RboxPoints()
 : PointCoordinates("rbox")
 , rbox_new_count(0)
 , rbox_status(qh_ERRnone)
 , rbox_message()
 {}
 
 RboxPoints::
 RboxPoints(const char *rboxCommand)
 : PointCoordinates("rbox")
 , rbox_new_count(0)
 , rbox_status(qh_ERRnone)
 , rbox_message()
 {
     appendPoints(rboxCommand);
 }
 
 RboxPoints::
 RboxPoints(const RboxPoints &other)
 : PointCoordinates(other)
 , rbox_new_count(0)
 , rbox_status(other.rbox_status)
 , rbox_message(other.rbox_message)
 {}
 
 RboxPoints & RboxPoints::
 operator=(const RboxPoints &other)
 {
     PointCoordinates::operator=(other);
     rbox_new_count= other.rbox_new_count;
     rbox_status= other.rbox_status;
     rbox_message= other.rbox_message;
     return *this;
 }//operator=
 
 
 RboxPoints::
 ~RboxPoints()
 {}
 
 #//Error
 
 void RboxPoints::
 clearRboxMessage()
 {
     rbox_status= qh_ERRnone;
     rbox_message.clear();
 }//clearRboxMessage
 
 std::string RboxPoints::
 rboxMessage() const
 {
     if(rbox_status!=qh_ERRnone){
         return rbox_message;
     }
     if(isEmpty()){
         return "rbox warning: no points generated\n";
     }
     return "rbox: OK\n";
 }//rboxMessage
 
 int RboxPoints::
 rboxStatus() const
 {
     return rbox_status;
 }
 
 bool RboxPoints::
 hasRboxMessage() const
 {
     return (rbox_status!=qh_ERRnone);
 }
 
 #//Modify
 
 void RboxPoints::
 appendPoints(const char *rboxCommand)
 {
     string s("rbox ");
     s += rboxCommand;
     char *command= const_cast<char*>(s.c_str());
     if(rbox_output){
         throw QhullError(10001, "Qhull error: Two simultaneous calls to RboxPoints::appendPoints().  Prevent two processes calling appendPoints() at the same time.  Other RboxPoints '%s'", 0, 0, 0, rbox_output->comment().c_str());
     }
     if(extraCoordinatesCount()!=0){
         throw QhullError(10067, "Qhull error: Extra coordinates (%d) prior to calling RboxPoints::appendPoints.  Was %s", extraCoordinatesCount(), 0, 0.0, comment().c_str());
     }
     int previousCount= count();
     rbox_output= this;              // set rbox_output for qh_fprintf()
     int status= ::qh_rboxpoints(0, 0, command);
     rbox_output= 0;
     if(rbox_status==qh_ERRnone){
         rbox_status= status;
     }
     if(rbox_status!=qh_ERRnone){
         throw QhullError(rbox_status, rbox_message);
     }
     if(extraCoordinatesCount()!=0){
         throw QhullError(10002, "Qhull error: extra coordinates (%d) for PointCoordinates (%x)", extraCoordinatesCount(), 0, 0.0, coordinates());
     }
     if(previousCount+newCount()!=count()){
         throw QhullError(10068, "Qhull error: rbox specified %d points but got %d points for command '%s'", newCount(), count()-previousCount, 0.0, comment().c_str());
     }
 }//appendPoints
 
 }//namespace orgQhull
 
 #//Global functions
 
 /*-<a                             href="qh-user.htm#TOC"
 >-------------------------------</a><a name="qh_fprintf_rbox">-</a>
 
   qh_fprintf_rbox(fp, msgcode, format, list of args )
     fp is ignored (replaces qh_fprintf_rbox() in userprintf_rbox.c)
     rbox_output == RboxPoints
 
 notes:
     only called from qh_rboxpoints()
     same as fprintf() and Qhull::qh_fprintf()
     fgets() is not trapped like fprintf()
     Do not throw errors from here.  Use qh_errexit_rbox;
 */
 extern "C"
 void qh_fprintf_rbox(FILE*, int msgcode, const char *fmt, ... ) {
     va_list args;
 
     using namespace orgQhull;
 
     RboxPoints *out= rbox_output;
     va_start(args, fmt);
     if(msgcode<MSG_OUTPUT){
         char newMessage[MSG_MAXLEN];
         // RoadError provides the message tag
         vsnprintf(newMessage, sizeof(newMessage), fmt, args);
         out->rbox_message += newMessage;
         if(out->rbox_status<MSG_ERROR || out->rbox_status>=MSG_STDERR){
             out->rbox_status= msgcode;
         }
         va_end(args);
         return;
     }
     switch(msgcode){
     case 9391:
     case 9392:
         out->rbox_message += "RboxPoints error: options 'h', 'n' not supported.\n";
         qh_errexit_rbox(10010);
         /* never returns */
     case 9393:
         {
             int dimension= va_arg(args, int);
             string command(va_arg(args, char*));
             int count= va_arg(args, int);
             out->setDimension(dimension);
             out->appendComment(" \"");
             out->appendComment(command.substr(command.find(' ')+1));
             out->appendComment("\"");
             out->setNewCount(count);
             out->reservePoints();
         }
         break;
     case 9407:
         *out << va_arg(args, int);
         // fall through
     case 9405:
         *out << va_arg(args, int);
         // fall through
     case 9403:
         *out << va_arg(args, int);
         break;
     case 9408:
         *out << va_arg(args, double);
         // fall through
     case 9406:
         *out << va_arg(args, double);
         // fall through
     case 9404:
         *out << va_arg(args, double);
         break;
     }
     va_end(args);
 } /* qh_fprintf_rbox */
 
diff --git a/src/libqhullrcpp/RboxPoints.h b/src/libqhullpcpp/RboxPoints.h
similarity index 93%
rename from src/libqhullrcpp/RboxPoints.h
rename to src/libqhullpcpp/RboxPoints.h
index 424454f..28e14aa 100644
--- a/src/libqhullrcpp/RboxPoints.h
+++ b/src/libqhullpcpp/RboxPoints.h
@@ -1,66 +1,66 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/RboxPoints.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/RboxPoints.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef RBOXPOINTS_H
 #define RBOXPOINTS_H
 
 #include "QhullPoint.h"
 #include "PointCoordinates.h"
 extern "C" {
 #include "libqhull/libqhull.h"
 }
 
 #include <stdarg.h>
 #include <string>
 #include <vector>
 #include <istream>
 #include <ostream>
 #include <sstream>
 
 namespace orgQhull {
 
 #//Types
     //! RboxPoints -- generate random PointCoordinates for Qhull
     class RboxPoints;
 
     class RboxPoints : public PointCoordinates {
 
 private:
 #//Fields and friends
     int                 rbox_new_count;     //! Number of points for PointCoordinates
     int                 rbox_status;    //! error status from rboxpoints.  qh_ERRnone if none.
     std::string         rbox_message;   //! stderr from rboxpoints
 
     friend void ::qh_fprintf_rbox(FILE *fp, int msgcode, const char *fmt, ... );
 
 public:
 #//Construct
                         RboxPoints();
     explicit            RboxPoints(const char *rboxCommand);
                         RboxPoints(const RboxPoints &other);
                         RboxPoints &operator=(const RboxPoints &other);
                        ~RboxPoints();
 
 public:
 #//GetSet
     void                clearRboxMessage();
     int                 newCount() const { return rbox_new_count; }
     std::string         rboxMessage() const;
     int                 rboxStatus() const;
     bool                hasRboxMessage() const;
     void                setNewCount(int pointCount) { QHULL_ASSERT(pointCount>=0); rbox_new_count= pointCount; }
 
 #//Modify
     void                appendPoints(const char* rboxCommand);
     using               PointCoordinates::appendPoints;
     void                reservePoints() { reserveCoordinates((count()+newCount())*dimension()); }
 };//class RboxPoints
 
 }//namespace orgQhull
 
 #endif // RBOXPOINTS_H
diff --git a/src/libqhullrcpp/RoadError.cpp b/src/libqhullpcpp/RoadError.cpp
similarity index 94%
rename from src/libqhullrcpp/RoadError.cpp
rename to src/libqhullpcpp/RoadError.cpp
index d0b6212..fd2377f 100644
--- a/src/libqhullrcpp/RoadError.cpp
+++ b/src/libqhullpcpp/RoadError.cpp
@@ -1,156 +1,156 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/RoadError.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/RoadError.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! RoadError -- All exceptions thrown by Qhull are RoadErrors
 #//! Do not throw RoadError's from destructors.  Use e.logError() instead.
 
 #include "RoadError.h"
 
 #include <string>
 #include <sstream>
 #include <iostream>
 
 using std::cerr;
 using std::cout;
 using std::string;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//Class fields
 
 //! Identifies error messages from Qhull and Road for web searches.
 //! See QhullError.h#QHULLlastError and user.h#MSG_ERROR
 const char * RoadError::
 ROADtag= "QH";
 
 std::ostringstream RoadError::
 global_log;
 
 #//Constructor
 
 RoadError::
 RoadError()
 : error_code(0)
 , log_event()
 , error_message()
 { }
 
 RoadError::
 RoadError(const RoadError &other)
 : error_code(other.error_code)
 , log_event(other.log_event)
 , error_message(other.error_message)
 {
 }//copy construct
 
 RoadError::
 RoadError(int code, const std::string &message)
 : error_code(code)
 , log_event(message.c_str())
 , error_message(log_event.toString(ROADtag, error_code))
 {
     log_event.cstr_1= error_message.c_str(); // overwrites initial value
 }
 
 RoadError::
 RoadError(int code, const char *fmt)
 : error_code(code)
 , log_event(fmt)
 , error_message()
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d)
 : error_code(code)
 , log_event(fmt, d)
 , error_message()
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d, int d2)
 : error_code(code)
 , log_event(fmt, d, d2)
 , error_message()
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d, int d2, float f)
 : error_code(code)
 , log_event(fmt, d, d2, f)
 , error_message()
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d, int d2, float f, const char *s)
 : error_code(code)
 , log_event(fmt, d, d2, f, s)
 , error_message(log_event.toString(ROADtag, code)) // char * may go out of scope
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d, int d2, float f, const void *x)
 : error_code(code)
 , log_event(fmt, d, d2, f, x)
 , error_message()
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d, int d2, float f, int i)
 : error_code(code)
 , log_event(fmt, d, d2, f, i)
 , error_message()
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d, int d2, float f, long long i)
 : error_code(code)
 , log_event(fmt, d, d2, f, i)
 , error_message()
 { }
 
 RoadError::
 RoadError(int code, const char *fmt, int d, int d2, float f, double e)
 : error_code(code)
 , log_event(fmt, d, d2, f, e)
 , error_message()
 { }
 
 RoadError & RoadError::
 operator=(const RoadError &other)
 {
     error_code= other.error_code;
     error_message= other.error_message;
     log_event= other.log_event;
     return *this;
 }//operator=
 
 #//Virtual
 const char * RoadError::
 what() const throw()
 {
     if(error_message.empty()){
         error_message= log_event.toString(ROADtag, error_code);
     }
     return error_message.c_str();
 }//what
 
 #//Updates
 
 //! Log error instead of throwing it.
 void RoadError::
 logError() const
 {
     global_log << what() << endl;
 }//logError
 
 
 }//namespace orgQhull
 
diff --git a/src/libqhullrcpp/RoadError.h b/src/libqhullpcpp/RoadError.h
similarity index 95%
rename from src/libqhullrcpp/RoadError.h
rename to src/libqhullpcpp/RoadError.h
index f9c1239..1c91154 100644
--- a/src/libqhullrcpp/RoadError.h
+++ b/src/libqhullpcpp/RoadError.h
@@ -1,86 +1,86 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/RoadError.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/RoadError.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef ROADERROR_H
 #define ROADERROR_H
 
 #include "RoadLogEvent.h"
 
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 
 using std::endl;
 
 namespace orgQhull {
 
 #//Types
     //! RoadError -- Report and log errors
     //!  See discussion in Saylan, G., "Practical C++ error handling in hybrid environments," Dr. Dobb's Journal, p. 50-55, March 2007.
     //!   He uses an auto_ptr to track a stringstream.  It constructs a string on the fly.  RoadError uses the copy constructor to transform RoadLogEvent into a string
     class RoadError;
 
 class RoadError : public std::exception {
 
 private:
 #//Fields
     int                 error_code;  //! Non-zero code (not logged), maybe returned as program status
     RoadLogEvent        log_event;   //! Format string w/ arguments
     mutable std::string error_message;  //! Formated error message.  Must be after log_event.
 
 #//Class fields
     static const char  *  ROADtag;
     static std::ostringstream  global_log; //! May be replaced with any ostream object
 
 public:
 #//Constants
 
 #//Constructors
     RoadError();
     RoadError(const RoadError &other);  //! Called on throw, generates error_message
     RoadError(int code, const std::string &message);
     RoadError(int code, const char *fmt);
     RoadError(int code, const char *fmt, int d);
     RoadError(int code, const char *fmt, int d, int d2);
     RoadError(int code, const char *fmt, int d, int d2, float f);
     RoadError(int code, const char *fmt, int d, int d2, float f, const char *s);
     RoadError(int code, const char *fmt, int d, int d2, float f, const void *x);
     RoadError(int code, const char *fmt, int d, int d2, float f, int i);
     RoadError(int code, const char *fmt, int d, int d2, float f, long long i);
     RoadError(int code, const char *fmt, int d, int d2, float f, double e);
 
     RoadError          &operator=(const RoadError &other);
                        ~RoadError() throw() {};
 
 #//Class methods
 
     static void         clearGlobalLog() { global_log.seekp(0); }
     static bool         emptyGlobalLog() { return global_log.tellp()<=0; }
     static const char  *stringGlobalLog() { return global_log.str().c_str(); }
 
 #//Virtual
     virtual const char *what() const throw();
 
 #//GetSet
     bool                isDefined() const { return log_event.isDefined(); }
     int                 errorCode() const { return error_code; };
    // FIXUP QH11021 should RoadError provide errorMessage().  Currently what()
     RoadLogEvent        roadLogEvent() const { return log_event; };
 
 #//Update
     void                logError() const;
 };//class RoadError
 
 }//namespace orgQhull
 
 #//Global functions
 
 inline std::ostream    &operator<<(std::ostream &os, const orgQhull::RoadError &e) { return os << e.what(); }
 
 #endif // ROADERROR_H
diff --git a/src/libqhullrcpp/RoadLogEvent.cpp b/src/libqhullpcpp/RoadLogEvent.cpp
similarity index 94%
rename from src/libqhullrcpp/RoadLogEvent.cpp
rename to src/libqhullpcpp/RoadLogEvent.cpp
index 4a0d479..1c5904f 100644
--- a/src/libqhullrcpp/RoadLogEvent.cpp
+++ b/src/libqhullpcpp/RoadLogEvent.cpp
@@ -1,122 +1,122 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/RoadLogEvent.cpp#1 $$Change: 1640 $
-** $Date: 2014/01/15 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/RoadLogEvent.cpp#1 $$Change: 1652 $
+** $Date: 2014/01/17 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #//! RoadError -- All exceptions thrown by Qhull are RoadErrors
 
 #include "RoadError.h"
 
 #include <string>
 #include <sstream>
 #include <iostream>
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::string;
 
 #ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
 #endif
 
 namespace orgQhull {
 
 #//!\name Conversion
 string RoadLogEvent::
 toString(const char *tag, int code) const
 {
     ostringstream os;
     if(tag && code){
         os << tag << code;
         if(format_string){
             os << " ";
         }
     }
     if(!format_string){
         return os.str();
     }
     const char *s= format_string;
     int dCount= 0;  // Count of %d
     int fCount= 0;  // Count of %f
     char extraCode= '\0';
     while(*s){
         if(*s!='%'){
             os << *s++;
         }else{
             char c= *++s;
             s++;
             switch(c){
             case 'd':
                 if(++dCount>2){
                     os << " ERROR_three_%d_in_format ";
                 }else if(dCount==2){
                     os << int_2;
                 }else{
                     os << int_1;
                 }
                 break;
             case 'e':
                 if(firstExtraCode(os, c, &extraCode)){
                     os << double_1;
                 }
                 break;
             case 'f':
                 if(++fCount>1){
                     os << " ERROR_two_%f_in_format ";
                 }else{
                     os << float_1;
                 }
                 break;
             case 'i':
                 if(firstExtraCode(os, c, &extraCode)){
                     os << int64_1;
                 }
                 break;
             case 's':
                 if(firstExtraCode(os, c, &extraCode)){
                     os << cstr_1;
                 }
                 break;
             case 'u':
                 if(firstExtraCode(os, c, &extraCode)){
                     os << "0x" << std::hex << int64_1 << std::dec;
                 }
                 break;
             case 'x':
                 if(firstExtraCode(os, c, &extraCode)){
                     os << void_1;
                 }
                 break;
             case '%':
                 os << c;
                 break;
             default:
                 os << " ERROR_%" << c << "_not_defined_in_format";
                 break;
             }
         }
     }
     if(s[-1]!='\n'){
         os << endl;
     }
     return os.str();
 }//toString
 
 #//Class helpers (static)
 
 //! True if this char is the first extra code
 bool RoadLogEvent::
 firstExtraCode(std::ostream &os, char c, char *extraCode){
     if(*extraCode){
         os << " ERROR_%" << *extraCode << "_and_%" << c << "_in_format ";
         return false;
     }
     *extraCode= c;
     return true;
 }//firstExtraCode
 
 }//namespace orgQhull
 
diff --git a/src/libqhullrcpp/RoadLogEvent.h b/src/libqhullpcpp/RoadLogEvent.h
similarity index 96%
rename from src/libqhullrcpp/RoadLogEvent.h
rename to src/libqhullpcpp/RoadLogEvent.h
index 3f6d2be..2024a17 100644
--- a/src/libqhullrcpp/RoadLogEvent.h
+++ b/src/libqhullpcpp/RoadLogEvent.h
@@ -1,77 +1,77 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/RoadLogEvent.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/RoadLogEvent.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef ROADLOGEVENT_H
 #define ROADLOGEVENT_H
 
 #include <ostream>
 #include <stdexcept>
 #include <string>
 
 namespace orgQhull {
 
 #//Types
     //! RoadLogEvent -- Record an event for the RoadLog
     struct RoadLogEvent;
 
 struct RoadLogEvent {
 
 public:
 #//Fields
     const char     *format_string; //! Format string (a literal with format codes, for logging)
     int             int_1;       //! Integer argument (%d, for logging)
     int             int_2;       //! Integer argument (%d, for logging)
     float           float_1;     //! Float argument (%f, for logging)
     union {                      //! One additional argument (for logging)
         const char *cstr_1;      //!   Cstr argument (%s) -- type checked at construct-time
         const void *void_1;      //!   Void* argument (%x) -- Use upper-case codes for object types
         long long   int64_1;     //!   signed int64 (%i).  Ambiguous if unsigned is also defined.
         double      double_1;    //!   Double argument (%e)
     };
 
 #//Constants
 
 #//Constructors
     RoadLogEvent() : format_string(0), int_1(0), int_2(0), float_1(0), int64_1(0) {};
     explicit RoadLogEvent(const char *fmt) : format_string(fmt), int_1(0), int_2(0), float_1(0), int64_1(0) {};
     RoadLogEvent(const char *fmt, int d) : format_string(fmt), int_1(d), int_2(0), float_1(0), int64_1(0) {};
     RoadLogEvent(const char *fmt, int d, int d2) : format_string(fmt), int_1(d), int_2(d2), float_1(0), int64_1(0) {};
     RoadLogEvent(const char *fmt, int d, int d2, float f) : format_string(fmt), int_1(d), int_2(d2), float_1(f), int64_1(0) {};
     RoadLogEvent(const char *fmt, int d, int d2, float f, const char *s) : format_string(fmt), int_1(d), int_2(d2), float_1(f), cstr_1(s) {};
     RoadLogEvent(const char *fmt, int d, int d2, float f, const void *x) : format_string(fmt), int_1(d), int_2(d2), float_1(f), void_1(x) {};
     RoadLogEvent(const char *fmt, int d, int d2, float f, int i) : format_string(fmt), int_1(d), int_2(d2), float_1(f), int64_1(i) {};
     RoadLogEvent(const char *fmt, int d, int d2, float f, long long i) : format_string(fmt), int_1(d), int_2(d2), float_1(f), int64_1(i) {};
     RoadLogEvent(const char *fmt, int d, int d2, float f, double g) : format_string(fmt), int_1(d), int_2(d2), float_1(f), double_1(g) {};
     ~RoadLogEvent() {};
     //! Default copy constructor and assignment
 
 #//GetSet
     bool                isDefined() const { return format_string!=0; }
     int                 int1() const { return int_1; };
     int                 int2() const { return int_2; };
     float               float1() const { return float_1; };
     const char         *format() const { return format_string; };
     const char         *cstr1() const { return cstr_1; };
     const void         *void1() const { return void_1; };
     long long           int64() const { return int64_1; };
     double              double1() const { return double_1; };
 
 #//Conversion
 
     std::string        toString(const char* tag, int code) const;
 
 private:
 #//Class helpers
     static bool         firstExtraCode(std::ostream &os, char c, char *extraCode);
 
 
 };//class RoadLogEvent
 
 }//namespace orgQhull
 
 #endif // ROADLOGEVENT_H
diff --git a/src/libqhullpcpp/UsingLibQhull.cpp b/src/libqhullpcpp/UsingLibQhull.cpp
new file mode 100644
index 0000000..9ee3156
--- /dev/null
+++ b/src/libqhullpcpp/UsingLibQhull.cpp
@@ -0,0 +1,373 @@
+/****************************************************************************
+**
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/UsingLibQhull.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
+**
+****************************************************************************/
+
+#//! UsingLibQhull -- Set up qhull C code from C++
+
+#include "Qhull.h"
+#include "UsingLibQhull.h"
+#include "QhullError.h"
+#include "QhullQh.h"
+
+#ifdef _MSC_VER  // Microsoft Visual C++ -- warning level 4
+#endif
+
+namespace orgQhull {
+
+#//Class objects
+
+const double UsingLibQhull::
+DEFAULTdistanceEpsilon= 1e-15*FACTORepsilon; //! ~DISTround*FACTORepsilon for unit cube
+
+const double UsingLibQhull::
+DEFAULTangleEpsilon= 1e-15*FACTORepsilon; //! ~ANGLEround*FACTORepsilon for unit cube
+
+    //! Global pointer to Qhull for qh_fprintf callback and QhullError
+Qhull *
+s_qhull_output= 0;
+
+double UsingLibQhull::
+s_angle_epsilon= 0;
+
+double UsingLibQhull::
+s_distance_epsilon= 0;
+
+//! For QhullPoint.id() w/o qhRunId.  Initialized by Qhull
+const coordT *UsingLibQhull::
+s_points_begin= 0;
+const coordT *UsingLibQhull::
+s_points_end= 0;
+int UsingLibQhull::
+s_points_dimension= 0;
+
+int UsingLibQhull::
+s_vertex_dimension= 0;  // FIXUP QH11023: s_vertex_dimension is required if dimension>15.  Cannot store in QhullVertex
+
+bool UsingLibQhull::
+s_has_points= false;
+
+bool UsingLibQhull::
+s_has_angle_epsilon= false;
+
+bool UsingLibQhull::
+s_has_vertex_dimension= false;
+
+bool UsingLibQhull::
+s_has_distance_epsilon= false;
+
+bool UsingLibQhull::
+s_using_libqhull= false;
+
+#//Constructors
+
+//! Grabs global state (qh_qh, qh_qhstat, qhmem.tempstack)
+//! Follow immediately with setjmp(qh errexit), otherwise errors in libqhull are not caught properly
+//! See qh_restore_qhull [global.c]
+UsingLibQhull::
+UsingLibQhull(Qhull *q)
+: my_qhull(q)
+, qh_exitcode(0)
+{
+    checkUsingLibQhull();
+    QhullQh *qhullqh= q->qhullQh();
+    if(!qhullqh){
+        throw QhullError(10014, "Qhull internal error: Qhull.qhullQh() not defined. initializeQhull() not called.");
+    }
+    if(qhullqh->run_id != q->qhull_run_id){
+        throw QhullError(10015, "Qhull error: QhullQh.runId %d != Qhull.runId %d.  Overwritten?", qhullqh->run_id, q->qhull_run_id);
+    }
+    // qh.old_qhstat is zero at initialization
+    // qh.old_tempstack is zero when empty
+    // QhullQh() and UsingLibQhull() are the same
+#if qh_QHpointer
+    if(qh_qh){
+        qh old_qhstat= qh_qhstat;
+        qh old_tempstack= qhmem.tempstack;
+    }
+    qh_qh= qhullqh;
+    qh_qhstat= qhullqh->old_qhstat;
+    qhmem.tempstack= qhullqh->old_tempstack;
+    qhullqh->old_qhstat= 0;
+    qhullqh->old_tempstack= 0;
+#else
+    #error FIXUP QH11024 static qh_qh not tested.  Delete the line to try.
+    if(qhullqh!=&qh_qh){
+        throw QhullError(10040, "Qhull internal error: Qhull.qhullQh() is not qh_qh (%x, static).  Overwrite?", 0,0,0.0, &qh_qh);
+    }
+#endif
+    s_qhull_output= q;      // set s_qhull_output for qh_fprintf()
+    qh NOerrexit= False;   // assumes setjmp called next
+}//UsingLibQhull qhull
+
+//! Same as UsingLibQhull but does not throw exceptions
+//! !defined() on failure.  For use in destructors
+UsingLibQhull::
+UsingLibQhull(Qhull *q, int noThrow)
+: my_qhull(0)  // Fail by default
+, qh_exitcode(0)
+{
+    QHULL_UNUSED(noThrow);
+
+    QhullQh *qhullqh= q->qhullQh();
+    if(s_using_libqhull){
+        QhullError e(10050, "Qhull error: UsingLibQhull already in use");
+        e.logError();
+    }else if(!qhullqh || qhullqh->run_id != q->qhull_run_id){
+        QhullError e(10051, "Qhull error: Qhull.qhullQh (%x) undefined or QhullQh.runId %d != Qhull.runId %d.  Overwritten?", (qhullqh ? qhullqh->run_id : -1), q->qhull_run_id, 0.0, qhullqh);
+        e.logError();
+    }else{
+        // qh.old_qhstat is zero at initialization
+        // qh.old_tempstack is zero when empty
+        // QhullQh() and UsingLibQhull() are the same
+#if qh_QHpointer
+        if(qh_qh){
+            qh old_qhstat= qh_qhstat;
+            qh old_tempstack= qhmem.tempstack;
+        }
+        qh_qh= qhullqh;
+        qh_qhstat= qhullqh->old_qhstat;
+        qhmem.tempstack= qhullqh->old_tempstack;
+        qhullqh->old_qhstat= 0;
+        qhullqh->old_tempstack= 0;
+#endif
+        my_qhull= q;
+        s_qhull_output= q;          // set s_qhull_output for qh_fprintf()
+        qh NOerrexit= False;   // assumes setjmp called next
+    }
+}//UsingLibQhull qhull noThrow
+
+//! Reuses current global state (qh_qh) from prior UsingQhull
+//! Errors if runId is not the same
+UsingLibQhull::
+UsingLibQhull(int qhRunId)
+: my_qhull(0)
+, qh_exitcode(0)
+{
+    checkUsingLibQhull();
+#if qh_QHpointer
+    if(!qh_qh || !qh_qhstat){
+        throw QhullError(10024, "Qhull error: UsingLibQhull is not active (qh_qh %x or qh_qhstat is not defined)", 0,0,0.0, qh_qh);
+    }
+#endif
+    if(qh run_id!=qhRunId){
+        throw QhullError(10036, "Qhull error: qhRunId %d != qh_qh.runId %d.  Is another Qhull active?", qhRunId, qh run_id);
+    }
+    if(!s_qhull_output){
+        throw QhullError(10037, "Qhull error: UsingLibQhull not active(s_qhull_output undefined).  Invoke UsingLibQhull before this call");
+    }
+    if(s_qhull_output->qhull_run_id!=qhRunId){
+        throw QhullError(10046, "Qhull error: qhRunId %d != s_qhull_output.runId %d.  Is another Qhull active", qhRunId, s_qhull_output->qhull_run_id);
+    }
+    my_qhull= s_qhull_output;
+    qh NOerrexit= False;   // assumes setjmp called next
+}//UsingLibQhull runId
+
+//Leaves libqhull active for runId access
+UsingLibQhull::
+~UsingLibQhull()
+{
+    QhullError e= checkRunId();
+    if(e.isDefined()){
+        e.logError();
+    }else{
+#if qh_QHpointer
+        if(qh_qh){
+            qh NOerrexit= true;
+        }
+#else
+        qh NOerrexit= true;
+#endif
+    }
+    s_using_libqhull= false;
+}//~UsingLibQhull
+
+#//Class methods
+
+void UsingLibQhull::
+checkQhullMemoryEmpty()
+{
+    int curlong, totlong, curshort, totshort, maxlong, totbuffer;
+    // qh_memtotal does not error
+    qh_memtotal(&curlong, &totlong, &curshort, &totshort, &maxlong, &totbuffer);
+    if (curlong || totlong){
+        throw QhullError(10026, "Qhull error: qhull did not free %d bytes of long memory (%d pieces).", totlong, curlong);
+    }
+    if (curshort || totshort){
+        throw QhullError(10035, "Qhull error: qhull did not free %d bytes of short memory (%d pieces).", totshort, curshort);
+    }
+}//checkQhullMemoryEmpty
+
+double UsingLibQhull::
+currentAngleEpsilon()
+{
+    if(s_qhull_output && s_qhull_output->initialized()){
+        return s_qhull_output->qhullQh()->ANGLEround*FACTORepsilon;
+    }else if(s_has_angle_epsilon){
+        return s_angle_epsilon;
+    }
+    return UsingLibQhull::DEFAULTangleEpsilon;
+}//currentAngleEpsilon
+
+double UsingLibQhull::
+currentDistanceEpsilon()
+{
+    if(s_qhull_output && s_qhull_output->initialized()){
+        return s_qhull_output->qhullQh()->DISTround*FACTORepsilon;
+    }else if(s_has_distance_epsilon){
+        return s_distance_epsilon;
+    }
+    return UsingLibQhull::DEFAULTdistanceEpsilon;
+}//currentDistanceEpsilon
+
+const coordT *UsingLibQhull::
+currentPoints(int *dimension, const coordT **pointsEnd)
+{
+    if(s_qhull_output && s_qhull_output->initialized()){
+        *dimension= qh hull_dim;
+        *pointsEnd= qh first_point+qh num_points*qh hull_dim;
+        return qh first_point;
+    }else if(s_has_points){
+        *dimension= s_points_dimension;
+        *pointsEnd= s_points_end;
+        return s_points_begin;
+    }
+    throw QhullError(10059, "Qhull error: missing definition for currentPoints().  Need currentQhull() or setGlobalDistanceEpsilon()");
+}//currentPoints
+
+Qhull &UsingLibQhull::
+currentQhull()
+{
+    if(!s_qhull_output){
+        throw QhullError(10055, "Qhull error: currentQhull not defined.  Run qhull first.");
+    }
+    return *s_qhull_output;
+}//currentQhull
+
+// for QhullVertex::dimension() when >= 16
+int UsingLibQhull::
+currentVertexDimension()
+{
+    if(s_qhull_output && s_qhull_output->initialized()){
+        return s_qhull_output->dimension();
+    }else if(s_has_vertex_dimension){
+        return s_vertex_dimension;
+    }
+    throw QhullError(10057, "Qhull error: missing definition for currentVertexDimension().  Need currentQhull() or setGlobalVertexDimension()");
+}//currentVertexDimension
+
+const coordT *UsingLibQhull::
+globalPoints(int *dimension, const coordT **pointsEnd)
+{
+    if(s_has_points){
+        *dimension= s_points_dimension;
+        *pointsEnd= s_points_end;
+        return s_points_begin;
+    }else{
+        return currentPoints(dimension, pointsEnd);
+    }
+}//globalPoints
+
+bool UsingLibQhull::
+hasPoints()
+{
+    return s_has_points || (s_qhull_output && s_qhull_output->initialized());
+}
+
+bool UsingLibQhull::
+hasVertexDimension()
+{
+    return s_has_vertex_dimension || (s_qhull_output && s_qhull_output->initialized());
+}
+
+void UsingLibQhull::
+setGlobals()
+{
+    if(s_qhull_output && s_qhull_output->initialized()){
+        QhullQh *qqh= s_qhull_output->qhullQh();
+        s_angle_epsilon= qqh->ANGLEround*FACTORepsilon;
+        s_distance_epsilon= qqh->DISTround*FACTORepsilon;
+        s_points_begin= qqh->first_point;
+        s_points_dimension= qqh->hull_dim;
+        s_points_end= s_points_begin+qqh->num_points*s_points_dimension;
+        s_vertex_dimension= qqh->hull_dim;
+        s_has_angle_epsilon= true;
+        s_has_distance_epsilon= true;
+        s_has_points= true;
+        s_has_vertex_dimension= true;
+    }else{
+        throw QhullError(10058, "Qhull error: setGlobals can only be called for currentQhull().  Run qhull first.");
+    }
+ }//setGlobals
+
+void UsingLibQhull::
+unsetGlobals()
+{
+    s_has_angle_epsilon= false;
+    s_has_distance_epsilon= false;
+    s_has_points= false;
+    s_has_vertex_dimension= false;
+}//unsetGlobals
+
+#// Methods
+
+void UsingLibQhull::
+maybeThrowQhullMessage(int exitCode) const
+{
+    my_qhull->maybeThrowQhullMessage(exitCode);
+    QhullError e= checkRunId(); // Check for qhRunId after libqhull returns. For convenience, ought to be at end of libqhull try block
+    if(e.isDefined()){
+        throw e;
+    }
+}//maybeThrowQhullMessage
+
+void UsingLibQhull::
+maybeThrowQhullMessage(int exitCode, int noThrow) const
+{
+    my_qhull->maybeThrowQhullMessage(exitCode, noThrow);
+    QhullError e= checkRunId(); // Check for qhRunId after libqhull returns. For convenience, ought to be at end of libqhull try block
+    if(e.isDefined()){
+        e.logError();
+    }
+}//maybeThrowQhullMessage
+
+#//Helpers
+
+//! Return QhullError for maybeThrowFromDestructor()
+QhullError UsingLibQhull::
+checkRunId() const
+{
+    // Predeclaring QhullError results in four copy constructors, none used here
+#if qh_QHpointer
+    if(qh_qh){ // 0 if ~Qhull
+        if(my_qhull->qhull_run_id!=qh run_id){
+            return QhullError(10047, "Qhull internal error: Global state (qh_qh, run_id %d) changed.  Should be runId %d.  Another thread?", qh run_id, my_qhull->qhull_run_id);
+        }
+    }
+#else
+    if(qh run_id!=0 && my_qhull->qhull_run_id!=qh run_id){
+        return QhullError(10048, "Qhull internal error: Global state (qh_qh, run_id %d) changed.  Should be runId %d.  Another thread?", qh run_id, my_qhull->qhull_run_id);
+    }
+#endif
+    return QhullError();
+}//checkRunId
+
+//! Can not embed UsingLibQhull.  Otherwise allocated a C++ object missed by qh_errexit
+void UsingLibQhull::
+checkUsingLibQhull() const
+{
+    if(s_using_libqhull){
+        if(s_qhull_output){
+            throw QhullError(10049, "Qhull error: UsingLibQhull already in use by QhullQh.runId %d", s_qhull_output->qhull_run_id);
+        }else{
+            throw QhullError(10050, "Qhull error: UsingLibQhull already in use.  No s_qhull_output");
+        }
+    }
+    s_using_libqhull= true;
+}//checkUsingLibQhull
+
+}//namespace orgQhull
+
diff --git a/src/libqhullpcpp/UsingLibQhull.h b/src/libqhullpcpp/UsingLibQhull.h
new file mode 100644
index 0000000..7b094d8
--- /dev/null
+++ b/src/libqhullpcpp/UsingLibQhull.h
@@ -0,0 +1,144 @@
+/****************************************************************************
+**
+** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/UsingLibQhull.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
+**
+****************************************************************************/
+
+#ifndef USINGlibqhull_H
+#define USINGlibqhull_H
+
+#include "QhullError.h"
+extern "C" {
+#include "libqhull/libqhull.h"
+}
+
+namespace orgQhull {
+
+#//Types
+    //! UsingLibQhull -- Interface into libqhull and its 'qh' and 'qhstat' macros
+    //! Always use with setjmp() for libqhull error handling.
+
+/*******************************
+
+UsingLibQhull is stack based, but as a call
+Qhull declarations are stack-based.  But can't define a
+setjmp environment, since the target goes away.  So must be UsingLibQhull, but can only have one
+setjmp at a time? Can embedded another Using as long as save/restore
+longjmp on exit.
+*/
+    class UsingLibQhull;
+
+    // Defined elsewhere
+    class Qhull;
+
+#// Global variables
+extern Qhull           *s_qhull_output; //! Provide qh_fprintf (Qhull.cpp) access to Qhull
+
+class UsingLibQhull {
+
+private:
+#//Fields
+    Qhull              *my_qhull;
+    int                 qh_exitcode;
+
+#//Class globals
+    //! Global flags
+    static bool         s_using_libqhull; //! True if UsingLibQhull is in scope
+
+    //! Use global values if s_has_... is set
+    static bool         s_has_angle_epsilon; //! True if s_angle_epsilon defined
+    static bool         s_has_distance_epsilon; //! True if s_distance_epsilon defined
+    static bool         s_has_points;        //! If False (default), Qhull() runs setPointBase()
+    static bool         s_has_vertex_dimension; //! True if s_vertex_dimension defined
+
+    //! Global values
+    static double       s_angle_epsilon;   //! Epsilon for angle equality
+    static double       s_distance_epsilon;   //! Epsilon for distance equality
+    static const coordT *s_points_begin;            //! For QhullPoint::id() w/o qhRunId.
+    static const coordT *s_points_end;            //! For QhullPoint::id() w/o qhRunId.
+    static int          s_points_dimension;
+    static int          s_vertex_dimension; //! Default dimension (e.g., if Vertex::dimension() >= 16)
+
+public:
+#//Class constants
+    static const int    NOqhRunId= 0;   //! qh_qh is not available
+    static const int    NOthrow= 1;     //! Do not throw from maybeThrowQhullMessage
+    static const int    FACTORepsilon= 10;  //!
+    static const double DEFAULTdistanceEpsilon; //! ~DISTround*FACTORepsilon for unit cube
+    static const double DEFAULTangleEpsilon;    //! ~ANGLEround*FACTORepsilon for unit cube
+
+#//Class members
+    static void         checkQhullMemoryEmpty();
+    static double       currentAngleEpsilon();
+    static double       currentDistanceEpsilon();
+    static const coordT *currentPoints(int *dimension, const coordT **pointsEnd);
+    static Qhull       &currentQhull();
+    static int          currentVertexDimension();
+    static double       globalAngleEpsilon() { return s_has_angle_epsilon ? s_angle_epsilon : currentAngleEpsilon(); }
+    static double       globalDistanceEpsilon() { return s_has_distance_epsilon ? s_distance_epsilon : currentDistanceEpsilon(); }
+    static double       globalMachineEpsilon() { return REALepsilon; }
+    static const coordT *globalPoints(int *dimension, const coordT **pointsEnd);
+    static int          globalVertexDimension() { return s_has_vertex_dimension ? s_vertex_dimension : currentVertexDimension(); }
+    static bool         hasPoints();        // inline would require Qhull.h
+    static bool         hasVertexDimension();
+    static void         setGlobalAngleEpsilon(double d) { s_angle_epsilon=d; s_has_angle_epsilon= true; }
+    static void         setGlobalDistanceEpsilon(double d) { s_distance_epsilon= d; s_has_distance_epsilon= true; }
+    static void         setGlobalPoints(int dimension, const coordT *pointsBegin, const coordT *pointsEnd) { s_points_dimension= dimension; s_points_begin= pointsBegin; s_points_end= pointsEnd; s_has_points= true; }
+    static void         setGlobalVertexDimension(int i) { s_vertex_dimension= i; s_has_vertex_dimension= true; }
+    static void         setGlobals();
+    static void         unsetGlobalAngleEpsilon() { s_has_angle_epsilon= false; }
+    static void         unsetGlobalDistanceEpsilon() { s_has_distance_epsilon= false; }
+    static void         unsetGlobalPoints() { s_has_points= false; }
+    static void         unsetGlobalVertexDimension() { s_has_vertex_dimension= false; }
+    static void         unsetGlobals();
+
+#//Constructors
+                        UsingLibQhull(Qhull *p);
+                        UsingLibQhull(Qhull *p, int noThrow);
+                        UsingLibQhull(int qhRunId);
+                       ~UsingLibQhull();
+
+private:                //! disable default constructor, copy constructor, and copy assignment
+                        UsingLibQhull();
+                        UsingLibQhull(const UsingLibQhull &);
+   UsingLibQhull       &operator=(const UsingLibQhull &);
+public:
+
+#//Methods
+#//Access
+    bool                defined() const { return my_qhull!=0; }
+    void                maybeThrowQhullMessage(int exitCode) const;
+    void                maybeThrowQhullMessage(int exitCode, int noThrow) const;
+
+#//Helpers
+private:
+   QhullError           checkRunId() const;
+   void                 checkUsingLibQhull() const;
+
+/***********************************
+You may use global variables in 'qh' after declaring UsingLibQhull.  For example
+
+  UsingLibQhull q(qhRunId);
+  // NOerrors -- no calls that throw libqhull errors
+  cout << "Delaunay Mode: " << qh DELAUNAY;
+
+To trap errors from libqhull, UsingLibQhull must be followed by
+
+UsingLibQhull q(qhRunId);
+int exitCode = setjmp(qh errexit);
+if(!exitCode){ // no object creation -- destructors skipped on longjmp()
+    calls to libqhull
+}
+q.maybeThrowQhullMessage(exitCode);
+
+The call to setjmp() can not be moved to a method.  The stack must be preserved for error exits from libqhull.
+
+*/
+
+};//UsingLibQhull
+
+}//namespace orgQhull
+
+#endif // USINGlibqhull_H
diff --git a/src/libqhullrcpp/functionObjects.h b/src/libqhullpcpp/functionObjects.h
similarity index 91%
rename from src/libqhullrcpp/functionObjects.h
rename to src/libqhullpcpp/functionObjects.h
index ad6647a..94c8d7a 100644
--- a/src/libqhullrcpp/functionObjects.h
+++ b/src/libqhullpcpp/functionObjects.h
@@ -1,66 +1,66 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/functionObjects.h#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/libqhullpcpp/functionObjects.h#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef QHFUNCTIONOBJECTS_H
 #define QHFUNCTIONOBJECTS_H
 
 #include <stdlib.h>
 #include <math.h>
 
 namespace orgQhull {
 #//Type
 
     //! Sum of absolute values of the elements in a container
     class AbsoluteSumOf;
     //! Sum of the elements in a container
     class SumOf;
     //! Sum of squares of the elements in a container
     class SumSquaresOf;
 
 #//Class
 
 //! Absolute sum of the elements in a container
 class AbsoluteSumOf
 {
 private:
     double sum;
 public:
     inline AbsoluteSumOf() : sum(0.0) {}
     inline void operator()(double v) { sum += fabs(v); }
     inline operator double() { return sum; }
 };//AbsoluteSumOf
 
 //! Sum of the elements in a container
 class SumOf
 {
 private:
     double sum;
 public:
     inline SumOf() : sum(0.0) {}
     inline void operator()(double v) { sum += v; }
     inline operator double() { return sum; }
 };//SumOf
 
 
 //! Sum of squares of the elements in a container
 class SumSquaresOf
 {
 private:
     double sum;
 public:
     inline SumSquaresOf() : sum(0.0) {}
     inline void operator()(double v) { sum += v*v; }
     inline operator double() { return sum; }
 };//SumSquaresOf
 
 
 }//orgQhull
 
 
 #endif //QHFUNCTIONOBJECTS_H
 
diff --git a/src/libqhullpcpp/libqhullpcpp.pro b/src/libqhullpcpp/libqhullpcpp.pro
new file mode 100644
index 0000000..cf07f5a
--- /dev/null
+++ b/src/libqhullpcpp/libqhullpcpp.pro
@@ -0,0 +1,71 @@
+# -------------------------------------------------
+# libqhullpcpp.pro -- Qt project for Qhull cpp shared library based on libqhullp
+# -------------------------------------------------
+
+include(../qhull-warn.pri)
+
+DESTDIR = ../../lib
+TEMPLATE = lib
+CONFIG += staticlib warn_on
+CONFIG -= qt rtti
+build_pass:CONFIG(debug, debug|release):{
+   TARGET = qhullcpp_pd
+   OBJECTS_DIR = Debug
+}else:build_pass:CONFIG(release, debug|release):{
+   TARGET = qhullcpp_p
+   OBJECTS_DIR = Release
+}
+MOC_DIR = moc
+
+DEFINES += qh_QHpointer # libqhull/user.h
+
+INCLUDEPATH += ../../src
+INCLUDEPATH += $$PWD # for MOC_DIR
+
+CONFIG += qhull_warn_shadow qhull_warn_conversion
+
+SOURCES += ../libqhullpcpp/Coordinates.cpp
+SOURCES += ../libqhullpcpp/PointCoordinates.cpp
+SOURCES += ../libqhullpcpp/Qhull.cpp
+SOURCES += ../libqhullpcpp/QhullFacet.cpp
+SOURCES += ../libqhullpcpp/QhullFacetList.cpp
+SOURCES += ../libqhullpcpp/QhullFacetSet.cpp
+SOURCES += ../libqhullpcpp/QhullHyperplane.cpp
+SOURCES += ../libqhullpcpp/QhullPoint.cpp
+SOURCES += ../libqhullpcpp/QhullPoints.cpp
+SOURCES += ../libqhullpcpp/QhullPointSet.cpp
+SOURCES += ../libqhullpcpp/QhullQh.cpp
+SOURCES += ../libqhullpcpp/QhullRidge.cpp
+SOURCES += ../libqhullpcpp/QhullSet.cpp
+SOURCES += ../libqhullpcpp/QhullStat.cpp
+SOURCES += ../libqhullpcpp/QhullVertex.cpp
+SOURCES += ../libqhullpcpp/QhullVertexSet.cpp
+SOURCES += ../libqhullpcpp/RboxPoints.cpp
+SOURCES += ../libqhullpcpp/RoadError.cpp
+SOURCES += ../libqhullpcpp/RoadLogEvent.cpp
+SOURCES += ../libqhullpcpp/UsingLibQhull.cpp
+
+HEADERS += ../libqhullpcpp/Coordinates.h
+HEADERS += ../libqhullpcpp/functionObjects.h
+HEADERS += ../libqhullpcpp/PointCoordinates.h
+HEADERS += ../libqhullpcpp/Qhull.h
+HEADERS += ../libqhullpcpp/QhullError.h
+HEADERS += ../libqhullpcpp/QhullFacet.h
+HEADERS += ../libqhullpcpp/QhullFacetList.h
+HEADERS += ../libqhullpcpp/QhullFacetSet.h
+HEADERS += ../libqhullpcpp/QhullHyperplane.h
+HEADERS += ../libqhullpcpp/QhullIterator.h
+HEADERS += ../libqhullpcpp/QhullLinkedList.h
+HEADERS += ../libqhullpcpp/QhullPoint.h
+HEADERS += ../libqhullpcpp/QhullPoints.h
+HEADERS += ../libqhullpcpp/QhullPointSet.h
+HEADERS += ../libqhullpcpp/QhullQh.h
+HEADERS += ../libqhullpcpp/QhullRidge.h
+HEADERS += ../libqhullpcpp/QhullSet.h
+HEADERS += ../libqhullpcpp/QhullSets.h
+HEADERS += ../libqhullpcpp/QhullStat.h
+HEADERS += ../libqhullpcpp/QhullVertex.h
+HEADERS += ../libqhullpcpp/RboxPoints.h
+HEADERS += ../libqhullpcpp/RoadError.h
+HEADERS += ../libqhullpcpp/RoadLogEvent.h
+HEADERS += ../libqhullpcpp/UsingLibQhull.h
diff --git a/src/libqhullpcpp/qhull_interface.cpp b/src/libqhullpcpp/qhull_interface.cpp
new file mode 100644
index 0000000..7c81511
--- /dev/null
+++ b/src/libqhullpcpp/qhull_interface.cpp
@@ -0,0 +1,96 @@
+/*<html><pre>  -<a                             href="../libqhull/qh-user.htm"
+  >-------------------------------</a><a name="TOP">-</a>
+*/
+
+#include <iostream.h>
+#include <conio.h>
+
+//--- Include qhull, so it works from with in a C++ source file
+//---
+//--- In MVC one cannot just do:
+//---
+//---    extern "C"
+//---    {
+//---      #include "qhull_a.h"
+//---    }
+//---
+//--- Because qhull_a.h includes math.h, which can not appear
+//--- inside a extern "C" declaration.
+//---
+//--- Maybe that why Numerical recipes in C avoid this problem, by removing
+//--- standard include headers from its header files and add them in the
+//--- respective source files instead.
+//---
+//--- [K. Erleben]
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <libqhull/qhulllib.h>
+#include <libqhull/mem.h>
+#include <libqhull/qset.h>
+#include <libqhull/geom.h>
+#include <libqhull/merge.h>
+#include <libqhull/poly.h>
+#include <libqhull/io.h>
+#include <libqhull/stat.h>
+#if defined(__cplusplus)
+}
+#endif
+
+/*********************************************************************/
+/*                                                                   */
+/*                                                                   */
+/*                                                                   */
+/*                                                                   */
+/*********************************************************************/
+
+void compute_convex_hull(void)
+{
+        int dim;                      /* dimension of points */
+        int numpoints;            /* number of points */
+        coordT *points;           /* array of coordinates for each point */
+        boolT ismalloc;           /* True if qhull should free points in qh_freeqhull() or reallocation */
+        char flags[]= "qhull Tv"; /* option flags for qhull, see qh_opt.htm */
+        FILE *outfile= stdout;    /* output from qh_produce_output()
+                                     use NULL to skip qh_produce_output() */
+        FILE *errfile= stderr;    /* error messages from qhull code */
+        int exitcode;             /* 0 if no error from qhull */
+        facetT *facet;            /* set by FORALLfacets */
+        int curlong, totlong;     /* memory remaining after qh_memfreeshort */
+
+        /* initialize dim, numpoints, points[], ismalloc here */
+        exitcode= qh_new_qhull(dim, numpoints, points, ismalloc,
+                                                        flags, outfile, errfile);
+        if (!exitcode) { /* if no error */
+                /* 'qh facet_list' contains the convex hull */
+                FORALLfacets {
+                        /* ... your code ... */
+                }
+        }
+        qh_freeqhull(!qh_ALL);
+        qh_memfreeshort(&curlong, &totlong);
+        if (curlong || totlong)
+                fprintf(errfile, "qhull internal warning (main): did not free %d bytes of long memory(%d pieces)\n",
+                             totlong, curlong);
+};
+
+/*********************************************************************/
+/*                                                                   */
+/*                                                                   */
+/*                                                                   */
+/*                                                                   */
+/*********************************************************************/
+
+void main()
+{
+        cout << "Hello world" << endl;
+
+        cout << "Press any key..." << endl;
+
+        while (!_kbhit());
+
+};
diff --git a/src/libqhullrcpp/qt-qhullr.cpp b/src/libqhullpcpp/qt-qhull.cpp
similarity index 92%
rename from src/libqhullrcpp/qt-qhullr.cpp
rename to src/libqhullpcpp/qt-qhull.cpp
index bb91e12..c16948e 100644
--- a/src/libqhullrcpp/qt-qhullr.cpp
+++ b/src/libqhullpcpp/qt-qhull.cpp
@@ -1,129 +1,129 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/libqhullrcpp/qt-qhullr.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/libqhullpcpp/qt-qhull.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include <QList>
 #include "RoadTest.h"
 
 #ifndef QHULL_USES_QT
 #define QHULL_USES_QT 1
 #endif
 
 #include "Coordinates.h"
 #include "QhullFacetList.h"
 #include "QhullFacetSet.h"
 #include "QhullHyperplane.h"
 #include "QhullPoint.h"
 #include "QhullPoints.h"
 #include "QhullPointSet.h"
 #include "QhullVertex.h"
 #include "QhullVertexSet.h"
 
 namespace orgQhull {
 
 #//Conversions
 
 QList<coordT> Coordinates::
 toQList() const
 {
     CoordinatesIterator i(*this);
     QList<coordT> cs;
     while(i.hasNext()){
         cs.append(i.next());
     }
     return cs;
 }//toQList
 
 QList<QhullFacet> QhullFacetList::
 toQList() const
 {
     QhullLinkedListIterator<QhullFacet> i(*this);
     QList<QhullFacet> vs;
     while(i.hasNext()){
         QhullFacet f= i.next();
         if(isSelectAll() || f.isGood()){
             vs.append(f);
         }
     }
     return vs;
 }//toQList
 
 //! Same as PrintVertices
 QList<QhullVertex> QhullFacetList::
 vertices_toQList(int qhRunId) const
 {
     QList<QhullVertex> vs;
     QhullVertexSet qvs(qhRunId, first().getFacetT(), NULL, isSelectAll());
     for(QhullVertexSet::iterator i=qvs.begin(); i!=qvs.end(); ++i){
         vs.push_back(*i);
     }
     return vs;
 }//vertices_toQList
 
 QList<QhullFacet> QhullFacetSet::
 toQList() const
 {
     QhullSetIterator<QhullFacet> i(*this);
     QList<QhullFacet> vs;
     while(i.hasNext()){
         QhullFacet f= i.next();
         if(isSelectAll() || f.isGood()){
             vs.append(f);
         }
     }
     return vs;
 }//toQList
 
 #ifdef QHULL_USES_QT
 QList<coordT> QhullHyperplane::
 toQList() const
 {
     QhullHyperplaneIterator i(*this);
     QList<coordT> fs;
     while(i.hasNext()){
         fs.append(i.next());
     }
     fs.append(hyperplane_offset);
     return fs;
 }//toQList
 #endif //QHULL_USES_QT
 
 QList<coordT> QhullPoint::
 toQList() const
 {
     QhullPointIterator i(*this);
     QList<coordT> vs;
     while(i.hasNext()){
         vs.append(i.next());
     }
     return vs;
 }//toQList
 
 QList<QhullPoint> QhullPoints::
 toQList() const
 {
     QhullPointsIterator i(*this);
     QList<QhullPoint> vs;
     while(i.hasNext()){
         vs.append(i.next());
     }
     return vs;
 }//toQList
 
 QList<QhullPoint> QhullPointSet::
 toQList() const
 {
     QhullPointSetIterator i(*this);
     QList<QhullPoint> vs;
     while(i.hasNext()){
         vs.append(i.next());
     }
     return vs;
 }//toQList
 
 }//orgQhull
 
diff --git a/src/libqhullr/README_r.txt b/src/libqhullr/README_r.txt
index 51b0fc8..af57f24 100644
--- a/src/libqhullr/README_r.txt
+++ b/src/libqhullr/README_r.txt
@@ -1,154 +1,207 @@
 Converting libqhull to libqhullr
 
+==========================
 Todo 
 
+After qmake, need to update HEADER paths for libqhull, libqhullr, libqhullcpp libqhullpcpp
+    Path="..\lib
+    Path="..\..\src\lib
+
+---
+Convert testqset.c to testqset_r.c
+   Try to make qhT and mem_r.c etc. plugable
+
+Convert user_eg,etc and branch old code to user_egp...
+
+At initialization, check for compatible libqhull.  Add a version check to libqhull
+
+p4 delete src/qhull-libqhullr-src.pri
+
+---
 3>..\..\src\qhullr\unix_r.c(39) : warning C4273: '_isatty' : inconsistent dll linkage
 3>        C:\Program Files\Microsoft Visual Studio 8\VC\INCLUDE\io.h(209) : see previous definition of '_isatty'
 
-Redo usage note for qhullr.cpp
-
-Add qhull-libqhull-src.pri to libqhull.pro
-Remove #SOURCE from libqhullr.pro
-   It changes the RelativePath to one fewer
-     From
-     				RelativePath="..\libqhullr\stat_r.h" />
-     To
-     				RelativePath="..\..\libqhullr\stat_r.h" />
 ---
-How is roadTest.h done, it has the right path in vcproj
+Redo usage note for qhullr.cpp
 
 ---
 /*** uncomment here and qhull_a.h
      if string.h does not define memcpy()
 #include <memory.h>
 */
 
 ---
 Run through valgrind
 
 ---
 Fix or "sample code" in user_r.h
 
 and in user_r.c
   qh_call_qhull(qh, void )
     template for calling qhull from inside your program
 
 --
 Try with and without qh_NOmem
 
+--
+Update 
+  README.txt -- the new subprojects
+  CMakeLists.txt
+  
 ==============
 Steps
 
 Build qhullr.sln from qhull_all.sln
   Shadow build isn't working for header files. libbqhull and libqhullr
    RelativePath="..\..\src\libqhull\
   Doesn't create qhullstatic_rd.lib
   Inconsistent dll linkage for _isatty
   
   include only libqhullstaticr and qhullr
   remove libqhull, libqhullp, libqhullr to avoid double searches
   remove all but testqset from testqset
   
 Replace all include files with _r.h
 
 [qhull_all] Remove all spaces before the parens 'qh_... (...)' 
 [qhull_all] Change copyright to 2014
 
 Checked in source
 
 Check for access to .c and .h files
 
 Add qhmemT *qh before all routines
    # Routines with arguments, 3648+498 occurrences
    {qh_[a-zA-Z0-9_]*[^_]\(}{[^)/]}
    \1qhmemT *qh, \2
 
    # Routines with comment args, 15+ occurrences
    {qh_[a-zA-Z0-9_]*[^_]\(}{[/]}
    \1qhmemT *qh \2
    
 Exceptions 104+55 instances
   qhmemT *qh, void
   qhmemT *qh
 
   # times
   SETtruncate_(qhmemT *qh, 
   _(
   
   qhmemT *qh, qhmemT *qh,
   qhmemT *qh,
 
   qhmemT *qh, qhmemT *qh
   qhmemT *qh
 
 In C code
   ^{  *qh_.*}qhmemT *qh
   \1qh
 
   # 602 occurrences, needs repeat  
   ^{ .*}qhmemT *qh
   \1qh
  
   # 3746 occurrences
   {[^a-z]}qh {[a-zA-Z]}
   \1qh->\2
 
 All files, 891 occurrences
   qhmemT \*qh{[^a-zA-Z]}
   qhT *qh\1
 
   qhT *qh *
   qhT *qh, void *
   
   qhmem.
   qh->qhmem.
   
   # 99 occurrences
   qhstat 
   qh->qhstat.
   
 Removed rboxT from rboxlib_r.c
 
 1138 errors and 438 warnings.
 
 Remove dependency on libqhull_r for statT
 Convert FOREACHsetelement_i_ in libqhull_r.h 
 traceN needs qh for qh_fprintf
 add qh to () calls
 
 Down to 600 errors
 
 Thurs at 7:18p after fixing all of the compile errors and removing qh_qhPOINTER
 
 # Debug version of qhullr
+ 59 files changed, 8849 insertions(+), 8900 deletions(-)
 
 ISPY-/local/qhull/bin> rbox 100000 t100 s | qhullr
 
 Convex hull of 100000 points in 3-d:
 
   Number of vertices: 100000
   Number of facets: 199996
 
 Statistics for: rbox 100000 t100 s | qhullr
 
   Number of points processed: 100000
   Number of hyperplanes created: 565761
   Number of distance tests for qhull: 4376829
   CPU seconds to compute hull (after input): 1.688
 
 # Release version 2012.1
 
 ISPY-/local/qhull/bin> rbox 100000 t100 s | qhull
 
 Convex hull of 100000 points in 3-d:
 
   Number of vertices: 100000
   Number of facets: 199996
 
 Statistics for: rbox 100000 t100 s | qhull
 
   Number of points processed: 100000
   Number of hyperplanes created: 565761
   Number of distance tests for qhull: 4376829
   CPU seconds to compute hull (after input):  1
+
+# Release version of rboxr and qhullr
+
+ISPY-/local/qhull/bin> rboxr 100000 t100 s | qhullr
+
+Convex hull of 100000 points in 3-d:
+
+  Number of vertices: 100000
+  Number of facets: 199996
+
+Statistics for: rboxr 100000 t100 s | qhullr
+
+  Number of points processed: 100000
+  Number of hyperplanes created: 565761
+  Number of distance tests for qhull: 4376829
+  CPU seconds to compute hull (after input):  1
+
+-----
+Reorganized projects for cpp. 
+
+Fixed up qhull_p-exports.def.  qhull_r-exports.def has no DATA records.
+
+user_eg3 with libqhullpcpp worked correctly the first time
+
+IISPY-/local/qhull/bin>   user_eg3 rbox "100000 t100 s"  qhull
+rbox 100000 t100 s
+
+Results of qhull
+
+Convex hull of 100000 points in 3-d:
+
+  Number of vertices: 100000
+  Number of facets: 199996
+
+Statistics for: rbox "100000 t100 s" | qhull
+
+  Number of points processed: 100000
+  Number of hyperplanes created: 565761
+  Number of distance tests for qhull: 4376829
+  CPU seconds to compute hull (after input): 1.672
   
\ No newline at end of file
diff --git a/src/libqhullr/libqhullr.pro b/src/libqhullr/libqhullr.pro
index bfce390..e1facd8 100644
--- a/src/libqhullr/libqhullr.pro
+++ b/src/libqhullr/libqhullr.pro
@@ -1,25 +1,25 @@
 # -------------------------------------------------
 # libqhullr.pro -- Qt project for Qhull shared library
 #   Built with qh_QHpointer=1
 # -------------------------------------------------
 
 include(../qhull-warn.pri)
 
 DESTDIR = ../../lib
 DLLDESTDIR = ../../bin
 TEMPLATE = lib
 CONFIG += shared warn_on
 CONFIG -= qt
 
 build_pass:CONFIG(debug, debug|release):{
     TARGET = qhull_rd
     OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release):{
     TARGET = qhull_r
     OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
 win32-msvc* : DEF_FILE += ../../src/libqhullr/qhull-exports_r.def
 
-include(../qhull-libqhullr-src.pri)
+include(../qhull-libqhull-src_r.pri)
diff --git a/src/libqhullr/qhull-exports_r.def b/src/libqhullr/qhull_r-exports.def
similarity index 91%
rename from src/libqhullr/qhull-exports_r.def
rename to src/libqhullr/qhull_r-exports.def
index 8f9cca9..dcdab61 100644
--- a/src/libqhullr/qhull-exports_r.def
+++ b/src/libqhullr/qhull_r-exports.def
@@ -1,412 +1,403 @@
 ; qhull-exports.def -- msvc module-definition file
 ;
 ;   Generated from depends.exe by cut-and-paste of exported symbols by mingw gcc
-;   [mar'11] 399 symbols 
-;   Annotate as DATA qh_qh qh_qhstat qhmem qhull_inuse rbox_inuse
-;   Same as ../libqhullp/qhull_p-exports.def without qh_save_qhull and qh_restore_qhull
+;   [jan'14] 391 symbols 
+;   Same as ../libqhullp/qhull-exports.def without DATA items (reentrant)
 ;
-; $Id: //main/2011/qhull/src/libqhullr/qhull-exports_r.def#1 $$Change: 1640 $
-; $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+; $Id: //main/2011/qhull/src/libqhullr/qhull_r-exports.def#2 $$Change: 1657 $
+; $DateTime: 2014/01/17 18:37:16 $$Author: bbarber $
 ; 
 ; Define qhull_VERSION in CMakeLists.txt, Makefile, qhull-exports.def, qhull_p-exports.def, and qhull-warn.pri
 VERSION 6.3
 EXPORTS
-dfacet
-dvertex
-out1
-out2n
-out3n
 qh_addhash
 qh_addpoint
 qh_all_merges
 qh_allstatA
 qh_allstatB
 qh_allstatC
 qh_allstatD
 qh_allstatE
 qh_allstatE2
 qh_allstatF
 qh_allstatG
 qh_allstatH
 qh_allstatI
 qh_allstatistics
 qh_appendfacet
 qh_appendmergeset
 qh_appendprint
 qh_appendvertex
 qh_argv_to_command
 qh_argv_to_command_size
 qh_attachnewfacets
 qh_backnormal
 qh_basevertices
 qh_build_withrestart
 qh_buildhull
 qh_buildtracing
 qh_check_bestdist
 qh_check_maxout
 qh_check_output
 qh_check_point
 qh_check_points
 qh_checkconnect
 qh_checkconvex
 qh_checkfacet
 qh_checkflags
 qh_checkflipped
 qh_checkflipped_all
 qh_checkpolygon
 qh_checkvertex
 qh_checkzero
 qh_clear_outputflags
 qh_clearcenters
 qh_clock
 qh_collectstatistics
 qh_compare_facetarea
 qh_compare_facetmerge
 qh_compare_facetvisit
 qh_compare_vertexpoint
 qh_compareangle
 qh_comparemerge
 qh_comparevisit
 qh_copyfilename
 qh_copynonconvex
 qh_copypoints
 qh_countfacets
 qh_createsimplex
 qh_crossproduct
 qh_degen_redundant_facet
 qh_degen_redundant_neighbors
 qh_deletevisible
 qh_delfacet
 qh_delridge
 qh_delvertex
 qh_determinant
 qh_detjoggle
 qh_detroundoff
 qh_detsimplex
 qh_detvnorm
 qh_detvridge
 qh_detvridge3
+qh_dfacet
 qh_distnorm
 qh_distplane
 qh_distround
 qh_divzero
+qh_dvertex
 qh_eachvoronoi
 qh_eachvoronoi_all
 qh_errexit
 qh_errexit2
 qh_errexit_rbox
 qh_errprint
 qh_exit
 qh_facet2point
 qh_facet3vertex
 qh_facetarea
 qh_facetarea_simplex
 qh_facetcenter
 qh_facetintersect
 qh_facetvertices
 qh_find_newvertex
 qh_findbest
 qh_findbest_test
 qh_findbestfacet
 qh_findbesthorizon
 qh_findbestlower
 qh_findbestneighbor
 qh_findbestnew
 qh_findfacet_all
 qh_findgood
 qh_findgood_all
 qh_findgooddist
 qh_findhorizon
 qh_flippedmerges
 qh_forcedmerges
 qh_fprintf
 qh_fprintf_rbox
 qh_free
 qh_freebuffers
 qh_freebuild
 qh_freeqhull
 qh_freeqhull2
 qh_freestatistics
 qh_furthestnext
 qh_furthestout
 qh_gausselim
 qh_geomplanes
 qh_getangle
 qh_getarea
 qh_getcenter
 qh_getcentrum
 qh_getdistance
 qh_gethash
 qh_getmergeset
 qh_getmergeset_initial
 qh_gram_schmidt
 qh_hashridge
 qh_hashridge_find
 qh_infiniteloop
 qh_init_A
 qh_init_B
 qh_init_qhull_command
 qh_initbuild
 qh_initflags
 qh_initialhull
 qh_initialvertices
 qh_initqhull_buffers
 qh_initqhull_globals
 qh_initqhull_mem
 qh_initqhull_outputflags
 qh_initqhull_start
 qh_initqhull_start2
 qh_initstatistics
 qh_initthresholds
 qh_inthresholds
 qh_isvertex
 qh_joggleinput
 qh_makenew_nonsimplicial
 qh_makenew_simplicial
 qh_makenewfacet
 qh_makenewfacets
 qh_makenewplanes
 qh_makeridges
 qh_malloc
 qh_mark_dupridges
 qh_markkeep
 qh_markvoronoi
 qh_matchduplicates
 qh_matchneighbor
 qh_matchnewfacets
 qh_matchvertices
 qh_maxabsval
 qh_maxmin
 qh_maxouter
 qh_maxsimplex
 qh_maydropneighbor
 qh_memalloc
 qh_memfree
 qh_memfreeshort
 qh_meminit
 qh_meminitbuffers
 qh_memsetup
 qh_memsize
 qh_memstatistics
 qh_memtotal
 qh_merge_degenredundant
 qh_merge_nonconvex
 qh_mergecycle
 qh_mergecycle_all
 qh_mergecycle_facets
 qh_mergecycle_neighbors
 qh_mergecycle_ridges
 qh_mergecycle_vneighbors
 qh_mergefacet
 qh_mergefacet2d
 qh_mergeneighbors
 qh_mergeridges
 qh_mergesimplex
 qh_mergevertex_del
 qh_mergevertex_neighbors
 qh_mergevertices
 qh_minabsval
 qh_mindiff
 qh_nearcoplanar
 qh_nearvertex
 qh_neighbor_intersections
 qh_new_qhull
 qh_newfacet
 qh_newhashtable
 qh_newridge
 qh_newstats
 qh_newvertex
 qh_newvertices
 qh_nextfurthest
 qh_nextridge3d
 qh_normalize
 qh_normalize2
 qh_nostatistic
 qh_option
 qh_order_vertexneighbors
 qh_orientoutside
+qh_out1
+qh_out2n
+qh_out3n
 qh_outcoplanar
 qh_outerinner
 qh_partitionall
 qh_partitioncoplanar
 qh_partitionpoint
 qh_partitionvisible
 qh_point
 qh_point_add
 qh_pointdist
 qh_pointfacet
 qh_pointid
 qh_pointvertex
 qh_postmerge
 qh_precision
 qh_premerge
 qh_prepare_output
 qh_prependfacet
 qh_printafacet
 qh_printallstatistics
 qh_printbegin
 qh_printcenter
 qh_printcentrum
 qh_printend
 qh_printend4geom
 qh_printextremes
 qh_printextremes_2d
 qh_printextremes_d
 qh_printfacet
 qh_printfacet2geom
 qh_printfacet2geom_points
 qh_printfacet2math
 qh_printfacet3geom_nonsimplicial
 qh_printfacet3geom_points
 qh_printfacet3geom_simplicial
 qh_printfacet3math
 qh_printfacet3vertex
 qh_printfacet4geom_nonsimplicial
 qh_printfacet4geom_simplicial
 qh_printfacetNvertex_nonsimplicial
 qh_printfacetNvertex_simplicial
 qh_printfacetheader
 qh_printfacetlist
 qh_printfacetridges
 qh_printfacets
 qh_printhashtable
 qh_printhelp_degenerate
 qh_printhelp_narrowhull
 qh_printhelp_singular
 qh_printhyperplaneintersection
 qh_printline3geom
 qh_printlists
 qh_printmatrix
 qh_printneighborhood
 qh_printpoint
 qh_printpoint3
 qh_printpointid
 qh_printpoints
 qh_printpoints_out
 qh_printpointvect
 qh_printpointvect2
 qh_printridge
 qh_printspheres
 qh_printstatistics
 qh_printstatlevel
 qh_printstats
 qh_printsummary
 qh_printvdiagram
 qh_printvdiagram2
 qh_printvertex
 qh_printvertexlist
 qh_printvertices
 qh_printvneighbors
 qh_printvnorm
 qh_printvoronoi
 qh_printvridge
 qh_produce_output
 qh_produce_output2
 qh_projectdim3
 qh_projectinput
 qh_projectpoint
 qh_projectpoints
-; Mark as DATA, otherwise links a separate qh_qh.  Requires __dcelspec
-qh_qh               DATA
-qh_qhstat           DATA
 qh_qhull
 qh_rand
 qh_rand_seed
 qh_randomfactor
 qh_randommatrix
 qh_rboxpoints
 qh_readfeasible
 qh_readpoints
 qh_reducevertices
 qh_redundant_vertex
 qh_remove_extravertices
 qh_removefacet
 qh_removevertex
 qh_rename_sharedvertex
 qh_renameridgevertex
 qh_renamevertex
 qh_resetlists
 qh_rotateinput
 qh_rotatepoints
+qh_roundi
 qh_scaleinput
 qh_scalelast
 qh_scalepoints
 qh_setaddnth
 qh_setaddsorted
 qh_setappend
 qh_setappend2ndlast
 qh_setappend_set
 qh_setcheck
 qh_setcompact
 qh_setcopy
 qh_setdel
 qh_setdelaunay
 qh_setdellast
 qh_setdelnth
 qh_setdelnthsorted
 qh_setdelsorted
 qh_setduplicate
 qh_setequal
 qh_setequal_except
 qh_setequal_skip
 qh_setfacetplane
 qh_setfeasible
 qh_setfree
 qh_setfree2
 qh_setfreelong
 qh_sethalfspace
 qh_sethalfspace_all
 qh_sethyperplane_det
 qh_sethyperplane_gauss
 qh_setin
 qh_setindex
 qh_setlarger
 qh_setlast
 qh_setnew
 qh_setnew_delnthsorted
 qh_setprint
 qh_setreplace
 qh_setsize
 qh_settemp
 qh_settempfree
 qh_settempfree_all
 qh_settemppop
 qh_settemppush
 qh_settruncate
 qh_setunique
 qh_setvoronoi_all
 qh_setzero
 qh_sharpnewfacets
 qh_skipfacet
 qh_skipfilename
 qh_srand
 qh_stddev
 qh_strtod
 qh_strtol
 qh_test_appendmerge
 qh_test_vneighbors
 qh_tracemerge
 qh_tracemerging
 qh_triangulate
 qh_triangulate_facet
 qh_triangulate_link
 qh_triangulate_mirror
 qh_triangulate_null
 qh_updatetested
 qh_updatevertices
 qh_user_memsizes
 qh_version
 qh_vertexintersect
 qh_vertexintersect_new
 qh_vertexneighbors
 qh_vertexridges
 qh_vertexridges_facet
 qh_vertexsubset
 qh_voronoi_center
 qh_willdelete
-; Mark as DATA, otherwise links a separate qhmem.  Requires __dcelspec
-qhmem                   DATA
-qhull_inuse             DATA
-rbox
-rbox_inuse              DATA
-roundi
diff --git a/src/libqhullrcpp/libqhullrcpp.pro b/src/libqhullrcpp/libqhullrcpp.pro
deleted file mode 100644
index f91d1cc..0000000
--- a/src/libqhullrcpp/libqhullrcpp.pro
+++ /dev/null
@@ -1,71 +0,0 @@
-# -------------------------------------------------
-# libqhullcpp.pro -- Qt project for Qhull cpp shared library
-# -------------------------------------------------
-
-include(../qhull-warn.pri)
-
-DESTDIR = ../../lib
-TEMPLATE = lib
-CONFIG += staticlib warn_on
-CONFIG -= qt rtti
-build_pass:CONFIG(debug, debug|release):{
-   TARGET = qhullcpp_d
-   OBJECTS_DIR = Debug
-}else:build_pass:CONFIG(release, debug|release):{
-   TARGET = qhullcpp
-   OBJECTS_DIR = Release
-}
-MOC_DIR = moc
-
-DEFINES += qh_QHpointer # libqhull/user.h
-
-INCLUDEPATH += ../../src
-INCLUDEPATH += $$PWD # for MOC_DIR
-
-CONFIG += qhull_warn_shadow qhull_warn_conversion
-
-SOURCES += Coordinates.cpp
-SOURCES += PointCoordinates.cpp
-SOURCES += Qhull.cpp
-SOURCES += QhullFacet.cpp
-SOURCES += QhullFacetList.cpp
-SOURCES += QhullFacetSet.cpp
-SOURCES += QhullHyperplane.cpp
-SOURCES += QhullPoint.cpp
-SOURCES += QhullPoints.cpp
-SOURCES += QhullPointSet.cpp
-SOURCES += QhullQh.cpp
-SOURCES += QhullRidge.cpp
-SOURCES += QhullSet.cpp
-SOURCES += QhullStat.cpp
-SOURCES += QhullVertex.cpp
-SOURCES += QhullVertexSet.cpp
-SOURCES += RboxPoints.cpp
-SOURCES += RoadError.cpp
-SOURCES += RoadLogEvent.cpp
-SOURCES += UsingLibQhull.cpp
-
-HEADERS += Coordinates.h
-HEADERS += functionObjects.h
-HEADERS += PointCoordinates.h
-HEADERS += Qhull.h
-HEADERS += QhullError.h
-HEADERS += QhullFacet.h
-HEADERS += QhullFacetList.h
-HEADERS += QhullFacetSet.h
-HEADERS += QhullHyperplane.h
-HEADERS += QhullIterator.h
-HEADERS += QhullLinkedList.h
-HEADERS += QhullPoint.h
-HEADERS += QhullPoints.h
-HEADERS += QhullPointSet.h
-HEADERS += QhullQh.h
-HEADERS += QhullRidge.h
-HEADERS += QhullSet.h
-HEADERS += QhullSets.h
-HEADERS += QhullStat.h
-HEADERS += QhullVertex.h
-HEADERS += RboxPoints.h
-HEADERS += RoadError.h
-HEADERS += RoadLogEvent.h
-HEADERS += UsingLibQhull.h
diff --git a/src/libqhullstaticr/libqhullstaticr.pro b/src/libqhullstaticr/libqhullstaticr.pro
index e9bc889..2430e2d 100644
--- a/src/libqhullstaticr/libqhullstaticr.pro
+++ b/src/libqhullstaticr/libqhullstaticr.pro
@@ -1,19 +1,20 @@
 # -------------------------------------------------
 # libqhullstaticr.pro -- Qt project for Qhull static library
 #    Reentrant code
 # -------------------------------------------------
 
 include(../qhull-warn.pri)
-include(../qhull-libqhullr-src.pri)
 
 DESTDIR = ../../lib
 TEMPLATE = lib
 CONFIG += staticlib warn_on
 CONFIG -= qt
 build_pass:CONFIG(debug, debug|release):{
     TARGET = qhullstatic_rd
     OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release):{
-    TARGET = qhullstatic_rd
+    TARGET = qhullstatic_r
     OBJECTS_DIR = Release
 }
+
+include(../qhull-libqhull-src_r.pri)
diff --git a/src/qhull-all.pro b/src/qhull-all.pro
index c75ac6e..2993253 100644
--- a/src/qhull-all.pro
+++ b/src/qhull-all.pro
@@ -1,80 +1,89 @@
 # -------------------------------------------------
 # qhull-all.pro -- Qt project to build executables and static libraries
 #
 # To build with Qt on mingw
 #   Download Qt SDK, install Perl
 #   /c/qt/2010.05/qt> ./configure -static -platform win32-g++ -fast -no-qt3support
 #
 # To build DevStudio sln and proj files (Qhull ships with cmake derived files)
 # qmake is in Qt's bin directory
 # ../build> qmake -tp vc -r ../src/qhull-all.pro
 # Need to add Build Dependencies, disable rtti, rename targets to qhull.dll, qhull6_p.dll and qhull6_pd.dll
 # -------------------------------------------------
 
 TEMPLATE = subdirs
 CONFIG += ordered
 
 SUBDIRS += libqhull        #shared library
 SUBDIRS += libqhullp       #shared library with qh_QHpointer (libqhull/user.h)
 SUBDIRS += libqhullr       #shared library for reentrant code
 SUBDIRS += user_eg         #user program linked to libqhull6_p (libqhullp)
 
 SUBDIRS += libqhullstatic  #static library
 SUBDIRS += libqhullstaticp #static library with qh_QHpointer
 SUBDIRS += libqhullstaticr #static library with reentrant code
 SUBDIRS += qhull           #qhull programs linked to libqhullstatic
 SUBDIRS += qconvex
 SUBDIRS += qdelaunay
 SUBDIRS += qhalf
 SUBDIRS += qvoronoi
 SUBDIRS += rbox
-SUBDIRS += qhullr          #qhull program linked to libqhullstatic_r (for testing)
-SUBDIRS += rboxr	   #rbox program linked to libqhullstatic_r (for testing)
+SUBDIRS += qhullr          #qhull program linked to libqhullstatic_r
+SUBDIRS += rboxr	   #rbox program linked to libqhullstatic_r
 SUBDIRS += user_eg2        #user program linked to libqhull
 SUBDIRS += testqset        #test program for qset.c with mem.c
 
 SUBDIRS += libqhullcpp     #static library for C++ interface with libqhullstaticp
 SUBDIRS += user_eg3        #user program with libqhullcpp and libqhullstaticp
 SUBDIRS += qhulltest       #test program with Qt, libqhullcpp, and libqhullstaticp
+SUBDIRS += libqhullpcpp     #static library for C++ interface with libqhullstaticp
+SUBDIRS += qhullptest       #test program with Qt, libqhullcpp, and libqhullstaticp
 
 OTHER_FILES += Changes.txt
 OTHER_FILES += CMakeLists.txt
 OTHER_FILES += Make-config.sh
 OTHER_FILES += ../Announce.txt
 OTHER_FILES += ../CMakeLists.txt
 OTHER_FILES += ../COPYING.txt
 OTHER_FILES += ../File_id.diz
 OTHER_FILES += ../index.htm
 OTHER_FILES += ../Makefile
 OTHER_FILES += ../README.txt
 OTHER_FILES += ../REGISTER.txt
 OTHER_FILES += ../eg/q_eg
 OTHER_FILES += ../eg/q_egtest
 OTHER_FILES += ../eg/q_test
 OTHER_FILES += ../html/index.htm
 OTHER_FILES += ../html/qconvex.htm
 OTHER_FILES += ../html/qdelau_f.htm
 OTHER_FILES += ../html/qdelaun.htm
 OTHER_FILES += ../html/qhalf.htm
 OTHER_FILES += ../html/qh-code.htm
 OTHER_FILES += ../html/qh-eg.htm
 OTHER_FILES += ../html/qh-faq.htm
 OTHER_FILES += ../html/qh-get.htm
 OTHER_FILES += ../html/qh-impre.htm
 OTHER_FILES += ../html/qh-optc.htm
 OTHER_FILES += ../html/qh-optf.htm
 OTHER_FILES += ../html/qh-optg.htm
 OTHER_FILES += ../html/qh-opto.htm
 OTHER_FILES += ../html/qh-optp.htm
 OTHER_FILES += ../html/qh-optq.htm
 OTHER_FILES += ../html/qh-optt.htm
 OTHER_FILES += ../html/qh-quick.htm
 OTHER_FILES += ../html/qhull.htm
 OTHER_FILES += ../html/qhull.man
 OTHER_FILES += ../html/qhull.txt
 OTHER_FILES += ../html/qhull-cpp.xml
 OTHER_FILES += ../html/qvoron_f.htm
 OTHER_FILES += ../html/qvoronoi.htm
 OTHER_FILES += ../html/rbox.htm
 OTHER_FILES += ../html/rbox.man
 OTHER_FILES += ../html/rbox.txt
+OTHER_FILES += ../libqhull/DEPRECATED.txt
+OTHER_FILES += ../libqhullp/DEPRECATED.txt
+OTHER_FILES += ../libqhullpcpp/DEPRECATED.txt
+OTHER_FILES += ../qhullptest/DEPRECATED.txt
+OTHER_FILES += ../libqhull/qhull-exports.def
+OTHER_FILES += ../libqhullp/qhull_p-exports.def
+OTHER_FILES += ../libqhullr/qhull_r-exports.def
diff --git a/src/qhullr/qhullr.pro b/src/qhull-app-c_r.pri
similarity index 80%
copy from src/qhullr/qhullr.pro
copy to src/qhull-app-c_r.pri
index 74af2ab..cd861f3 100644
--- a/src/qhullr/qhullr.pro
+++ b/src/qhull-app-c_r.pri
@@ -1,28 +1,24 @@
 # -------------------------------------------------
-# qhullr.pro -- Qt project file for qhullr.exe
+# qhull-app-c_r.pri -- Qt include project for reentrant C qhull applications linked to qhullstatic_r
 # -------------------------------------------------
 
-TARGET = qhullr
-
-include(../qhull-warn.pri)
+include(qhull-warn.pri)
 
 DESTDIR = ../../bin
 TEMPLATE = app
 CONFIG += console warn_on
 CONFIG -= qt
 
 LIBS += -L../../lib
 build_pass:CONFIG(debug, debug|release){
    LIBS += -lqhullstatic_rd
    OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release){
    LIBS += -lqhullstatic_r
    OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
 INCLUDEPATH += ../libqhullr
 CONFIG += qhull_warn_conversion
 
-
-SOURCES += unix_r.c
diff --git a/src/qhull-app-cpp.pri b/src/qhull-app-cpp.pri
index 953cba4..d6fc162 100644
--- a/src/qhull-app-cpp.pri
+++ b/src/qhull-app-cpp.pri
@@ -1,26 +1,24 @@
 # -------------------------------------------------
-# qhull-app-cpp.pri -- Qt include project for static CPP qhull applications using Qt
+# qhull-app-cpp.pri -- Qt include project for qhull as C++ classes
 # -------------------------------------------------
 
 include(qhull-warn.pri)
 
 DESTDIR = ../../bin
 TEMPLATE = app
 CONFIG += console warn_on
 CONFIG -= rtti
 LIBS += -L../../lib
 build_pass:CONFIG(debug, debug|release){
    LIBS += -lqhullcpp_d
    LIBS += -lqhullstatic_pd  # Must be last, otherwise qh_fprintf,etc. are loaded from here instead of qhullcpp-d.lib
    OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release){
    LIBS += -lqhullcpp
    LIBS += -lqhullstatic_p  # Must be last, otherwise qh_fprintf,etc. are loaded from here instead of qhullcpp.lib
    OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
-DEFINES += qh_QHpointer # libqhull/user.h
-
 INCLUDEPATH += ../libqhullcpp
-INCLUDEPATH += ../../src # "libqhull/qhull_a.h"
+INCLUDEPATH += ../../src # "libqhullr/qhull_a.h"
diff --git a/src/qhull-app-cpp.pri b/src/qhull-app-cpp_p.pri
similarity index 81%
copy from src/qhull-app-cpp.pri
copy to src/qhull-app-cpp_p.pri
index 953cba4..03a92e4 100644
--- a/src/qhull-app-cpp.pri
+++ b/src/qhull-app-cpp_p.pri
@@ -1,26 +1,26 @@
 # -------------------------------------------------
-# qhull-app-cpp.pri -- Qt include project for static CPP qhull applications using Qt
+# qhull-app-cpp_p.pri -- Deprecated Qt include project for qhull as C++ with qh_QHpointer
 # -------------------------------------------------
 
 include(qhull-warn.pri)
 
 DESTDIR = ../../bin
 TEMPLATE = app
 CONFIG += console warn_on
 CONFIG -= rtti
 LIBS += -L../../lib
 build_pass:CONFIG(debug, debug|release){
-   LIBS += -lqhullcpp_d
+   LIBS += -lqhullcpp_pd
    LIBS += -lqhullstatic_pd  # Must be last, otherwise qh_fprintf,etc. are loaded from here instead of qhullcpp-d.lib
    OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release){
-   LIBS += -lqhullcpp
+   LIBS += -lqhullcpp_p
    LIBS += -lqhullstatic_p  # Must be last, otherwise qh_fprintf,etc. are loaded from here instead of qhullcpp.lib
    OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
 DEFINES += qh_QHpointer # libqhull/user.h
 
-INCLUDEPATH += ../libqhullcpp
+INCLUDEPATH += ../libqhullpcpp
 INCLUDEPATH += ../../src # "libqhull/qhull_a.h"
diff --git a/src/qhull-app-shared.pri b/src/qhull-app-shared.pri
index 0c8a191..1f4026a 100644
--- a/src/qhull-app-shared.pri
+++ b/src/qhull-app-shared.pri
@@ -1,27 +1,27 @@
 # -------------------------------------------------
-# qhull-app-shared.pri -- Qt include project for C qhull applications linked with libqhull (shared library)
+# qhull-app-shared.pri -- Deprecated Qt include project for C qhull applications linked with libqhull (shared library)
 # -------------------------------------------------
 
 include(qhull-warn.pri)
 
 DESTDIR = ../../bin
 TEMPLATE = app
 CONFIG += console warn_on
 CONFIG -= qt
 
 LIBS += -L../../lib
 build_pass:CONFIG(debug, debug|release){
    LIBS += -lqhull_d
    OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release){
    LIBS += -lqhull
    OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
 win32-msvc* : DEFINES += qh_dllimport # libqhull/user.h
 
 INCLUDEPATH += ../libqhull
 CONFIG += qhull_warn_conversion
 
 
diff --git a/src/qhullr/qhullr.pro b/src/qhull-app-shared_r.pri
similarity index 64%
copy from src/qhullr/qhullr.pro
copy to src/qhull-app-shared_r.pri
index 74af2ab..60ad2e8 100644
--- a/src/qhullr/qhullr.pro
+++ b/src/qhull-app-shared_r.pri
@@ -1,28 +1,27 @@
 # -------------------------------------------------
-# qhullr.pro -- Qt project file for qhullr.exe
+# qhull-app-shared_r.pri -- Qt include project for reentrant C qhull applications linked with libqhull (shared library)
 # -------------------------------------------------
 
-TARGET = qhullr
-
-include(../qhull-warn.pri)
+include(qhull-warn.pri)
 
 DESTDIR = ../../bin
 TEMPLATE = app
 CONFIG += console warn_on
 CONFIG -= qt
 
 LIBS += -L../../lib
 build_pass:CONFIG(debug, debug|release){
-   LIBS += -lqhullstatic_rd
+   LIBS += -lqhull_rd
    OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release){
-   LIBS += -lqhullstatic_r
+   LIBS += -lqhull_r
    OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
+win32-msvc* : DEFINES += qh_dllimport # libqhullr/user.h
+
 INCLUDEPATH += ../libqhullr
 CONFIG += qhull_warn_conversion
 
 
-SOURCES += unix_r.c
diff --git a/src/qhull-app-sharedp.pri b/src/qhull-app-sharedp.pri
index 3d0bbac..d640d0f 100644
--- a/src/qhull-app-sharedp.pri
+++ b/src/qhull-app-sharedp.pri
@@ -1,29 +1,29 @@
 # -------------------------------------------------
-# qhull-app-sharedp.pri -- Qt include project for C qhull applications linked with libqhull6_p 
+# qhull-app-sharedp.pri -- Deprecated Qt include project for C qhull applications linked with libqhull6_p 
 #   Compile code with -Dqh_QHpointer 
 # -------------------------------------------------
 
 include(qhull-warn.pri)
 
 DESTDIR = ../../bin
 TEMPLATE = app
 CONFIG += console warn_on
 CONFIG -= qt
 
 LIBS += -L../../lib
 build_pass:CONFIG(debug, debug|release){
    LIBS += -lqhull_pd
    OBJECTS_DIR = Debug
 }else:build_pass:CONFIG(release, debug|release){
    LIBS += -lqhull_p
    OBJECTS_DIR = Release
 }
 win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
 
 DEFINES += qh_QHpointer # libqhull/user.h
 win32-msvc* : DEFINES += qh_QHpointer_dllimport # libqhull/user.h
 
 INCLUDEPATH += ../libqhull
 CONFIG += qhull_warn_conversion
 
 
diff --git a/src/qhull-libqhull-src_r.pri b/src/qhull-libqhull-src_r.pri
new file mode 100644
index 0000000..110fb8e
--- /dev/null
+++ b/src/qhull-libqhull-src_r.pri
@@ -0,0 +1,35 @@
+# -------------------------------------------------
+# qhull-libqhull-src_r.pri -- Qt include project for reentrant libqhullr sources and headers
+# -------------------------------------------------
+
+# Order object files by frequency of execution.  Small files at end.
+# Current directory is caller
+SOURCES += ../libqhullr/global_r.c
+SOURCES += ../libqhullr/stat_r.c
+SOURCES += ../libqhullr/geom2_r.c
+SOURCES += ../libqhullr/poly2_r.c
+SOURCES += ../libqhullr/merge_r.c
+SOURCES += ../libqhullr/libqhull_r.c
+SOURCES += ../libqhullr/geom_r.c
+SOURCES += ../libqhullr/poly_r.c
+SOURCES += ../libqhullr/qset_r.c
+SOURCES += ../libqhullr/mem_r.c
+SOURCES += ../libqhullr/random_r.c
+SOURCES += ../libqhullr/usermem_r.c
+SOURCES += ../libqhullr/userprintf_r.c
+SOURCES += ../libqhullr/io_r.c
+SOURCES += ../libqhullr/user_r.c
+SOURCES += ../libqhullr/rboxlib_r.c
+SOURCES += ../libqhullr/userprintf_rbox_r.c
+
+HEADERS += ../libqhullr/geom_r.h
+HEADERS += ../libqhullr/io_r.h
+HEADERS += ../libqhullr/libqhull_r.h
+HEADERS += ../libqhullr/mem_r.h
+HEADERS += ../libqhullr/merge_r.h
+HEADERS += ../libqhullr/poly_r.h
+HEADERS += ../libqhullr/random_r.h
+HEADERS += ../libqhullr/qhull_ra.h
+HEADERS += ../libqhullr/qset_r.h
+HEADERS += ../libqhullr/stat_r.h
+HEADERS += ../libqhullr/user_r.h
diff --git a/src/qhullrtest/Coordinates_test.cpp b/src/qhullptest/Coordinates_test.cpp
similarity index 98%
rename from src/qhullrtest/Coordinates_test.cpp
rename to src/qhullptest/Coordinates_test.cpp
index 54717c9..bdc3589 100644
--- a/src/qhullrtest/Coordinates_test.cpp
+++ b/src/qhullptest/Coordinates_test.cpp
@@ -1,534 +1,534 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/Coordinates_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/Coordinates_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h" // QT_VERSION
 
 #include "Coordinates.h"
 #include "QhullError.h"
 #include "RboxPoints.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class Coordinates_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void t_construct();
     void t_convert();
     void t_element();
     void t_readonly();
     void t_operator();
     void t_const_iterator();
     void t_iterator();
     void t_coord_iterator();
     void t_mutable_coord_iterator();
     void t_readwrite();
     void t_search();
     void t_io();
 };//Coordinates_test
 
 void
 add_Coordinates_test()
 {
     new Coordinates_test();
 }
 
 void Coordinates_test::
 t_construct()
 {
     Coordinates c;
     QCOMPARE(c.size(), 0U);
     QVERIFY(c.isEmpty());
     c << 1.0;
     QCOMPARE(c.count(), 1);
     Coordinates c2(c);
     c2 << 2.0;
     QCOMPARE(c2.count(), 2);
     Coordinates c3;
     c3 = c2;
     QCOMPARE(c3.count(), 2);
     QCOMPARE(c3[0]+c3[1], 3.0);
     QVERIFY(c2==c3);
     std::vector<coordT> vc;
     vc.push_back(3.0);
     vc.push_back(4.0);
     Coordinates c4(vc);
     QCOMPARE(c4[0]+c4[1], 7.0);
     Coordinates c5(c3);
     QVERIFY(c5==c3);
     c5= vc;
     QVERIFY(c5!=c3);
     QVERIFY(c5==c4);
 }//t_construct
 
 void Coordinates_test::
 t_convert()
 {
     Coordinates c;
     c << 1.0 << 3.0;
     QCOMPARE(c.data()[1], 3.0);
     coordT *c2= c.data();
     const coordT *c3= c.data();
     QCOMPARE(c2, c3);
     std::vector<coordT> vc= c.toStdVector();
     QCOMPARE(vc.size(), c.size());
     for(size_t k= vc.size(); k--; ){
         QCOMPARE(vc[k], c[k]);
     }
     QList<coordT> qc= c.toQList();
     QCOMPARE(qc.count(), c.count());
     for(int k= qc.count(); k--; ){
         QCOMPARE(qc[k], c[k]);
     }
     Coordinates c4;
     c4= std::vector<double>(2, 0.0);
     QCOMPARE(c4.back(), 0.0);
     Coordinates c5(std::vector<double>(2, 0.0));
     QCOMPARE(c4.size(), c5.size());
     QVERIFY(c4==c5);
 }//t_convert
 
 void Coordinates_test::
 t_element()
 {
     Coordinates c;
     c << 1.0 << -2.0;
     c.at(1)= -3;
     QCOMPARE(c.at(1), -3.0);
     QCOMPARE(c.back(), -3.0);
     QCOMPARE(c.front(), 1.0);
     c[1]= -2.0;
     QCOMPARE(c[1],-2.0);
     QCOMPARE(c.first(), 1.0);
     c.first()= 2.0;
     QCOMPARE(c.first(), 2.0);
     QCOMPARE(c.last(), -2.0);
     c.last()= 0.0;
     QCOMPARE(c.first()+c.last(), 2.0);
     coordT *c4= &c.first();
     const coordT *c5= &c.first();
     QCOMPARE(c4, c5);
     coordT *c6= &c.last();
     const coordT *c7= &c.last();
     QCOMPARE(c6, c7);
     Coordinates c2= c.mid(1);
     QCOMPARE(c2.count(), 1);
     c << 3.0;
     Coordinates c3= c.mid(1,1);
     QCOMPARE(c2, c3);
     QCOMPARE(c3.value(-1, -1.0), -1.0);
     QCOMPARE(c3.value(3, 4.0), 4.0);
     QCOMPARE(c.value(2, 4.0), 3.0);
 }//t_element
 
 void Coordinates_test::
 t_readonly()
 {
     Coordinates c;
     QCOMPARE(c.size(), 0u);
     QCOMPARE(c.count(), 0);
     QVERIFY(c.empty());
     QVERIFY(c.isEmpty());
     c << 1.0 << -2.0;
     QCOMPARE(c.size(), 2u);
     QCOMPARE(c.count(), 2);
     QVERIFY(!c.empty());
     QVERIFY(!c.isEmpty());
 }//t_readonly
 
 void Coordinates_test::
 t_operator()
 {
     Coordinates c;
     Coordinates c2(c);
     QVERIFY(c==c2);
     QVERIFY(!(c!=c2));
     c << 1.0;
     QVERIFY(!(c==c2));
     QVERIFY(c!=c2);
     c2 << 1.0;
     QVERIFY(c==c2);
     QVERIFY(!(c!=c2));
     c[0]= 0.0;
     QVERIFY(c!=c2);
     Coordinates c3= c+c2;
     QCOMPARE(c3.count(), 2);
     QCOMPARE(c3[0], 0.0);
     QCOMPARE(c3[1], 1.0);
     c3 += c3;
     QCOMPARE(c3.count(), 4);
     QCOMPARE(c3[2], 0.0);
     QCOMPARE(c3[3], 1.0);
     c3 += c2;
     QCOMPARE(c3[4], 1.0);
     c3 += 5.0;
     QCOMPARE(c3.count(), 6);
     QCOMPARE(c3[5], 5.0);
     // << checked above
 }//t_operator
 
 void Coordinates_test::
 t_const_iterator()
 {
     Coordinates c;
     QCOMPARE(c.begin(), c.end());
     // begin and end checked elsewhere
     c << 1.0 << 3.0;
     Coordinates::const_iterator i= c.begin();
     QCOMPARE(*i, 1.0);
     QCOMPARE(i[1], 3.0);
     // i[1]= -3.0; // compiler error
     // operator-> is not applicable to double
     QCOMPARE(*i++, 1.0);
     QCOMPARE(*i, 3.0);
     QCOMPARE(*i--, 3.0);
     QCOMPARE(*i, 1.0);
     QCOMPARE(*(i+1), 3.0);
     QCOMPARE(*++i, 3.0);
     QCOMPARE(*(i-1), 1.0);
     QCOMPARE(*--i, 1.0);
     QVERIFY(i==c.begin());
     QVERIFY(i==c.constBegin());
     QVERIFY(i!=c.end());
     QVERIFY(i!=c.constEnd());
     QVERIFY(i<c.end());
     QVERIFY(i>=c.begin());
     QVERIFY(i+1<=c.end());
     QVERIFY(i+1>c.begin());
     Coordinates::iterator i2= c.begin();
     Coordinates::const_iterator i3(i2);
     QCOMPARE(*i3, 1.0);
     QCOMPARE(i3[1], 3.0);
 }//t_const_iterator
 
 void Coordinates_test::
 t_iterator()
 {
     Coordinates c;
     QCOMPARE(c.begin(), c.end());
     // begin and end checked elsewhere
     c << 1.0 << 3.0;
     Coordinates::iterator i= c.begin();
     QCOMPARE(*i, 1.0);
     QCOMPARE(i[1], 3.0);
     *i= -1.0;
     QCOMPARE(*i, -1.0);
     i[1]= -3.0;
     QCOMPARE(i[1], -3.0);
     *i= 1.0;
     // operator-> is not applicable to double
     QCOMPARE(*i++, 1.0);
     QCOMPARE(*i, -3.0);
     *i= 3.0;
     QCOMPARE(*i--, 3.0);
     QCOMPARE(*i, 1.0);
     QCOMPARE(*(i+1), 3.0);
     QCOMPARE(*++i, 3.0);
     QCOMPARE(*(i-1), 1.0);
     QCOMPARE(*--i, 1.0);
     QVERIFY(i==c.begin());
     QVERIFY(i==c.constBegin());
     QVERIFY(i!=c.end());
     QVERIFY(i!=c.constEnd());
     QVERIFY(i<c.end());
     QVERIFY(i>=c.begin());
     QVERIFY(i+1<=c.end());
     QVERIFY(i+1>c.begin());
 }//t_iterator
 
 void Coordinates_test::
 t_coord_iterator()
 {
     Coordinates c;
     c << 1.0 << 3.0;
     CoordinatesIterator i(c);
     CoordinatesIterator i2= c;
     QVERIFY(i.findNext(1.0));
     QVERIFY(!i.findNext(2.0));
     QVERIFY(!i.findNext(3.0));
     QVERIFY(i.findPrevious(3.0));
     QVERIFY(!i.findPrevious(2.0));
     QVERIFY(!i.findPrevious(1.0));
     QVERIFY(i2.findNext(3.0));
     QVERIFY(i2.findPrevious(3.0));
     QVERIFY(i2.findNext(3.0));
     QVERIFY(i2.findPrevious(1.0));
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     i2.toFront();
     QVERIFY(!i.hasNext());
     QVERIFY(i.hasPrevious());
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     Coordinates c2;
     i2= c2;
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     i2.toBack();
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekPrevious(), 3.0);
     QCOMPARE(i.previous(), 3.0);
     QCOMPARE(i.previous(), 1.0);
     QVERIFY(!i.hasPrevious());
     QCOMPARE(i.peekNext(), 1.0);
     // i.peekNext()= 1.0; // compiler error
     QCOMPARE(i.next(), 1.0);
     QCOMPARE(i.peekNext(), 3.0);
     QCOMPARE(i.next(), 3.0);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), 1.0);
 }//t_coord_iterator
 
 void Coordinates_test::
 t_mutable_coord_iterator()
 {
     // Same tests as CoordinatesIterator
     Coordinates c;
     c << 1.0 << 3.0;
     MutableCoordinatesIterator i(c);
     MutableCoordinatesIterator i2= c;
     QVERIFY(i.findNext(1.0));
     QVERIFY(!i.findNext(2.0));
     QVERIFY(!i.findNext(3.0));
     QVERIFY(i.findPrevious(3.0));
     QVERIFY(!i.findPrevious(2.0));
     QVERIFY(!i.findPrevious(1.0));
     QVERIFY(i2.findNext(3.0));
     QVERIFY(i2.findPrevious(3.0));
     QVERIFY(i2.findNext(3.0));
     QVERIFY(i2.findPrevious(1.0));
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     i2.toFront();
     QVERIFY(!i.hasNext());
     QVERIFY(i.hasPrevious());
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     Coordinates c2;
     i2= c2;
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     i2.toBack();
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekPrevious(), 3.0);
     QCOMPARE(i.peekPrevious(), 3.0);
     QCOMPARE(i.previous(), 3.0);
     QCOMPARE(i.previous(), 1.0);
     QVERIFY(!i.hasPrevious());
     QCOMPARE(i.peekNext(), 1.0);
     QCOMPARE(i.next(), 1.0);
     QCOMPARE(i.peekNext(), 3.0);
     QCOMPARE(i.next(), 3.0);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), 1.0);
 
     // Mutable tests
     i.toFront();
     i.peekNext()= -1.0;
     QCOMPARE(i.peekNext(), -1.0);
     QCOMPARE((i.next()= 1.0), 1.0);
     QCOMPARE(i.peekPrevious(), 1.0);
     i.remove();
     QCOMPARE(c.count(), 1);
     i.remove();
     QCOMPARE(c.count(), 1);
     QCOMPARE(i.peekNext(), 3.0);
     i.insert(1.0);
     i.insert(2.0);
     QCOMPARE(c.count(), 3);
     QCOMPARE(i.peekNext(), 3.0);
     QCOMPARE(i.peekPrevious(), 2.0);
     i.peekPrevious()= -2.0;
     QCOMPARE(i.peekPrevious(), -2.0);
     QCOMPARE((i.previous()= 2.0), 2.0);
     QCOMPARE(i.peekNext(), 2.0);
     i.toBack();
     i.remove();
     QCOMPARE(c.count(), 3); // unchanged
     i.toFront();
     i.remove();
     QCOMPARE(c.count(), 3); // unchanged
     QCOMPARE(i.peekNext(), 1.0);
     i.remove();
     QCOMPARE(c.count(), 3); // unchanged
     i.insert(0.0);
     QCOMPARE(c.count(), 4);
     QCOMPARE(i.value(), 0.0);
     QCOMPARE(i.peekPrevious(), 0.0);
     i.setValue(-10.0);
     QCOMPARE(c.count(), 4); // unchanged
     QCOMPARE(i.peekNext(), 1.0);
     QCOMPARE(i.peekPrevious(), -10.0);
     i.findNext(1.0);
     i.setValue(-1.0);
     QCOMPARE(i.peekPrevious(), -1.0);
     i.setValue(1.0);
     QCOMPARE(i.peekPrevious(), 1.0);
     QCOMPARE(i.value(), 1.0);
     i.findPrevious(1.0);
     i.setValue(-1.0);
     QCOMPARE(i.peekNext(), -1.0);
     i.toBack();
     QCOMPARE(i.previous(), 3.0);
     i.setValue(-3.0);
     QCOMPARE(i.peekNext(), -3.0);
     double d= i.value();
     QCOMPARE(d, -3.0);
     QCOMPARE(i.previous(), 2.0);
 }//t_mutable_coord_iterator
 
 void Coordinates_test::
 t_readwrite()
 {
     Coordinates c;
     c.clear();
     QCOMPARE(c.count(), 0);
     c << 1.0 << 3.0;
     c.clear();
     QCOMPARE(c.count(), 0);
     c << 1.0 << 3.0;
     c.erase(c.begin(), c.end());
     QCOMPARE(c.count(), 0);
     c << 1.0 << 0.0;
     Coordinates::iterator i= c.erase(c.begin());
     QCOMPARE(*i, 0.0);
     i= c.insert(c.end(), 1.0);
     QCOMPARE(*i, 1.0);
     QCOMPARE(c.count(), 2);
     c.pop_back();
     QCOMPARE(c.count(), 1);   // 0
     QCOMPARE(c[0], 0.0);
     c.push_back(2.0);
     QCOMPARE(c.count(), 2);
     c.append(3.0);
     QCOMPARE(c.count(), 3);   // 0, 2, 3
     QCOMPARE(c[2], 3.0);
     c.insert(0, 4.0);
     QCOMPARE(c[0], 4.0);
     QCOMPARE(c[3], 3.0);
     c.insert(c.count(), 5.0);
     QCOMPARE(c.count(), 5);   // 4, 0, 2, 3, 5
     QCOMPARE(c[4], 5.0);
     c.move(4, 0);
     QCOMPARE(c.count(), 5);   // 5, 4, 0, 2, 3
     QCOMPARE(c[0], 5.0);
     c.pop_front();
     QCOMPARE(c.count(), 4);
     QCOMPARE(c[0], 4.0);
     c.prepend(6.0);
     QCOMPARE(c.count(), 5);   // 6, 4, 0, 2, 3
     QCOMPARE(c[0], 6.0);
     c.push_front(7.0);
     QCOMPARE(c.count(), 6);
     QCOMPARE(c[0], 7.0);
     c.removeAt(1);
     QCOMPARE(c.count(), 5);   // 7, 4, 0, 2, 3
     QCOMPARE(c[1], 4.0);
     c.removeFirst();
     QCOMPARE(c.count(), 4);   // 4, 0, 2, 3
     QCOMPARE(c[0], 4.0);
     c.removeLast();
     QCOMPARE(c.count(), 3);
     QCOMPARE(c.last(), 2.0);
     c.replace(2, 8.0);
     QCOMPARE(c.count(), 3);   // 4, 0, 8
     QCOMPARE(c[2], 8.0);
     c.swap(0, 2);
     QCOMPARE(c[2], 4.0);
     double d= c.takeAt(2);
     QCOMPARE(c.count(), 2);   // 8, 0
     QCOMPARE(d, 4.0);
     double d2= c.takeFirst();
     QCOMPARE(c.count(), 1);   // 0
     QCOMPARE(d2, 8.0);
     double d3= c.takeLast();
     QVERIFY(c.isEmpty()); \
     QCOMPARE(d3, 0.0);
 }//t_readwrite
 
 void Coordinates_test::
 t_search()
 {
     Coordinates c;
     c << 1.0 << 3.0 << 1.0;
     QVERIFY(c.contains(1.0));
     QVERIFY(c.contains(3.0));
     QVERIFY(!c.contains(0.0));
     QCOMPARE(c.count(1.0), 2);
     QCOMPARE(c.count(3.0), 1);
     QCOMPARE(c.count(0.0), 0);
     QCOMPARE(c.indexOf(1.0), 0);
     QCOMPARE(c.indexOf(3.0), 1);
     QCOMPARE(c.indexOf(1.0, -1), 2);
     QCOMPARE(c.indexOf(3.0, -1), -1);
     QCOMPARE(c.indexOf(3.0, -2), 1);
     QCOMPARE(c.indexOf(1.0, -3), 0);
     QCOMPARE(c.indexOf(1.0, -4), 0);
     QCOMPARE(c.indexOf(1.0, 1), 2);
     QCOMPARE(c.indexOf(3.0, 2), -1);
     QCOMPARE(c.indexOf(1.0, 2), 2);
     QCOMPARE(c.indexOf(1.0, 3), -1);
     QCOMPARE(c.indexOf(1.0, 4), -1);
     QCOMPARE(c.lastIndexOf(1.0), 2);
     QCOMPARE(c.lastIndexOf(3.0), 1);
     QCOMPARE(c.lastIndexOf(1.0, -1), 2);
     QCOMPARE(c.lastIndexOf(3.0, -1), 1);
     QCOMPARE(c.lastIndexOf(3.0, -2), 1);
     QCOMPARE(c.lastIndexOf(1.0, -3), 0);
     QCOMPARE(c.lastIndexOf(1.0, -4), -1);
     QCOMPARE(c.lastIndexOf(1.0, 1), 0);
     QCOMPARE(c.lastIndexOf(3.0, 2), 1);
     QCOMPARE(c.lastIndexOf(1.0, 2), 2);
     QCOMPARE(c.lastIndexOf(1.0, 3), 2);
     QCOMPARE(c.lastIndexOf(1.0, 4), 2);
     c.removeAll(3.0);
     QCOMPARE(c.count(), 2);
     c.removeAll(4.0);
     QCOMPARE(c.count(), 2);
     c.removeAll(1.0);
     QCOMPARE(c.count(), 0);
     c.removeAll(4.0);
     QCOMPARE(c.count(), 0);
 }//t_search
 
 void Coordinates_test::
 t_io()
 {
     Coordinates c;
     c << 1.0 << 2.0 << 3.0;
     ostringstream os;
     os << "Coordinates 1-2-3\n" << c;
     cout << os.str();
     QString s= QString::fromStdString(os.str());
     QCOMPARE(s.count("2"), 2);
 }//t_io
 
 }//orgQhull
 
 #include "moc/Coordinates_test.moc"
diff --git a/src/qhullptest/DEPRECATED.txt b/src/qhullptest/DEPRECATED.txt
new file mode 100644
index 0000000..db9d81b
--- /dev/null
+++ b/src/qhullptest/DEPRECATED.txt
@@ -0,0 +1,10 @@
+
+qhull/src/qhullptest
+
+    This directory tests the deprecated cpp classes based on libqhullp.
+    
+    It will be maintained until January 2015.
+    
+    See qhull/src/qhulltest for the new cpp tests.
+    
+ 
diff --git a/src/qhullrtest/PointCoordinates_test.cpp b/src/qhullptest/PointCoordinates_test.cpp
similarity index 98%
rename from src/qhullrtest/PointCoordinates_test.cpp
rename to src/qhullptest/PointCoordinates_test.cpp
index d49d9c9..67d5ec3 100644
--- a/src/qhullrtest/PointCoordinates_test.cpp
+++ b/src/qhullptest/PointCoordinates_test.cpp
@@ -1,397 +1,397 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/PointCoordinates_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/PointCoordinates_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h" // QT_VERSION
 
 #include "PointCoordinates.h"
 #include "QhullError.h"
 #include "RboxPoints.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 using std::stringstream;
 
 namespace orgQhull {
 
 class PointCoordinates_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void t_construct();
     void t_convert();
     void t_getset();
     void t_element();
     void t_foreach();
     void t_search();
     void t_modify();
     void t_append_points();
     void t_coord_iterator();
     void t_io();
 };//PointCoordinates_test
 
 void
 add_PointCoordinates_test()
 {
     new PointCoordinates_test();
 }
 
 void PointCoordinates_test::
 t_construct()
 {
     PointCoordinates pc;
     QCOMPARE(pc.size(), 0U);
     QCOMPARE(pc.coordinateCount(), 0);
     QCOMPARE(pc.dimension(), 0);
     QCOMPARE(pc.coordinates(), (coordT *)0);
     QVERIFY(pc.isEmpty());
     pc.checkValid();
     PointCoordinates pc7(2);
     QCOMPARE(pc7.dimension(), 2);
     QCOMPARE(pc7.count(), 0);
     QVERIFY(pc7.isEmpty());
     QVERIFY(pc7.comment().empty());
     pc7.checkValid();
     PointCoordinates pc2("Test pc2");
     QCOMPARE(pc2.count(), 0);
     QVERIFY(pc2.isEmpty());
     QCOMPARE(pc2.comment(), std::string("Test pc2"));
     pc2.checkValid();
     PointCoordinates pc3(3, "Test 3-d pc3");
     QCOMPARE(pc3.dimension(), 3);
     QVERIFY(pc3.isEmpty());
     pc3.checkValid();
     coordT c[]= { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 };
     PointCoordinates pc4(2, "Test 2-d pc4", 6, c);
     QCOMPARE(pc4.dimension(), 2);
     QCOMPARE(pc4.count(), 3);
     QCOMPARE(pc4.size(), 3u);
     QVERIFY(!pc4.isEmpty());
     QVERIFY(!pc4.empty());
     pc4.checkValid();
     QhullPoint p= pc4[2];
     QCOMPARE(p[1], 5.0);
     // QhullPoint refers to PointCoordinates
     p[1] += 1.0;
     QCOMPARE(pc4[2][1], 6.0);
     PointCoordinates pc5(4, "Test 4-d pc5 with insufficient coordinates", 6, c);
     QCOMPARE(pc5.dimension(), 4);
     QCOMPARE(pc5.count(), 1);
     QCOMPARE(pc5.extraCoordinatesCount(), 2);
     QCOMPARE(pc5.extraCoordinates()[1], 5.0);
     QVERIFY(!pc5.isEmpty());;
     std::vector<coordT> vc;
     vc.push_back(3.0);
     vc.push_back(4.0);
     vc.push_back(5.0);
     vc.push_back(6.0);
     vc.push_back(7.0);
     vc.push_back(9.0);
     pc5.append(2, &vc[3]); // Copy of vc[]
     pc5.checkValid();
     QhullPoint p5(4, &vc[1]);
     QCOMPARE(pc5[1], p5);
     PointCoordinates pc6(pc5); // Makes copy of point_coordinates
     QCOMPARE(pc6[1], p5);
     QVERIFY(pc6==pc5);
     QhullPoint p6= pc5[1];  // Refers to pc5.coordinates
     pc5[1][0] += 1.0;
     QCOMPARE(pc5[1], p6);
     QVERIFY(pc5[1]!=p5);
     QVERIFY(pc6!=pc5);
     pc6= pc5;
     QVERIFY(pc6==pc5);
     PointCoordinates pc8;
     pc6= pc8;
     QVERIFY(pc6!=pc5);
     QVERIFY(pc6.isEmpty());
 }//t_construct
 
 void PointCoordinates_test::
 t_convert()
 {
     //defineAs tested above
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     PointCoordinates ps(3, "two 3-d points", 6, c);
     QCOMPARE(ps.dimension(), 3);
     QCOMPARE(ps.size(), 2u);
     const coordT *c2= ps.constData();
     QVERIFY(c!=c2);
     QCOMPARE(c[0], c2[0]);
     const coordT *c3= ps.data();
     QCOMPARE(c3, c2);
     coordT *c4= ps.data();
     QCOMPARE(c4, c2);
     std::vector<coordT> vs= ps.toStdVector();
     QCOMPARE(vs.size(), 6u);
     QCOMPARE(vs[5], 5.0);
     QList<coordT> qs= ps.toQList();
     QCOMPARE(qs.size(), 6);
     QCOMPARE(qs[5], 5.0);
 }//t_convert
 
 void PointCoordinates_test::
 t_getset()
 {
     // See t_construct() for test of coordinates, coordinateCount, dimension, empty, isEmpty, ==, !=
     // See t_construct() for test of checkValid, comment, setDimension
     PointCoordinates pc("Coordinates c");
     pc.setComment("New comment");
     QCOMPARE(pc.comment(), std::string("New comment"));
     pc.checkValid();
     pc.makeValid();  // A no-op
     pc.checkValid();
     Coordinates cs= pc.getCoordinates();
     QVERIFY(cs.isEmpty());
     PointCoordinates pc2(pc);
     pc.setDimension(3);
     QVERIFY(pc2!=pc);
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     pc.append(6, c);
     pc.checkValid();
     pc.makeValid();  // A no-op
     QhullPoint p= pc[0];
     QCOMPARE(p[2], 2.0);
     try{
         pc.setDimension(2);
         QFAIL("setDimension(2) did not fail for 3-d.");
     }catch (const std::exception &e) {
         const char *s= e.what();
         cout << "INFO   : Caught " << s;
     }
 }//t_getset
 
 void PointCoordinates_test::
 t_element()
 {
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     PointCoordinates pc(2, "2-d points", 6, c);
     QhullPoint p= pc.at(0);
     QCOMPARE(p, pc[0]);
     QCOMPARE(p, pc.first());
     QCOMPARE(p, pc.value(0));
     p= pc.back();
     QCOMPARE(p, pc[2]);
     QCOMPARE(p, pc.last());
     QCOMPARE(p, pc.value(2));
     QhullPoints ps= pc.mid(1, 2);
     QCOMPARE(ps[1], p);
 }//t_element
 
 void PointCoordinates_test::
 t_foreach()
 {
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     PointCoordinates pc(2, "2-d points", 6, c);
     QhullPoints::Iterator i= pc.begin();
     QhullPoint p= pc[0];
     QCOMPARE(*i, p);
     QCOMPARE((*i)[0], 0.0);
     QhullPoint p3= pc[2];
     i= pc.end();
     QCOMPARE(i[-1], p3);
     const PointCoordinates pc2(2, "2-d points", 6, c);
     QhullPoints::ConstIterator i2= pc.begin();
     const QhullPoint p0= pc2[0];
     QCOMPARE(*i2, p0);
     QCOMPARE((*i2)[0], 0.0);
     QhullPoints::ConstIterator i3= i2;
     QCOMPARE(i3, i2);
     QCOMPARE((*i3)[0], 0.0);
     i3= pc.constEnd();
     --i3;
     QhullPoint p2= pc2[2];
     QCOMPARE(*i3, p2);
     i= pc.end();
     QVERIFY(i-1==i3);
     i2= pc2.end();
     QVERIFY(i2-1!=i3);
     QCOMPARE(*(i2-1), *i3);
     foreach(QhullPoint p3, pc){ //Qt only
         QVERIFY(p3[0]>=0.0);
         QVERIFY(p3[0]<=5.0);
     }
     Coordinates::ConstIterator i4= pc.beginCoordinates();
     QCOMPARE(*i4, 0.0);
     Coordinates::Iterator i5= pc.beginCoordinates();
     QCOMPARE(*i5, 0.0);
     i4= pc.beginCoordinates(1);
     QCOMPARE(*i4, 2.0);
     i5= pc.beginCoordinates(1);
     QCOMPARE(*i5, 2.0);
     i4= pc.endCoordinates();
     QCOMPARE(*--i4, 5.0);
     i5= pc.endCoordinates();
     QCOMPARE(*--i5, 5.0);
 }//t_foreach
 
 void PointCoordinates_test::
 t_search()
 {
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     PointCoordinates pc(2, "2-d points", 6, c);
     QhullPoint p0= pc[0];
     QhullPoint p2= pc[2];
     QVERIFY(pc.contains(p0));
     QVERIFY(pc.contains(p2));
     QCOMPARE(pc.count(p0), 1);
     QCOMPARE(pc.indexOf(p2), 2);
     QCOMPARE(pc.lastIndexOf(p0), 0);
 }//t_search
 
 void PointCoordinates_test::
 t_modify()
 {
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     PointCoordinates pc(2, "2-d points", 6, c);
     coordT c3[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     PointCoordinates pc5(2);
     pc5.append(6, c3); // 0-5
     QVERIFY(pc5==pc);
     PointCoordinates pc2(2, "2-d");
     coordT c2[]= {6.0, 7.0, 8.0, 9.0, 10.0, 11.0};
     pc2.append(6, c2);
     QCOMPARE(pc2.count(), 3);
     pc2.append(14.0);
     QCOMPARE(pc2.count(), 3);
     QCOMPARE(pc2.extraCoordinatesCount(), 1);
     pc2.append(15.0); // 6-11, 14,15
     QCOMPARE(pc2.count(), 4);
     QCOMPARE(pc2.extraCoordinatesCount(), 0);
     QhullPoint p(pc[0]);
     pc2.append(p); // 6-11, 14,15, 0,1
     QCOMPARE(pc2.count(), 5);
     QCOMPARE(pc2.extraCoordinatesCount(), 0);
     QCOMPARE(pc2.lastIndexOf(p), 4);
     pc.append(pc2); // Invalidates p
     QCOMPARE(pc.count(), 8); // 0-11, 14,15, 0,1
     QCOMPARE(pc.extraCoordinatesCount(), 0);
     QCOMPARE(pc.lastIndexOf(pc[0]), 7);
     pc.appendComment(" operators");
     QCOMPARE(pc.comment(), std::string("2-d points operators"));
     pc.checkValid();
     // see t_append_points for appendPoints
     PointCoordinates pc3= pc+pc2;
     pc3.checkValid();
     QCOMPARE(pc3.count(), 13);
     QCOMPARE(pc3[6][0], 14.0);
     QCOMPARE(pc3[8][0], 6.0);
     pc3 += pc;
     QCOMPARE(pc3.count(), 21);
     QCOMPARE(pc3[14][0], 2.0);
     pc3 += 12.0;
     pc3 += 14.0;
     QCOMPARE(pc3.count(), 22);
     QCOMPARE(pc3.last()[0], 12.0);
     // QhullPoint p3= pc3.first(); // += throws error because append may move the data
     QhullPoint p3= pc2.first();
     pc3 += p3;
     QCOMPARE(pc3.count(), 23);
     QCOMPARE(pc3.last()[0], 6.0);
     pc3 << pc;
     QCOMPARE(pc3.count(), 31);
     QCOMPARE(pc3.last()[0], 0.0);
     pc3 << 12.0 << 14.0;
     QCOMPARE(pc3.count(), 32);
     QCOMPARE(pc3.last()[0], 12.0);
     PointCoordinates pc4(pc3);
     pc4.reserveCoordinates(100);
     QVERIFY(pc3==pc4);
 }//t_modify
 
 void PointCoordinates_test::
 t_append_points()
 {
     PointCoordinates pc(2, "stringstream");
     stringstream s("2 3 1 2 3 4 5 6");
     pc.appendPoints(s);
     QCOMPARE(pc.count(), 3);
 }//t_append_points
 
 void PointCoordinates_test::
 t_coord_iterator()
 {
     PointCoordinates c(2);
     c << 0.0 << 1.0 << 2.0 << 3.0 << 4.0 << 5.0;
     PointCoordinatesIterator i(c);
     QhullPoint p0(c[0]);
     QhullPoint p1(c[1]);
     QhullPoint p2(c[2]);
     coordT c2[] = {-1.0, -2.0};
     QhullPoint p3(2, c2);
     PointCoordinatesIterator i2= c;
     QVERIFY(i.findNext(p1));
     QVERIFY(!i.findNext(p1));
     QVERIFY(!i.findNext(p2));
     QVERIFY(!i.findNext(p3));
     QVERIFY(i.findPrevious(p2));
     QVERIFY(!i.findPrevious(p2));
     QVERIFY(!i.findPrevious(p0));
     QVERIFY(!i.findPrevious(p3));
     QVERIFY(i2.findNext(p2));
     QVERIFY(i2.findPrevious(p0));
     QVERIFY(i2.findNext(p1));
     QVERIFY(i2.findPrevious(p0));
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     i2.toFront();
     QVERIFY(!i.hasNext());
     QVERIFY(i.hasPrevious());
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     PointCoordinates c3;
     PointCoordinatesIterator i3= c3;
     QVERIFY(!i3.hasNext());
     QVERIFY(!i3.hasPrevious());
     i3.toBack();
     QVERIFY(!i3.hasNext());
     QVERIFY(!i3.hasPrevious());
     QCOMPARE(i.peekPrevious(), p2);
     QCOMPARE(i.previous(), p2);
     QCOMPARE(i.previous(), p1);
     QCOMPARE(i.previous(), p0);
     QVERIFY(!i.hasPrevious());
     QCOMPARE(i.peekNext(), p0);
     // i.peekNext()= 1.0; // compiler error
     QCOMPARE(i.next(), p0);
     QCOMPARE(i.peekNext(), p1);
     QCOMPARE(i.next(), p1);
     QCOMPARE(i.next(), p2);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), p0);
 }//t_coord_iterator
 
 void PointCoordinates_test::
 t_io()
 {
     PointCoordinates c;
     c << 1.0 << 2.0 << 3.0 << 1.0 << 2.0 << 3.0;
     ostringstream os;
     os << "PointCoordinates 0-d\n" << c;
     c.setDimension(2);
     os << "PointCoordinates 1-3-2\n" << c;
     cout << os.str();
     QString s= QString::fromStdString(os.str());
     QCOMPARE(s.count("0"), 3);
     QCOMPARE(s.count("2"), 4);
 }//t_io
 
 }//orgQhull
 
 #include "moc/PointCoordinates_test.moc"
diff --git a/src/qhullrtest/Point_test.cpp b/src/qhullptest/Point_test.cpp
similarity index 97%
rename from src/qhullrtest/Point_test.cpp
rename to src/qhullptest/Point_test.cpp
index 95394a2..430c721 100644
--- a/src/qhullrtest/Point_test.cpp
+++ b/src/qhullptest/Point_test.cpp
@@ -1,238 +1,238 @@
 /****************************************************************************
 **
 ** Copyright (C) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/Point_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/qhullptest/Point_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include <iostream>
 using std::cout;
 using std::endl;
 #include "RoadTest.h" // QT_VERSION
 
 #include "QhullPoint.h"
 
 #include "Qhull.h"
 
 namespace orgQhull {
 
 class Point_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void initTestCase();
     void t_construct();
     void t_getset();
     void t_operator();
     void t_const_iterator();
     void t_iterator();
     void t_point_iterator();
     // void t_mutable_point_iterator();
     // void t_io();
 };//Point_test
 
 void
 add_Point_test()
 {
     new Point_test();
 }
 
 void Point_test::
 initTestCase(){
     RboxPoints rcube("c");
     Qhull q(rcube, "");
     UsingQhullLib::setGlobals();
 }//initTestCase
 
 void Point_test::
 t_construct()
 {
     QhullPoint p;
     QCOMPARE(p.dimension(), 0);
     coordT c[]= {0.0, 1.0, 2.0};
     QhullPoint p2;
     p2.defineAs(3, c);
     QCOMPARE(p2.dimension(), 3);
     QCOMPARE(p2.coordinates(), c);
     coordT c2[]= {0.0, 1.0, 2.0};
     QhullPoint p3(3, c2);
     QVERIFY(p3==p2);
     QhullPoint p5(p3);
     QVERIFY(p5==p3);
 }//t_construct
 
 void Point_test::
 t_getset()
 {
     coordT c[]= {0.0, 1.0, 2.0};
     QhullPoint p(3, c);
     QCOMPARE(p.coordinates(), c);
     QCOMPARE(p.dimension(), 3);
     QCOMPARE(p[2], 2.0);
     QhullPoint p2(p);
     p2.defineAs(p);
     QVERIFY(p2==p);
     QVERIFY(p2.coordinates()==p.coordinates());
     QVERIFY(p2.dimension()==p.dimension());
     p2.setDimension(2);
     QCOMPARE(p2.dimension(), 2);
     QVERIFY(p2!=p);
     coordT c2[]= {0.0, 1.0};
     p2.setCoordinates(c2);
     QCOMPARE(p2.coordinates(), c2);
     p.defineAs(2, c);
     QVERIFY(p2==p);
     QCOMPARE(p[1], 1.0);
 }//t_getset
 
 void Point_test::
 t_operator()
 {
     QhullPoint p;
     QhullPoint p2(p);
     QVERIFY(p==p2);
     QVERIFY(!(p!=p2));
     coordT c[]= {0.0, 1.0, 2.0};
     QhullPoint p3(3, c);
     QVERIFY(p3!=p2);
     QhullPoint p4(p3);
     QVERIFY(p4==p3);
     coordT c5[]= {5.0, 6.0, 7.0};
     QhullPoint p5(3, c5);
     QVERIFY(p5!=p3);
     QCOMPARE(p5[1], 6.0);
     QCOMPARE(p5[0], 5.0);
     const coordT *c0= &p5[0];
     QCOMPARE(*c0, 5.0);
 }//t_operator
 
 void Point_test::
 t_const_iterator()
 {
     coordT c[]= {1.0, 2.0, 3.0};
     QhullPoint p(3, c);
     QhullPoint::const_iterator i(p.coordinates());
     QhullPoint::const_iterator i2= p.coordinates();
     QVERIFY(i==i2);
     QVERIFY(i>=i2);
     QVERIFY(i<=i2);
     QCOMPARE(*i, 1.0);
     QCOMPARE(*(i+1), 2.0);
     QCOMPARE(*(i+1), i[1]);
     i= p.end();
     QVERIFY(i!=i2);
     i= i2;
     QVERIFY(i==i2);
     i= p.end();
     i= p.begin();
     QCOMPARE(*i, 1.0);
     QhullPoint::ConstIterator i3= p.end();
     QCOMPARE(*(i3-1), 3.0);
     QCOMPARE(*(i3-1), i3[-1]);
     QVERIFY(i!=i3);
     QVERIFY(i<i3);
     QVERIFY(i<=i3);
     QVERIFY(i3>i);
     QVERIFY(i3>=i);
 }//t_const_iterator
 
 
 void Point_test::
 t_iterator()
 {
     coordT c[]= {1.0, 2.0, 3.0};
     QhullPoint p(3, c);
     QhullPoint::Iterator i(p.coordinates());
     QhullPoint::iterator i2= p.coordinates();
     QVERIFY(i==i2);
     QVERIFY(i>=i2);
     QVERIFY(i<=i2);
     QCOMPARE(*i, 1.0);
     QCOMPARE(*(i+1), 2.0);
     QCOMPARE(*(i+1), i[1]);
     i= p.end();
     QVERIFY(i!=i2);
     i= i2;
     QVERIFY(i==i2);
     i= p.end();
     i= p.begin();
     QCOMPARE(*i, 1.0);
     QhullPoint::Iterator i3= p.end();
     QCOMPARE(*(i3-1), 3.0);
     QCOMPARE(*(i3-1), i3[-1]);
     QVERIFY(i!=i3);
     QVERIFY(i<i3);
     QVERIFY(i<=i3);
     QVERIFY(i3>i);
     QVERIFY(i3>=i);
     // compiler errors -- QhullPoint is const-only
     // QCOMPARE((i[0]= -10.0), -10.0);
     // coordT *c3= &i3[1];
 }//t_iterator
 
 void Point_test::
 t_point_iterator()
 {
     coordT c[]= {1.0, 3.0, 4.0};
     QhullPoint p(3, c);
     QhullPointIterator i(p);
     QhullPointIterator i2= p;
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     i2.toFront();
     QVERIFY(!i.hasNext());
     QVERIFY(i.hasPrevious());
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
 
     coordT c2[]= {1.0, 3.0, 4.0};
     QhullPoint p2(0, c2); // 0-dimensional
     i2= p2;
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     i2.toBack();
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekPrevious(), 4.0);
     QCOMPARE(i.previous(), 4.0);
     QCOMPARE(i.previous(), 3.0);
     QCOMPARE(i.previous(), 1.0);
     QVERIFY(!i.hasPrevious());
     QCOMPARE(i.peekNext(), 1.0);
     // i.peekNext()= 1.0; // compiler error
     QCOMPARE(i.next(), 1.0);
     QCOMPARE(i.peekNext(), 3.0);
     QCOMPARE(i.next(), 3.0);
     QCOMPARE(i.next(), 4.0);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), 1.0);
 }//t_point_iterator
 
 // No MutableQhullPointIterator since QhullPoint is const-only
 
 #if 0
 
 void Point_test::
 t_io()
 {
     QhullPoint p;
     cout<< "INFO:     empty point" << p << endl;
     const coordT c[]= {1.0, 3.0, 4.0};
     QhullPoint p2(2, c); // 2-dimensional
     cout<< "INFO:   " << p2 << endl;
 }//t_io
 
 error LNK2019: unresolved external symbol "class std::basic_ostream<char,struct std::char_traits<char> > & __cdecl operator<<(class std::basic_ostream<char,struct std::char_traits<char> > &,class orgQhull::QhullPoint &)" (??6@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@std@@AAV01@AAVPoint@orgQhull@@@Z) referenced in function "private: void __thiscall orgQhull::Point_test::t_io(void)" (?t_io@Point_test@orgQhull@@AAEXXZ)
 
 #endif
 
 }//orgQhull
 
 #include "moc/Point_test.moc"
diff --git a/src/qhullrtest/QhullFacetList_test.cpp b/src/qhullptest/QhullFacetList_test.cpp
similarity index 95%
rename from src/qhullrtest/QhullFacetList_test.cpp
rename to src/qhullptest/QhullFacetList_test.cpp
index ce7d34f..2722f37 100644
--- a/src/qhullrtest/QhullFacetList_test.cpp
+++ b/src/qhullptest/QhullFacetList_test.cpp
@@ -1,172 +1,172 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullFacetList_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullFacetList_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h" // QT_VERSION
 
 #include "QhullFacetList.h"
 #include "QhullError.h"
 #include "QhullFacet.h"
 #include "QhullVertexSet.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullFacetList_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_readonly();
     void t_foreach();
     void t_io();
 };//QhullFacetList_test
 
 void
 add_QhullFacetList_test()
 {
     new QhullFacetList_test();
 }
 
 //Executed after each testcase
 void QhullFacetList_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullFacetList_test::
 t_construct()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullFacetList fs2= q.facetList();
     QVERIFY(!fs2.isEmpty());
     QCOMPARE(fs2.count(),6);
     QhullFacetList fs3(q.endFacet(), q.endFacet());
     QVERIFY(fs3.isEmpty());
     QhullFacetList fs4(q.endFacet().previous(), q.endFacet());
     QCOMPARE(fs4.count(), 1);
     QhullFacetList fs5(q.beginFacet(), q.endFacet());
     QCOMPARE(fs2.count(), fs5.count());
     QVERIFY(fs2==fs5);
     QhullFacetList fs6= fs2; // copy constructor
     QVERIFY(fs6==fs2);
     std::vector<QhullFacet> fv= fs2.toStdVector();
     QCOMPARE(fv.size(), 6u);
 }//t_construct
 
 void QhullFacetList_test::
 t_convert()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0 QV2");  // rotated unit cube
     QhullFacetList fs2= q.facetList();
     QVERIFY(!fs2.isSelectAll());
     QVERIFY(!fs2.isEmpty());
     QCOMPARE(fs2.count(),3);
     std::vector<QhullFacet> fv= fs2.toStdVector();
     QCOMPARE(fv.size(), 3u);
     QList<QhullFacet> fv2= fs2.toQList();
     QCOMPARE(fv2.size(), 3);
     std::vector<QhullVertex> fv5= fs2.vertices_toStdVector(q.runId());
     QCOMPARE(fv5.size(), 7u);
     QList<QhullVertex> fv6= fs2.vertices_toQList(q.runId());
     QCOMPARE(fv6.size(), 7);
     fs2.selectAll();
     QVERIFY(fs2.isSelectAll());
     std::vector<QhullFacet> fv3= fs2.toStdVector();
     QCOMPARE(fv3.size(), 6u);
     QList<QhullFacet> fv4= fs2.toQList();
     QCOMPARE(fv4.size(), 6);
     std::vector<QhullVertex> fv7= fs2.vertices_toStdVector(q.runId());
     QCOMPARE(fv7.size(), 8u);
     QList<QhullVertex> fv8= fs2.vertices_toQList(q.runId());
     QCOMPARE(fv8.size(), 8);
 }//t_convert
 
 //! Spot check properties and read-only.  See QhullLinkedList_test
 void QhullFacetList_test::
 t_readonly()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QV0");  // good facets are adjacent to point 0
     QhullFacetList fs= q.facetList();
     QVERIFY(!fs.isSelectAll());
     QCOMPARE(fs.count(), 3);
     QCOMPARE(fs.first(), q.firstFacet());
     fs.selectAll();
     QVERIFY(fs.isSelectAll());
     QCOMPARE(fs.count(), 6);
     fs.selectGood();
     QVERIFY(!fs.isSelectAll());
     QCOMPARE(fs.count(), 3);
     fs.selectAll();
     QVERIFY(fs.isSelectAll());
     QCOMPARE(fs.count(), 6);
     QhullFacet f= fs.first();
     QhullFacet f2= fs.last();
     fs.selectAll();
     QVERIFY(fs.contains(f));
     QVERIFY(fs.contains(f2));
     QVERIFY(f.isGood());
     QVERIFY(!f2.isGood());
     fs.selectGood();
     QVERIFY(fs.contains(f));
     QVERIFY(!fs.contains(f2));
 }//t_readonly
 
 void QhullFacetList_test::
 t_foreach()
 {
     RboxPoints rcube("c");
     // Spot check predicates and accessors.  See QhullLinkedList_test
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullFacetList fs= q.facetList();
     QVERIFY(fs.contains(q.firstFacet()));
     QhullFacet f= q.firstFacet().next();
     QVERIFY(fs.contains(f));
     QCOMPARE(fs.first(), *fs.begin());
     QCOMPARE(*(fs.end()-1), fs.last());
     QCOMPARE(fs.first(), q.firstFacet());
     QCOMPARE(*fs.begin(), q.beginFacet());
     QCOMPARE(*fs.end(), q.endFacet());
 }//t_foreach
 
 void QhullFacetList_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0 QV0");   // good facets are adjacent to point 0
         QhullFacetList fs= q.facetList();
         ostringstream os;
         os << fs.print(q.runId()); // Runs all print options
         os << "\nFacets only\n" << fs; // printVertices() requires a runId
         cout << os.str();
         QString facets= QString::fromStdString(os.str());
         QCOMPARE(facets.count("(v"), 7+12*3*2);
         QCOMPARE(facets.count(QRegExp("f\\d")), 3*7 + 13*3*2);
     }
 }//t_io
 
 }//orgQhull
 
 #include "moc/QhullFacetList_test.moc"
diff --git a/src/qhullrtest/QhullFacetSet_test.cpp b/src/qhullptest/QhullFacetSet_test.cpp
similarity index 95%
rename from src/qhullrtest/QhullFacetSet_test.cpp
rename to src/qhullptest/QhullFacetSet_test.cpp
index 647a7fa..b3b84c3 100644
--- a/src/qhullrtest/QhullFacetSet_test.cpp
+++ b/src/qhullptest/QhullFacetSet_test.cpp
@@ -1,153 +1,153 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullFacetSet_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullFacetSet_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h"
 
 #include "QhullFacetSet.h"
 #include "QhullError.h"
 #include "QhullFacet.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullFacetSet_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_readonly();
     void t_foreach();
     void t_io();
 };//QhullFacetSet_test
 
 void
 add_QhullFacetSet_test()
 {
     new QhullFacetSet_test();
 }
 
 //Executed after each testcase
 void QhullFacetSet_test::
 cleanup()
 {
     RoadTest::cleanup();
     UsingLibQhull::checkQhullMemoryEmpty();
 }
 
 void QhullFacetSet_test::
 t_construct()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullFacet f= q.firstFacet();
     QhullFacetSet fs2= f.neighborFacets();
     QVERIFY(!fs2.isEmpty());
     QCOMPARE(fs2.count(),4);
     QhullFacetSet fs4= fs2; // copy constructor
     QVERIFY(fs4==fs2);
     QhullFacetSet fs3(q.qhullQh()->facet_mergeset);
     QVERIFY(fs3.isEmpty());
 }//t_construct
 
 void QhullFacetSet_test::
 t_convert()
 {
     RboxPoints rcube("c");
     Qhull q2(rcube,"QR0 QV2");  // rotated unit cube
     QhullFacet f2= q2.firstFacet();
     QhullFacetSet fs2= f2.neighborFacets();
     QVERIFY(!fs2.isSelectAll());
     QCOMPARE(fs2.count(),2);
     std::vector<QhullFacet> fv= fs2.toStdVector();
     QCOMPARE(fv.size(), 2u);
     QList<QhullFacet> fv2= fs2.toQList();
     QCOMPARE(fv2.size(), 2);
     fs2.selectAll();
     QVERIFY(fs2.isSelectAll());
     std::vector<QhullFacet> fv3= fs2.toStdVector();
     QCOMPARE(fv3.size(), 4u);
     QList<QhullFacet> fv4= fs2.toQList();
     QCOMPARE(fv4.size(), 4);
 }//t_convert
 
 //! Spot check properties and read-only.  See QhullSet_test
 void QhullFacetSet_test::
 t_readonly()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QV0");  // good facets are adjacent to point 0
     QhullFacetSet fs= q.firstFacet().neighborFacets();
     QVERIFY(!fs.isSelectAll());
     QCOMPARE(fs.count(), 2);
     fs.selectAll();
     QVERIFY(fs.isSelectAll());
     QCOMPARE(fs.count(), 4);
     fs.selectGood();
     QVERIFY(!fs.isSelectAll());
     QCOMPARE(fs.count(), 2);
     QhullFacet f= fs.first();
     QhullFacet f2= fs.last();
     fs.selectAll();
     QVERIFY(fs.contains(f));
     QVERIFY(fs.contains(f2));
     QVERIFY(f.isGood());
     QVERIFY(!f2.isGood());
     fs.selectGood();
     QVERIFY(fs.contains(f));
     QVERIFY(!fs.contains(f2));
 }//t_readonly
 
 void QhullFacetSet_test::
 t_foreach()
 {
     RboxPoints rcube("c");
     // Spot check predicates and accessors.  See QhullLinkedList_test
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullFacetSet fs= q.firstFacet().neighborFacets();
     QVERIFY(!fs.contains(q.firstFacet()));
     QVERIFY(fs.contains(fs.first()));
     QhullFacet f= q.firstFacet().next();
     if(!fs.contains(f)){
         f= f.next();
     }
     QVERIFY(fs.contains(f));
     QCOMPARE(fs.first(), *fs.begin());
     QCOMPARE(*(fs.end()-1), fs.last());
 }//t_foreach
 
 void QhullFacetSet_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0 QV0");   // good facets are adjacent to point 0
         QhullFacetSet fs= q.firstFacet().neighborFacets();
         ostringstream os;
         os << fs.print(q.runId(), "Neighbors of first facet with point 0");
         os << fs.printIdentifiers("\nFacet identifiers: ");
         cout << os.str();
         QString facets= QString::fromStdString(os.str());
         QCOMPARE(facets.count(QRegExp(" f[0-9]")), 2+13*2);
     }
 }//t_io
 
 }//orgQhull
 
 #include "moc/QhullFacetSet_test.moc"
diff --git a/src/qhullrtest/QhullFacet_test.cpp b/src/qhullptest/QhullFacet_test.cpp
similarity index 97%
rename from src/qhullrtest/QhullFacet_test.cpp
rename to src/qhullptest/QhullFacet_test.cpp
index 631e340..81082bd 100644
--- a/src/qhullrtest/QhullFacet_test.cpp
+++ b/src/qhullptest/QhullFacet_test.cpp
@@ -1,264 +1,264 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullFacet_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullFacet_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h"
 
 #include "QhullFacet.h"
 #include "QhullError.h"
 #include "Coordinates.h"
 #include "RboxPoints.h"
 #include "QhullFacetList.h"
 #include "QhullFacetSet.h"
 #include "QhullPointSet.h"
 #include "QhullRidge.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullFacet_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_constructConvert();
     void t_getSet();
     void t_value();
     void t_foreach();
     void t_io();
 };//QhullFacet_test
 
 void
 add_QhullFacet_test()
 {
     new QhullFacet_test();
 }
 
 //Executed after each testcase
 void QhullFacet_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullFacet_test::
 t_constructConvert()
 {
     // Qhull.runQhull() constructs QhullFacets as facetT
     QhullFacet f;
     QVERIFY(!f.isDefined());
     QCOMPARE(f.dimension(),0);
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullFacet f2(q.beginFacet());
     QCOMPARE(f2.dimension(),3);
     f= f2; // copy assignment
     QVERIFY(f.isDefined());
     QCOMPARE(f.dimension(),3);
     QhullFacet f5= f2;
     QVERIFY(f5==f2);
     QVERIFY(f5==f);
     QhullFacet f3= f2.getFacetT();
     QCOMPARE(f,f3);
     QhullFacet f4= f2.getBaseT();
     QCOMPARE(f,f4);
 }//t_constructConvert
 
 void QhullFacet_test::
 t_getSet()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QCOMPARE(q.facetCount(), 12);
         QCOMPARE(q.vertexCount(), 8);
         QhullFacetListIterator i(q.facetList());
         while(i.hasNext()){
             const QhullFacet f= i.next();
             cout << f.id() << endl;
             QCOMPARE(f.dimension(),3);
             QVERIFY(f.id()>0 && f.id()<=39);
             QVERIFY(f.isDefined());
             if(i.hasNext()){
                 QCOMPARE(f.next(), i.peekNext());
                 QVERIFY(f.next()!=f);
             }
             QVERIFY(i.hasPrevious());
             QCOMPARE(f, i.peekPrevious());
         }
         QhullFacetListIterator i2(i);
         QEXPECT_FAIL("", "ListIterator copy constructor not reset to BOT", Continue);
         QVERIFY(!i2.hasPrevious());
 
         // test tricoplanarOwner
         QhullFacet facet = q.beginFacet();
         QhullFacet tricoplanarOwner = facet.tricoplanarOwner();
         int tricoplanarCount= 0;
         i.toFront();
         while(i.hasNext()){
             const QhullFacet f= i.next();
             if(f.tricoplanarOwner()==tricoplanarOwner){
                 tricoplanarCount++;
             }
         }
         QCOMPARE(tricoplanarCount, 2);
         int tricoplanarCount2= 0;
         foreach (QhullFacet f, q.facetList()){  // Qt only
             QhullHyperplane h= f.hyperplane();
             cout << "Hyperplane: " << h << endl;
             QCOMPARE(h.count(), 3);
             QCOMPARE(h.offset(), -0.5);
             double n= h.norm();
             QCOMPARE(n, 1.0);
             QhullHyperplane hi= f.innerplane(q.runId());
             QCOMPARE(hi.count(), 3);
             double innerOffset= hi.offset()+0.5;
             cout << "InnerPlane: " << hi << "innerOffset+0.5 " << innerOffset << endl;
             QVERIFY(innerOffset >= 0.0);
             QhullHyperplane ho= f.outerplane(q.runId());
             QCOMPARE(ho.count(), 3);
             double outerOffset= ho.offset()+0.5;
             cout << "OuterPlane: " << ho << "outerOffset+0.5 " << outerOffset << endl;
             QVERIFY(outerOffset <= 0.0);
             QVERIFY(outerOffset-innerOffset < 1e-7);
             for(int k= 0; k<3; k++){
                 QVERIFY(ho[k]==hi[k]);
                 QVERIFY(ho[k]==h[k]);
             }
             QhullPoint center= f.getCenter(q.runId());
             cout << "Center: " << center << endl;
             double d= f.distance(center);
             QVERIFY(d < innerOffset-outerOffset);
             QhullPoint center2= f.getCenter(q.runId(), qh_PRINTcentrums);
             QCOMPARE(center, center2);
             if(f.tricoplanarOwner()==tricoplanarOwner){
                 tricoplanarCount2++;
             }
         }
         QCOMPARE(tricoplanarCount2, 2);
         Qhull q2(rcube,"d Qz Qt QR0");  // 3-d triangulation of Delaunay triangulation (the cube)
         QhullFacet f2= q2.firstFacet();
         QhullPoint center3= f2.getCenter(q.runId(), qh_PRINTtriangles);
         QCOMPARE(center3.dimension(), 3);
         QhullPoint center4= f2.getCenter(q.runId());
         QCOMPARE(center4.dimension(), 3);
         for(int k= 0; k<3; k++){
             QVERIFY(center4[k]==center3[k]);
         }
         Qhull q3(rcube,"v Qz QR0");  // Voronoi diagram of a cube (one vertex)
 
         UsingLibQhull::setGlobalDistanceEpsilon(1e-12); // Voronoi vertices are not necessarily within distance episilon
         foreach(QhullFacet f, q3.facetList()){ //Qt only
             if(f.isGood()){
                 QhullPoint p= f.voronoiVertex(q3.runId());
                 cout << p.print(q3.runId(), "Voronoi vertex: ")
                     << " DistanceEpsilon " << UsingLibQhull::globalDistanceEpsilon() << endl;
                 QCOMPARE(p, q3.origin());
             }
         }
     }
 }//t_getSet
 
 void QhullFacet_test::
 t_value()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube, "");
         coordT c[]= {0.0, 0.0, 0.0};
         foreach (QhullFacet f, q.facetList()){  // Qt only
             double d= f.distance(q.origin());
             QCOMPARE(d, -0.5);
             double d0= f.distance(c);
             QCOMPARE(d0, -0.5);
             double facetArea= f.facetArea(q.runId());
             QCOMPARE(facetArea, 1.0);
             #if qh_MAXoutside
                 double maxoutside= f.getFacetT()->maxoutside;
                 QVERIFY(maxoutside<1e-7);
             #endif
         }
     }
 }//t_value
 
 void QhullFacet_test::
 t_foreach()
 {
     RboxPoints rcube("c W0 300");  // cube plus 300 points on its surface
     {
         Qhull q(rcube, "QR0 Qc"); // keep coplanars, thick facet, and rotate the cube
         int coplanarCount= 0;
         foreach(const QhullFacet f, q.facetList()){
             QhullPointSet coplanars= f.coplanarPoints();
             coplanarCount += coplanars.count();
             QhullFacetSet neighbors= f.neighborFacets();
             QCOMPARE(neighbors.count(), 4);
             QhullPointSet outsides= f.outsidePoints();
             QCOMPARE(outsides.count(), 0);
             QhullRidgeSet ridges= f.ridges();
             QCOMPARE(ridges.count(), 4);
             QhullVertexSet vertices= f.vertices();
             QCOMPARE(vertices.count(), 4);
             int ridgeCount= 0;
             QhullRidge r= ridges.first();
             for(int r0= r.id(); ridgeCount==0 || r.id()!=r0; r= r.nextRidge3d(f)){
                 ++ridgeCount;
                 if(!r.hasNextRidge3d(f)){
                     QFAIL("Unexpected simplicial facet.  They only have ridges to non-simplicial neighbors.");
                 }
             }
             QCOMPARE(ridgeCount, 4);
         }
         QCOMPARE(coplanarCount, 300);
     }
 }//t_foreach
 
 void QhullFacet_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube, "");
         QhullFacet f= q.beginFacet();
         cout << f;
         ostringstream os;
         os << f.printHeader(q.runId());
         os << f.printFlags("    - flags:");
         os << f.printCenter(q.runId(), qh_PRINTfacets, "    - center:");
         os << f.printRidges(q.runId());
         cout << os.str();
         ostringstream os2;
         os2 << f.print(q.runId());  // invokes print*()
         QString facetString2= QString::fromStdString(os2.str());
         facetString2.replace(QRegExp("\\s\\s+"), " ");
         ostringstream os3;
         q.setOutputStream(&os3);
         q.outputQhull("f");
         QString facetsString= QString::fromStdString(os3.str());
         QString facetString3= facetsString.mid(facetsString.indexOf("- f1\n"));
         facetString3= facetString3.left(facetString3.indexOf("\n- f")+1);
         facetString3.replace(QRegExp("\\s\\s+"), " ");
         QCOMPARE(facetString2, facetString3);
     }
 }//t_io
 
 // toQhullFacet is static_cast only
 
 }//orgQhull
 
 #include "moc/QhullFacet_test.moc"
diff --git a/src/qhullrtest/QhullHyperplane_test.cpp b/src/qhullptest/QhullHyperplane_test.cpp
similarity index 98%
rename from src/qhullrtest/QhullHyperplane_test.cpp
rename to src/qhullptest/QhullHyperplane_test.cpp
index 64d8b52..6053616 100644
--- a/src/qhullrtest/QhullHyperplane_test.cpp
+++ b/src/qhullptest/QhullHyperplane_test.cpp
@@ -1,412 +1,412 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullHyperplane_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullHyperplane_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include <vector>
 #include "RoadTest.h"
 
 #include "QhullHyperplane.h"
 #include "QhullError.h"
 #include "RboxPoints.h"
 #include "QhullFacet.h"
 #include "QhullFacetList.h"
 #include "Qhull.h"
 #include <numeric>
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullHyperplane_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_readonly();
     void t_define();
     void t_value();
     void t_operator();
     void t_iterator();
     void t_const_iterator();
     void t_qhullHyperplane_iterator();
     void t_io();
 };//QhullHyperplane_test
 
 void
 add_QhullHyperplane_test()
 {
     new QhullHyperplane_test();
 }
 
 //Executed after each testcase
 void QhullHyperplane_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullHyperplane_test::
 t_construct()
 {
     // Qhull.runQhull() constructs QhullFacets as facetT
     QhullHyperplane h;
     QVERIFY(!h.isDefined());
     QCOMPARE(h.dimension(),0);
     QCOMPARE(h.coordinates(),static_cast<double *>(0));
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullFacet f= q.firstFacet();
     QhullHyperplane h2(f.hyperplane());
     QVERIFY(h2.isDefined());
     QCOMPARE(h2.dimension(),3);
     // h= h2;  // copy assignment disabled, ambiguous
     QhullHyperplane h3(h2.dimension(), h2.coordinates(), h2.offset());
     QCOMPARE(h2, h3);
     QhullHyperplane h5= h2; // copy constructor
     QVERIFY(h5==h2);
 }//t_construct
 
 void QhullHyperplane_test::
 t_convert()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullHyperplane h= q.firstFacet().hyperplane();
     std::vector<double> fs= h.toStdVector();
     QCOMPARE(fs.size(), 4u);
     double offset= fs.back();
     fs.pop_back();
     QCOMPARE(offset, -0.5);
 
     double squareNorm= inner_product(fs.begin(), fs.end(), fs.begin(), 0.0);
     QCOMPARE(squareNorm, 1.0);
     QList<double> qs= h.toQList();
     QCOMPARE(qs.size(), 4);
     double offset2= qs.takeLast();
     QCOMPARE(offset2, -0.5);
     double squareNorm2= std::inner_product(qs.begin(), qs.end(), qs.begin(), 0.0);
     QCOMPARE(squareNorm2, 1.0);
 }//t_convert
 
 void QhullHyperplane_test::
 t_readonly()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QhullFacetList fs= q.facetList();
         QhullFacetListIterator i(fs);
         while(i.hasNext()){
             QhullFacet f= i.next();
             QhullHyperplane h= f.hyperplane();
             int id= f.id();
             cout << "h" << id << endl;
             QVERIFY(h.isDefined());
             QCOMPARE(h.dimension(),3);
             const coordT *c= h.coordinates();
             coordT *c2= h.coordinates();
             QCOMPARE(c, c2);
             const coordT *c3= h.begin();
             QCOMPARE(c, c3);
             QCOMPARE(h.offset(), -0.5);
             int j= h.end()-h.begin();
             QCOMPARE(j, 3);
             double squareNorm= std::inner_product(h.begin(), h.end(), h.begin(), 0.0);
             QCOMPARE(squareNorm, 1.0);
         }
         QhullHyperplane h2= fs.first().hyperplane();
         QhullHyperplane h3= fs.last().hyperplane();
         QVERIFY(h2!=h3);
         QVERIFY(h3.coordinates()!=h2.coordinates());
     }
 }//t_readonly
 
 void QhullHyperplane_test::
 t_define()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QhullFacetList fs= q.facetList();
         QhullHyperplane h= fs.first().hyperplane();
         QhullHyperplane h2= h;
         QVERIFY(h==h2);
         QhullHyperplane h3= fs.last().hyperplane();
         QVERIFY(h2!=h3);
 
         QhullHyperplane h4= h3;
         h4.defineAs(h2);
         QVERIFY(h2==h4);
         QhullHyperplane p5= h3;
         p5.defineAs(h2.dimension(), h2.coordinates(), h2.offset());
         QVERIFY(h2==p5);
         QhullHyperplane h6= h3;
         h6.setCoordinates(h2.coordinates());
         QCOMPARE(h2.coordinates(), h6.coordinates());
         h6.setOffset(h2.offset());
         QCOMPARE(h2.offset(), h6.offset());
         QVERIFY(h2==h6);
         h6.setDimension(2);
         QCOMPARE(h6.dimension(), 2);
         QVERIFY(h2!=h6);
     }
 }//t_define
 
 void QhullHyperplane_test::
 t_value()
 {
     RboxPoints rcube("c G1");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     const QhullHyperplane h= q.firstFacet().hyperplane();
     double dist= h.distance(q.origin());
     QCOMPARE(dist, -1.0);
     double norm= h.norm();
     QCOMPARE(norm, 1.0);
 }//t_value
 
 void QhullHyperplane_test::
 t_operator()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     const QhullHyperplane h= q.firstFacet().hyperplane();
     //operator== and operator!= tested elsewhere
     const coordT *c= h.coordinates();
     for(int k=h.dimension(); k--; ){
         QCOMPARE(c[k], h[k]);
     }
     //h[0]= 10.0; // compiler error, const
     QhullHyperplane h2= q.firstFacet().hyperplane();
     h2[0]= 10.0;  // Overwrites Hyperplane coordinate!
     QCOMPARE(h2[0], 10.0);
 }//t_operator
 
 void QhullHyperplane_test::
 t_iterator()
 {
     RboxPoints rcube("c");
     {
         QhullHyperplane h2;
         QCOMPARE(h2.begin(), h2.end());
         QCOMPARE(h2.count(), 0);
         QCOMPARE(h2.size(), 0u);
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullHyperplane h= q.firstFacet().hyperplane();
         QCOMPARE(h.count(), 3);
         QCOMPARE(h.size(), 3u);
         QhullHyperplane::Iterator i= h.begin();
         QhullHyperplane::iterator i2= h.begin();
         QVERIFY(i==i2);
         QVERIFY(i>=i2);
         QVERIFY(i<=i2);
         i= h.begin();
         QVERIFY(i==i2);
         i2= h.end();
         QVERIFY(i!=i2);
         double d3= *i;
         i2--;
         double d2= *i2;
         QCOMPARE(d3, h[0]);
         QCOMPARE(d2, h[2]);
         QhullHyperplane::Iterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3), h[1]);
         QVERIFY(i==i);
         QVERIFY(i!=i2);
         QVERIFY(i<i2);
         QVERIFY(i<=i2);
         QVERIFY(i2>i);
         QVERIFY(i2>=i);
 
         QhullHyperplane::ConstIterator i4= h.begin();
         QVERIFY(i==i4); // iterator COMP const_iterator
         QVERIFY(i<=i4);
         QVERIFY(i>=i4);
         QVERIFY(i4==i); // const_iterator COMP iterator
         QVERIFY(i4<=i);
         QVERIFY(i4>=i);
         QVERIFY(i>=i4);
         QVERIFY(i4<=i);
         QVERIFY(i2!=i4);
         QVERIFY(i2>i4);
         QVERIFY(i2>=i4);
         QVERIFY(i4!=i2);
         QVERIFY(i4<i2);
         QVERIFY(i4<=i2);
         ++i4;
         QVERIFY(i<i4);
         QVERIFY(i<=i4);
         QVERIFY(i4>i);
         QVERIFY(i4>=i);
 
         i= h.begin();
         i2= h.begin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, h[1]);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, h.begin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2 += 3, h.end());
         QCOMPARE(i2 -= 3, h.begin());
         QCOMPARE(i2+0, h.begin());
         QCOMPARE(i2+3, h.end());
         i2 += 3;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-3;
         QCOMPARE(i, h.begin());
         QCOMPARE(i2-i, 3);
 
         //h.begin end tested above
 
         // QhullHyperplane is const-only
     }
 }//t_iterator
 
 void QhullHyperplane_test::
 t_const_iterator()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullHyperplane h= q.firstFacet().hyperplane();
         QhullHyperplane::ConstIterator i= h.begin();
         QhullHyperplane::const_iterator i2= h.begin();
         QVERIFY(i==i2);
         QVERIFY(i>=i2);
         QVERIFY(i<=i2);
         i= h.begin();
         QVERIFY(i==i2);
         i2= h.end();
         QVERIFY(i!=i2);
         double d3= *i;
         i2--;
         double d2= *i2;
         QCOMPARE(d3, h[0]);
         QCOMPARE(d2, h[2]);
         QhullHyperplane::ConstIterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3), h[1]);
         QVERIFY(i==i);
         QVERIFY(i!=i2);
         QVERIFY(i<i2);
         QVERIFY(i<=i2);
         QVERIFY(i2>i);
         QVERIFY(i2>=i);
 
         // See t_iterator for const_iterator COMP iterator
 
         i= h.begin();
         i2= h.constBegin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, h[1]);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, h.constBegin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2+=3, h.constEnd());
         QCOMPARE(i2-=3, h.constBegin());
         QCOMPARE(i2+0, h.constBegin());
         QCOMPARE(i2+3, h.constEnd());
         i2 += 3;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-3;
         QCOMPARE(i, h.constBegin());
         QCOMPARE(i2-i, 3);
 
         // QhullHyperplane is const-only
     }
 }//t_const_iterator
 
 void QhullHyperplane_test::
 t_qhullHyperplane_iterator()
 {
     QhullHyperplane h2;
     QhullHyperplaneIterator i= h2;
     QCOMPARE(h2.dimension(), 0);
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullHyperplane h = q.firstFacet().hyperplane();
     QhullHyperplaneIterator i2(h);
     QCOMPARE(h.dimension(), 3);
     i= h;
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i2.toBack();
     i.toFront();
     QVERIFY(!i2.hasNext());
     QVERIFY(i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     // i at front, i2 at end/back, 3 coordinates
     QCOMPARE(i.peekNext(), h[0]);
     QCOMPARE(i2.peekPrevious(), h[2]);
     QCOMPARE(i2.previous(), h[2]);
     QCOMPARE(i2.previous(), h[1]);
     QCOMPARE(i2.previous(), h[0]);
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekNext(), h[0]);
     // i.peekNext()= 1.0; // compiler error, i is const
     QCOMPARE(i.next(), h[0]);
     QCOMPARE(i.peekNext(), h[1]);
     QCOMPARE(i.next(), h[1]);
     QCOMPARE(i.next(), h[2]);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), h[0]);
 }//t_qhullHyperplane_iterator
 
 void QhullHyperplane_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube, "");
         QhullHyperplane h= q.firstFacet().hyperplane();
         ostringstream os;
         os << "Hyperplane:\n";
         os << h;
         os << "Hyperplane w/ runId:\n";
         os << h.print();
         os << h.print(" and a message ", " offset ");
         cout << os.str();
         QString s= QString::fromStdString(os.str());
         QCOMPARE(s.count("1"), 3);
         // QCOMPARE(s.count(QRegExp("f\\d")), 3*7 + 13*3*2);
     }
 }//t_io
 
 
 }//orgQhull
 
 #include "moc/QhullHyperplane_test.moc"
diff --git a/src/qhullrtest/QhullLinkedList_test.cpp b/src/qhullptest/QhullLinkedList_test.cpp
similarity index 97%
rename from src/qhullrtest/QhullLinkedList_test.cpp
rename to src/qhullptest/QhullLinkedList_test.cpp
index 512b138..ce93b88 100644
--- a/src/qhullrtest/QhullLinkedList_test.cpp
+++ b/src/qhullptest/QhullLinkedList_test.cpp
@@ -1,330 +1,330 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullLinkedList_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullLinkedList_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <QtCore/QList>
 #include "RoadTest.h"
 
 #include "QhullLinkedList.h"
 #include "Qhull.h"
 
 namespace orgQhull {
 
 class QhullLinkedList_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_element();
     void t_search();
     void t_iterator();
     void t_const_iterator();
     void t_QhullLinkedList_iterator();
     void t_io();
 };//QhullLinkedList_test
 
 void
 add_QhullLinkedList_test()
 {
     new QhullLinkedList_test();
 }
 
 //Executed after each testcase
 void QhullLinkedList_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullLinkedList_test::
 t_construct()
 {
     // QhullLinkedList vs; //private (compiler error).  No memory allocation
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QCOMPARE(q.facetCount(), 12);
         QhullVertexList vs = QhullVertexList(q.beginVertex(), q.endVertex());
         QCOMPARE(vs.count(), 8);
         QCOMPARE(vs.size(), 8u);
         QVERIFY(!vs.isEmpty());
         QhullVertexList vs2 = q.vertexList();
         QCOMPARE(vs2.count(), 8);
         QCOMPARE(vs2.size(),8u);
         QVERIFY(!vs2.isEmpty());
         QVERIFY(!vs2.empty());
         QVERIFY(vs==vs2);
         // vs= vs2; // disabled.  Would not copy the vertices
         QhullVertexList vs3= vs2; // copy constructor
         QVERIFY(vs3==vs2);
     }
 }//t_construct
 
 void QhullLinkedList_test::
 t_convert()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QCOMPARE(q.facetCount(), 12);
         QhullVertexList vs = q.vertexList();
         QCOMPARE(vs.size(), 8u);
         QVERIFY(!vs.isEmpty());
         QVERIFY(!vs.empty());
         std::vector<QhullVertex> vs2= vs.toStdVector();
         QCOMPARE(vs2.size(), vs.size());
         QhullVertexList::Iterator i= vs.begin();
         for(int k= 0; k<(int)vs2.size(); k++){
             QCOMPARE(vs2[k], *i++);
         }
         QList<QhullVertex> vs3= vs.toQList();
         QCOMPARE(vs3.count(), vs.count());
         i= vs.begin();
         for(int k= 0; k<vs3.count(); k++){
             QCOMPARE(vs3[k], *i++);
         }
         QhullVertexList vs4(q.endVertex(), q.endVertex());
         QVERIFY(vs4.isEmpty());
         QVERIFY(vs==vs);
         QVERIFY(vs4==vs4);
         QVERIFY(vs!=vs4);
     }
 }//t_convert
 
 //ReadOnly tested by t_convert
 
 void QhullLinkedList_test::
 t_element()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullVertexList vs = q.vertexList();
     QhullVertex v= vs.first();
     QCOMPARE(v.previous(), QhullVertex(NULL));
     QCOMPARE(vs.front(), vs.first());
     QhullVertex v2= vs.last();
     QCOMPARE(v2.next().next(), QhullVertex(NULL)); // sentinel has NULL next
     QCOMPARE(vs.back(), vs.last());
 }//t_element
 
 void QhullLinkedList_test::
 t_search()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullVertexList vs = q.vertexList();
     QhullVertex v;
     QVERIFY(!vs.contains(v));
     QCOMPARE(vs.count(v), 0);
     QhullVertex v2= *vs.begin();
     QhullVertex v3= vs.last();
     QVERIFY(vs.contains(v2));
     QCOMPARE(vs.count(v2), 1);
     QVERIFY(vs.contains(v3));
     QCOMPARE(vs.count(v3), 1);
 }//t_search
 
 void QhullLinkedList_test::
 t_iterator()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullVertexList vs = q.vertexList();
         QhullVertexList::Iterator i= vs.begin();
         QhullVertexList::iterator i2= vs.begin();
         QVERIFY(i==i2);
         // No comparisons
         i= vs.begin();
         QVERIFY(i==i2);
         i2= vs.end();
         QVERIFY(i!=i2);
         QhullVertex v3(*i);
         i2--;
         QhullVertex v8= *i2;
         QhullVertex v= vs.first();
         QhullVertex v2= v.next();
         QCOMPARE(v3.id(), v.id());
         QCOMPARE(v8.id(), vs.last().id());
         QhullVertexList::Iterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3).id(), v2.id());
         QVERIFY(i==i);
         QVERIFY(i!=i2);
 
         QhullVertexList::ConstIterator i4= vs.begin();
         QVERIFY(i==i4); // iterator COMP const_iterator
         QVERIFY(i4==i); // const_iterator COMP iterator
         QVERIFY(i2!=i4);
         QVERIFY(i4!=i2);
         ++i4;
 
         i= vs.begin();
         i2= vs.begin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, v2);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, vs.begin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2 += 8, vs.end());
         QCOMPARE(i2 -= 8, vs.begin());
         QCOMPARE(i2+0, vs.begin());
         QCOMPARE(i2+8, vs.end());
         i2 += 8;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-8;
         QCOMPARE(i, vs.begin());
 
         //vs.begin end tested above
 
         // QhullVertexList is const-only
     }
 }//t_iterator
 
 void QhullLinkedList_test::
 t_const_iterator()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullVertexList vs = q.vertexList();
         QhullVertexList::ConstIterator i= vs.begin();
         QhullVertexList::const_iterator i2= vs.begin();
         QVERIFY(i==i2);
         i= vs.begin();
         QVERIFY(i==i2);
         i2= vs.end();
         QVERIFY(i!=i2);
         QhullVertex v3(*i);
         i2--;
         QhullVertex v8= *i2;
         QhullVertex v= vs.first();
         QhullVertex v2= v.next();
         QCOMPARE(v3.id(), v.id());
         QCOMPARE(v8.id(), vs.last().id());
         QhullVertexList::ConstIterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3).id(), v2.id());
         QVERIFY(i==i);
         QVERIFY(i!=i2);
 
         // See t_iterator for const_iterator COMP iterator
 
         i= vs.begin();
         i2= vs.constBegin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, v2);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, vs.constBegin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2 += 8, vs.constEnd());
         QCOMPARE(i2 -= 8, vs.constBegin());
         QCOMPARE(i2+0, vs.constBegin());
         QCOMPARE(i2+8, vs.constEnd());
         i2 += 8;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-8;
         QCOMPARE(i, vs.constBegin());
 
         // QhullVertexList is const-only
     }
 }//t_const_iterator
 
 void QhullLinkedList_test::
 t_QhullLinkedList_iterator()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullVertexList vs(q.endVertex(), q.endVertex());
     QhullVertexListIterator i= vs;
     QCOMPARE(vs.count(), 0);
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     QhullVertexList vs2 = q.vertexList();
     QhullVertexListIterator i2(vs2);
     QCOMPARE(vs2.count(), 8);
     i= vs2;
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i2.toBack();
     i.toFront();
     QVERIFY(!i2.hasNext());
     QVERIFY(i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     // i at front, i2 at end/back, 4 neighbors
     QhullVertexList vs3 = q.vertexList(); // same as vs2
     QhullVertex v3(vs3.first());
     QhullVertex v4= vs3.first();
     QCOMPARE(v3, v4);
     QVERIFY(v3==v4);
     QhullVertex v5(v4.next());
     QVERIFY(v4!=v5);
     QhullVertex v6(v5.next());
     QhullVertex v7(v6.next());
     QhullVertex v8(vs3.last());
     QCOMPARE(i2.peekPrevious(), v8);
     i2.previous();
     i2.previous();
     i2.previous();
     i2.previous();
     QCOMPARE(i2.previous(), v7);
     QCOMPARE(i2.previous(), v6);
     QCOMPARE(i2.previous(), v5);
     QCOMPARE(i2.previous(), v4);
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekNext(), v4);
     // i.peekNext()= 1.0; // compiler error
     QCOMPARE(i.next(), v4);
     QCOMPARE(i.peekNext(), v5);
     QCOMPARE(i.next(), v5);
     QCOMPARE(i.next(), v6);
     QCOMPARE(i.next(), v7);
     i.next();
     i.next();
     i.next();
     QCOMPARE(i.next(), v8);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), v4);
 }//t_QhullLinkedList_iterator
 
 void QhullLinkedList_test::
 t_io()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullVertexList vs(q.endVertex(), q.endVertex());
     std::cout << "INFO:     empty QhullVertextList" << vs << std::endl;
     QhullVertexList vs2= q.vertexList();
     std::cout << "INFO:   " << vs2 << std::endl;
 }//t_io
 
 }//namespace orgQhull
 
 #include "moc/QhullLinkedList_test.moc"
diff --git a/src/qhullrtest/QhullPointSet_test.cpp b/src/qhullptest/QhullPointSet_test.cpp
similarity index 98%
rename from src/qhullrtest/QhullPointSet_test.cpp
rename to src/qhullptest/QhullPointSet_test.cpp
index 6f23fdb..7384da5 100644
--- a/src/qhullrtest/QhullPointSet_test.cpp
+++ b/src/qhullptest/QhullPointSet_test.cpp
@@ -1,370 +1,370 @@
 /****************************************************************************
 **
-** Copyright (p) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullPointSet_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (p) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullPointSet_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled header
 #include <iostream>
 #include "RoadTest.h" // QT_VERSION
 
 #include "QhullPointSet.h"
 #include "RboxPoints.h"
 #include "QhullPoint.h"
 #include "QhullFacet.h"
 #include "QhullFacetList.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 
 namespace orgQhull {
 
 class QhullPointSet_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_element();
     void t_iterator();
     void t_const_iterator();
     void t_search();
     void t_pointset_iterator();
     void t_io();
 };//QhullPointSet_test
 
 void
 add_QhullPointSet_test()
 {
     new QhullPointSet_test();
 }
 
 //Executed after each testcase
 void QhullPointSet_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullPointSet_test::
 t_construct()
 {
     RboxPoints rcube("c W0 1000");
     Qhull q(rcube,"Qc");  // cube with 1000 coplanar points
     int coplanarCount= 0;
     foreach(QhullFacet f, q.facetList()){
         QhullPointSet ps(q.dimension(), f.getFacetT()->outsideset);
         QCOMPARE(ps.dimension(), 3);
         QVERIFY(ps.isEmpty());
         QVERIFY(ps.empty());
         QCOMPARE(ps.count(), 0);
         QCOMPARE(ps.size(), 0u);
         QhullPointSet ps2(q.dimension(), f.getFacetT()->coplanarset);
         QCOMPARE(ps2.dimension(), 3);
         QVERIFY(!ps2.isEmpty());
         QVERIFY(!ps2.empty());
         coplanarCount += ps2.count();
         QCOMPARE(ps2.count(), (int)ps2.size());
         QhullPointSet ps3(ps2);
         QCOMPARE(ps3.dimension(), 3);
         QVERIFY(!ps3.isEmpty());
         QCOMPARE(ps3.count(), ps2.count());
         QVERIFY(ps3==ps2);
         QVERIFY(ps3!=ps);
         // ps4= ps3; //compiler error
     }
     QCOMPARE(coplanarCount, 1000);
 }//t_construct
 
 void QhullPointSet_test::
 t_convert()
 {
     RboxPoints rcube("c W0 1000");
     Qhull q(rcube,"Qc");  // cube with 1000 coplanar points
     QhullFacet f= q.firstFacet();
     QhullPointSet ps= f.coplanarPoints();
     QCOMPARE(ps.dimension(), 3);
     QVERIFY(ps.count()>=1);   // Sometimes no coplanar points
     std::vector<QhullPoint> vs= ps.toStdVector();
     QCOMPARE(vs.size(), ps.size());
     QhullPoint p= ps[0];
     QhullPoint p2= vs[0];
     QCOMPARE(p, p2);
     QList<QhullPoint> qs= ps.toQList();
     QCOMPARE(qs.size(), static_cast<int>(ps.size()));
     QhullPoint p3= qs[0];
     QCOMPARE(p3, p);
 }//t_convert
 
 // readonly tested in t_construct
 //   dimension, empty, isEmpty, ==, !=, size
 
 void QhullPointSet_test::
 t_element()
 {
     RboxPoints rcube("c W0 1000");
     Qhull q(rcube,"Qc");  // cube with 1000 coplanar points
     QhullFacet f= q.firstFacet();
     QhullPointSet ps= f.coplanarPoints();
     QVERIFY(ps.count()>=3);  // Sometimes no coplanar points
     QhullPoint p= ps[0];
     QCOMPARE(p, ps[0]);
     QhullPoint p2= ps[ps.count()-1];
     QCOMPARE(ps.at(1), ps[1]);
     QCOMPARE(ps.first(), p);
     QCOMPARE(ps.front(), ps.first());
     QCOMPARE(ps.last(), p2);
     QCOMPARE(ps.back(), ps.last());
     QhullPoint p8;
     QCOMPARE(ps.value(2), ps[2]);
     QCOMPARE(ps.value(-1), p8);
     QCOMPARE(ps.value(ps.count()), p8);
     QCOMPARE(ps.value(ps.count(), p), p);
     QVERIFY(ps.value(1, p)!=p);
     QhullPointSet ps8= f.coplanarPoints();
     QhullPointSet::Iterator i= ps8.begin();
     foreach(QhullPoint p9, ps){  // Qt only
         QCOMPARE(p9.dimension(), 3);
         QCOMPARE(p9, *i++);
     }
 }//t_element
 
 void QhullPointSet_test::
 t_iterator()
 {
     RboxPoints rcube("c W0 1000");
     Qhull q(rcube,"Qc");  // cube with 1000 coplanar points
     QhullFacet f= q.firstFacet();
     QhullPointSet ps= f.coplanarPoints();
     QVERIFY(ps.count()>=3);  // Sometimes no coplanar points
     QhullPointSet::Iterator i= ps.begin();
     QhullPointSet::iterator i2= ps.begin();
     QVERIFY(i==i2);
     QVERIFY(i>=i2);
     QVERIFY(i<=i2);
     i= ps.begin();
     QVERIFY(i==i2);
     i2= ps.end();
     QVERIFY(i!=i2);
     QhullPoint p= *i;
     QCOMPARE(p.dimension(), ps.dimension());
     QCOMPARE(p, ps[0]);
     i2--;
     QhullPoint p2= *i2;
     QCOMPARE(p2.dimension(), ps.dimension());
     QCOMPARE(p2, ps.last());
     QhullPointSet::Iterator i5(i2);
     QCOMPARE(*i2, *i5);
     QhullPointSet::Iterator i3= i+1;
     QVERIFY(i!=i3);
     QCOMPARE(i[1], *i3);
     (i3= i)++;
     QCOMPARE((*i3)[0], ps[1][0]);
     QCOMPARE((*i3).dimension(), 3);
 
     QVERIFY(i==i);
     QVERIFY(i!=i3);
     QVERIFY(i<i3);
     QVERIFY(i<=i3);
     QVERIFY(i3>i);
     QVERIFY(i3>=i);
 
     QhullPointSet::ConstIterator i4= ps.begin();
     QVERIFY(i==i4); // iterator COMP const_iterator
     QVERIFY(i<=i4);
     QVERIFY(i>=i4);
     QVERIFY(i4==i); // const_iterator COMP iterator
     QVERIFY(i4<=i);
     QVERIFY(i4>=i);
     QVERIFY(i>=i4);
     QVERIFY(i4<=i);
     QVERIFY(i2!=i4);
     QVERIFY(i2>i4);
     QVERIFY(i2>=i4);
     QVERIFY(i4!=i2);
     QVERIFY(i4<i2);
     QVERIFY(i4<=i2);
     ++i4;
     QVERIFY(i<i4);
     QVERIFY(i<=i4);
     QVERIFY(i4>i);
     QVERIFY(i4>=i);
 
     i= ps.begin();
     i2= ps.begin();
     QCOMPARE(i, i2++);
     QCOMPARE(*i2, ps[1]);
     QCOMPARE(++i, i2);
     QCOMPARE(i, i2--);
     QCOMPARE(i2, ps.begin());
     QCOMPARE(--i, i2);
     QCOMPARE(i2+=ps.count(), ps.end());
     QCOMPARE(i2-=ps.count(), ps.begin());
     QCOMPARE(i2+0, ps.begin());
     QCOMPARE(i2+ps.count(), ps.end());
     i2 += ps.count();
     i= i2-0;
     QCOMPARE(i, i2);
     i= i2-ps.count();
     QCOMPARE(i, ps.begin());
     QCOMPARE(i2-i, ps.count());
 
     //ps.begin end tested above
 
     // QhullPointSet is const-only
 }//t_iterator
 
 void QhullPointSet_test::
 t_const_iterator()
 {
     RboxPoints rcube("c W0 1000");
     Qhull q(rcube,"Qc");  // cube with 1000 coplanar points
     QhullFacet f= q.firstFacet();
     QhullPointSet ps= f.coplanarPoints();
     QVERIFY(ps.count()>=3);  // Sometimes no coplanar points
     QhullPointSet::ConstIterator i= ps.begin();
     QhullPointSet::const_iterator i2= ps.begin();
     QVERIFY(i==i2);
     QVERIFY(i>=i2);
     QVERIFY(i<=i2);
 
     // See t_iterator for const_iterator COMP iterator
 
     i= ps.begin();
     QVERIFY(i==i2);
     i2= ps.end();
     QVERIFY(i!=i2);
     QhullPoint p= *i; // QhullPoint is the base class for QhullPointSet::iterator
     QCOMPARE(p.dimension(), ps.dimension());
     QCOMPARE(p, ps[0]);
     i2--;
     QhullPoint p2= *i2;
     QCOMPARE(p2.dimension(), ps.dimension());
     QCOMPARE(p2, ps.last());
     QhullPointSet::ConstIterator i5(i2);
     QCOMPARE(*i2, *i5);
 
 
     QhullPointSet::ConstIterator i3= i+1;
     QVERIFY(i!=i3);
     QCOMPARE(i[1], *i3);
 
     QVERIFY(i==i);
     QVERIFY(i!=i3);
     QVERIFY(i<i3);
     QVERIFY(i<=i3);
     QVERIFY(i3>i);
     QVERIFY(i3>=i);
 
     // QhullPointSet is const-only
 }//t_const_iterator
 
 
 void QhullPointSet_test::
 t_search()
 {
     RboxPoints rcube("c W0 1000");
     Qhull q(rcube,"Qc");  // cube with 1000 coplanar points
     QhullFacet f= q.firstFacet();
     QhullPointSet ps= f.coplanarPoints();
     QVERIFY(ps.count()>=3);  // Sometimes no coplanar points
     QhullPoint p= ps.first();
     QhullPoint p2= ps.last();
     QVERIFY(ps.contains(p));
     QVERIFY(ps.contains(p2));
     QVERIFY(p!=p2);
     QhullPoint p3= ps[2];
     QVERIFY(ps.contains(p3));
     QVERIFY(p!=p3);
     QhullPoint p4;
     QCOMPARE(ps.indexOf(p), 0);
     QCOMPARE(ps.indexOf(p2), ps.count()-1);
     QCOMPARE(ps.indexOf(p3), 2);
     QCOMPARE(ps.indexOf(p4), -1);
     QCOMPARE(ps.lastIndexOf(p), 0);
     QCOMPARE(ps.lastIndexOf(p2), ps.count()-1);
     QCOMPARE(ps.lastIndexOf(p3), 2);
     QCOMPARE(ps.lastIndexOf(p4), -1);
 }//t_search
 
 void QhullPointSet_test::
 t_pointset_iterator()
 {
     RboxPoints rcube("c W0 1000");
     Qhull q(rcube,"Qc");  // cube with 1000 coplanar points
     QhullFacet f= q.firstFacet();
     QhullPointSet ps2= f.outsidePoints();
     QVERIFY(ps2.count()==0); // No outside points after constructing the convex hull
     QhullPointSetIterator i2= ps2;
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     i2.toBack();
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
 
     QhullPointSet ps= f.coplanarPoints();
     QVERIFY(ps.count()>=3);  // Sometimes no coplanar points
     QhullPointSetIterator i(ps);
     i2= ps;
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i2.toBack();
     i.toFront();
     QVERIFY(!i2.hasNext());
     QVERIFY(i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     QhullPoint p= ps[0];
     QhullPoint p2(ps[0]);
     QCOMPARE(p, p2);
     QVERIFY(p==p2);
     QhullPoint p3(ps.last());
  // p2[0]= 0.0;
     QVERIFY(p==p2);
     QCOMPARE(i2.peekPrevious(), p3);
     QCOMPARE(i2.previous(), p3);
     QCOMPARE(i2.previous(), ps[ps.count()-2]);
     QVERIFY(i2.hasPrevious());
     QCOMPARE(i.peekNext(), p);
     // i.peekNext()= 1.0; // compiler error
     QCOMPARE(i.next(), p);
     QhullPoint p4= i.peekNext();
     QVERIFY(p4!=p3);
     QCOMPARE(i.next(), p4);
     QVERIFY(i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), p);
 }//t_pointset_iterator
 
 void QhullPointSet_test::
 t_io()
 {
     ostringstream os;
     RboxPoints rcube("c W0 120");
     Qhull q(rcube,"Qc");  // cube with 100 coplanar points
     QhullFacet f= q.firstFacet();
     QhullPointSet ps= f.coplanarPoints();
     QVERIFY(ps.count()>=3);  // Sometimes no coplanar points
     os << "QhullPointSet from coplanarPoints\n" << ps << endl;
     os << "\nRunId\n" << ps.print(q.runId());
     os << ps.print(q.runId(), "\nRunId w/ message\n");
     cout << os.str();
     QString s= QString::fromStdString(os.str());
     QCOMPARE(s.count("p"), 3*ps.count()+1);
     // QCOMPARE(s.count(QRegExp("f\\d")), 3*7 + 13*3*2);
 }//t_io
 
 }//orgQhull
 
 #include "moc/QhullPointSet_test.moc"
diff --git a/src/qhullrtest/QhullPoint_test.cpp b/src/qhullptest/QhullPoint_test.cpp
similarity index 98%
rename from src/qhullrtest/QhullPoint_test.cpp
rename to src/qhullptest/QhullPoint_test.cpp
index 5046170..7afc070 100644
--- a/src/qhullrtest/QhullPoint_test.cpp
+++ b/src/qhullptest/QhullPoint_test.cpp
@@ -1,397 +1,397 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullPoint_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullPoint_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h"
 
 #include "QhullPoint.h"
 #include "Coordinates.h"
 #include "RboxPoints.h"
 #include "QhullError.h"
 #include "QhullFacet.h"
 #include "QhullPoint.h"
 #include "Qhull.h"
 
 #include <numeric>
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullPoint_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_readonly();
     void t_define();
     void t_operator();
     void t_iterator();
     void t_const_iterator();
     void t_qhullpoint_iterator();
     void t_io();
 };//QhullPoint_test
 
 void
 add_QhullPoint_test()
 {
     new QhullPoint_test();
 }
 
 //Executed after each test
 void QhullPoint_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullPoint_test::
 t_construct()
 {
     // Qhull.runQhull() constructs QhullFacets as facetT
     QhullPoint p;
     QVERIFY(!p.isDefined());
     QCOMPARE(p.dimension(),0);
     QCOMPARE(p.coordinates(),static_cast<double *>(0));
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullVertex v2(q.beginVertex());
     QhullPoint p2(v2.point());
     QVERIFY(p2.isDefined());
     QCOMPARE(p2.dimension(),3);
     // p= p2;  // copy assignment disabled, ambiguous
     QhullPoint p3(p2.dimension(), p2.coordinates());
     QCOMPARE(p2, p3);
     Coordinates c;
     c << 0.0 << 0.0 << 0.0;
     QhullPoint p6(c);
     QCOMPARE(p6, q.origin());
     QhullPoint p5= p2; // copy constructor
     QVERIFY(p5==p2);
 }//t_construct
 
 void QhullPoint_test::
 t_convert()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullVertex v= q.firstVertex();
     QhullPoint p= v.point();
     std::vector<double> vs= p.toStdVector();
     QCOMPARE(vs.size(), 3u);
     for(int k=3; k--; ){
         QCOMPARE(vs[k], p[k]);
     }
     QList<double> qs= p.toQList();
     QCOMPARE(qs.size(), 3);
     for(int k=3; k--; ){
         QCOMPARE(qs[k], p[k]);
     }
 }//t_convert
 
 void QhullPoint_test::
 t_readonly()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QhullVertexList vs= q.vertexList();
         QhullVertexListIterator i(vs);
         while(i.hasNext()){
             QhullPoint p= i.next().point();
             int id= p.id(q.runId());
             cout << "p" << id << endl;
             QVERIFY(p.isDefined());
             QCOMPARE(p.dimension(),3);
             QCOMPARE(id, p.id());
             QVERIFY(p.id()>=0 && p.id()<9);
             const coordT *c= p.coordinates();
             coordT *c2= p.coordinates();
             QCOMPARE(c, c2);
             QCOMPARE(p.dimension(), 3);
         }
         QhullPoint p2= vs.first().point();
         QhullPoint p3= vs.last().point();
         QVERIFY(p2!=p3);
         QVERIFY(p3.coordinates()!=p2.coordinates());
     }
 }//t_readonly
 
 void QhullPoint_test::
 t_define()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QhullVertexList vs= q.vertexList();
         QhullPoint p= vs.first().point();
         QhullPoint p2= p;
         QVERIFY(p==p2);
         QhullPoint p3= vs.last().point();
         QVERIFY(p2!=p3);
         int idx= (p3.coordinates()-p2.coordinates())/p2.dimension();
         QVERIFY(idx>-8 && idx<8);
         p2.advancePoint(idx);
         QVERIFY(p2==p3);
         p2.advancePoint(-idx);
         QVERIFY(p2==p);
         p2.advancePoint(0);
         QVERIFY(p2==p);
 
         QhullPoint p4= p3;
         p4.defineAs(p2);
         QVERIFY(p2==p4);
         QhullPoint p5= p3;
         p5.defineAs(p2.dimension(), p2.coordinates());
         QVERIFY(p2==p5);
         QhullPoint p6= p3;
         p6.setCoordinates(p2.coordinates());
         QCOMPARE(p2.coordinates(), p6.coordinates());
         QVERIFY(p2==p6);
         p6.setDimension(2);
         QCOMPARE(p6.dimension(), 2);
         QVERIFY(p2!=p6);
     }
 }//t_define
 
 void QhullPoint_test::
 t_operator()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     const QhullPoint p= q.firstVertex().point();
     //operator== and operator!= tested elsewhere
     const coordT *c= p.coordinates();
     for(int k=p.dimension(); k--; ){
         QCOMPARE(c[k], p[k]);
     }
     //p[0]= 10.0; // compiler error, const
     QhullPoint p2= q.firstVertex().point();
     p2[0]= 10.0;  // Overwrites point coordinate
     QCOMPARE(p2[0], 10.0);
 }//t_operator
 
 void QhullPoint_test::
 t_iterator()
 {
     RboxPoints rcube("c");
     {
         QhullPoint p2;
         QCOMPARE(p2.begin(), p2.end());
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullPoint p= q.firstVertex().point();
         QhullPoint::Iterator i= p.begin();
         QhullPoint::iterator i2= p.begin();
         QVERIFY(i==i2);
         QVERIFY(i>=i2);
         QVERIFY(i<=i2);
         i= p.begin();
         QVERIFY(i==i2);
         i2= p.end();
         QVERIFY(i!=i2);
         double d3= *i;
         i2--;
         double d2= *i2;
         QCOMPARE(d3, p[0]);
         QCOMPARE(d2, p[2]);
         QhullPoint::Iterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3), p[1]);
         QVERIFY(i==i);
         QVERIFY(i!=i2);
         QVERIFY(i<i2);
         QVERIFY(i<=i2);
         QVERIFY(i2>i);
         QVERIFY(i2>=i);
 
         QhullPoint::ConstIterator i4= p.begin();
         QVERIFY(i==i4); // iterator COMP const_iterator
         QVERIFY(i<=i4);
         QVERIFY(i>=i4);
         QVERIFY(i4==i); // const_iterator COMP iterator
         QVERIFY(i4<=i);
         QVERIFY(i4>=i);
         QVERIFY(i>=i4);
         QVERIFY(i4<=i);
         QVERIFY(i2!=i4);
         QVERIFY(i2>i4);
         QVERIFY(i2>=i4);
         QVERIFY(i4!=i2);
         QVERIFY(i4<i2);
         QVERIFY(i4<=i2);
         ++i4;
         QVERIFY(i<i4);
         QVERIFY(i<=i4);
         QVERIFY(i4>i);
         QVERIFY(i4>=i);
 
         i= p.begin();
         i2= p.begin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, p[1]);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, p.begin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2 += 3, p.end());
         QCOMPARE(i2 -= 3, p.begin());
         QCOMPARE(i2+0, p.begin());
         QCOMPARE(i2+3, p.end());
         i2 += 3;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-3;
         QCOMPARE(i, p.begin());
         QCOMPARE(i2-i, 3);
 
         //p.begin end tested above
 
         // QhullPoint is const-only
     }
 }//t_iterator
 
 void QhullPoint_test::
 t_const_iterator()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullPoint p= q.firstVertex().point();
         QhullPoint::ConstIterator i= p.begin();
         QhullPoint::const_iterator i2= p.begin();
         QVERIFY(i==i2);
         QVERIFY(i>=i2);
         QVERIFY(i<=i2);
         i= p.begin();
         QVERIFY(i==i2);
         i2= p.end();
         QVERIFY(i!=i2);
         double d3= *i;
         i2--;
         double d2= *i2;
         QCOMPARE(d3, p[0]);
         QCOMPARE(d2, p[2]);
         QhullPoint::ConstIterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3), p[1]);
         QVERIFY(i==i);
         QVERIFY(i!=i2);
         QVERIFY(i<i2);
         QVERIFY(i<=i2);
         QVERIFY(i2>i);
         QVERIFY(i2>=i);
 
         // See t_iterator for const_iterator COMP iterator
 
         i= p.begin();
         i2= p.constBegin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, p[1]);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, p.constBegin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2+=3, p.constEnd());
         QCOMPARE(i2-=3, p.constBegin());
         QCOMPARE(i2+0, p.constBegin());
         QCOMPARE(i2+3, p.constEnd());
         i2 += 3;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-3;
         QCOMPARE(i, p.constBegin());
         QCOMPARE(i2-i, 3);
 
         // QhullPoint is const-only
     }
 }//t_const_iterator
 
 void QhullPoint_test::
 t_qhullpoint_iterator()
 {
     QhullPoint p2;
     QhullPointIterator i= p2;
     QCOMPARE(p2.dimension(), 0);
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullPoint p = q.firstVertex().point();
     QhullPointIterator i2(p);
     QCOMPARE(p.dimension(), 3);
     i= p;
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i2.toBack();
     i.toFront();
     QVERIFY(!i2.hasNext());
     QVERIFY(i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     // i at front, i2 at end/back, 3 coordinates
     QCOMPARE(i.peekNext(), p[0]);
     QCOMPARE(i2.peekPrevious(), p[2]);
     QCOMPARE(i2.previous(), p[2]);
     QCOMPARE(i2.previous(), p[1]);
     QCOMPARE(i2.previous(), p[0]);
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekNext(), p[0]);
     // i.peekNext()= 1.0; // compiler error, i is const
     QCOMPARE(i.next(), p[0]);
     QCOMPARE(i.peekNext(), p[1]);
     QCOMPARE(i.next(), p[1]);
     QCOMPARE(i.next(), p[2]);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), p[0]);
 }//t_qhullpoint_iterator
 
 void QhullPoint_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube, "");
         QhullPoint p= q.beginVertex().point();
         ostringstream os;
         os << "Point w/o runId:\n";
         os << p;
         os << "Point w/ runId:\n";
         os << p.print(q.runId()) << p.print(q.runId(), " and a message ");
         os << p.printWithIdentifier(q.runId(), " Point with id and a message ");
         cout << os.str();
         QString s= QString::fromStdString(os.str());
         QCOMPARE(s.count("p"), 3);
         // QCOMPARE(s.count(QRegExp("f\\d")), 3*7 + 13*3*2);
     }
 }//t_io
 
 }//orgQhull
 
 #include "moc/QhullPoint_test.moc"
diff --git a/src/qhullrtest/QhullPoints_test.cpp b/src/qhullptest/QhullPoints_test.cpp
similarity index 98%
rename from src/qhullrtest/QhullPoints_test.cpp
rename to src/qhullptest/QhullPoints_test.cpp
index 721a9cc..ba12ff5 100644
--- a/src/qhullrtest/QhullPoints_test.cpp
+++ b/src/qhullptest/QhullPoints_test.cpp
@@ -1,481 +1,481 @@
 /****************************************************************************
 **
-** Copyright (p) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullPoints_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (p) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullPoints_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled header
 #include <iostream>
 #include "RoadTest.h" // QT_VERSION
 
 #include "QhullPoints.h"
 #include "RboxPoints.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 
 namespace orgQhull {
 
 class QhullPoints_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_getset();
     void t_element();
     void t_iterator();
     void t_const_iterator();
     void t_search();
     void t_points_iterator();
     void t_io();
 };//QhullPoints_test
 
 void
 add_QhullPoints_test()
 {
     new QhullPoints_test();
 }
 
 //Executed after each testcase
 void QhullPoints_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullPoints_test::
 t_construct()
 {
     QhullPoints ps;
     QCOMPARE(ps.dimension(), 0);
     QVERIFY(ps.isEmpty());
     QVERIFY(ps.empty());
     QCOMPARE(ps.count(), 0);
     QCOMPARE(ps.size(), 0u);
     QCOMPARE(ps.coordinateCount(), 0);
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     QhullPoints ps2;
     ps2.defineAs(2, 6, c);
     QCOMPARE(ps2.dimension(), 2);
     QVERIFY(!ps2.isEmpty());
     QVERIFY(!ps2.empty());
     QCOMPARE(ps2.count(), 3);
     QCOMPARE(ps2.size(), 3u);
     QCOMPARE(ps2.coordinates(), c);
     QhullPoints ps7(3);
     QCOMPARE(ps7.dimension(), 3);
     QVERIFY(ps7.isEmpty());
     QhullPoints ps3(2, 6, c);
     QCOMPARE(ps3.dimension(), 2);
     QVERIFY(!ps3.isEmpty());
     QCOMPARE(ps3.coordinates(), ps2.coordinates());
     QVERIFY(ps3==ps2);
     QVERIFY(ps3!=ps);
     QhullPoints ps4= ps3;
     QVERIFY(ps4==ps3);
     // ps4= ps3; //compiler error
     QhullPoints ps5(ps4);
     QVERIFY(ps5==ps4);
     QVERIFY(!(ps5!=ps4));
     coordT c2[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     QhullPoints ps6(2, 6, c2);
     QVERIFY(ps6==ps2);
 }//t_construct
 
 void QhullPoints_test::
 t_convert()
 {
     //defineAs tested above
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     QhullPoints ps(3, 6, c);
     QCOMPARE(ps.dimension(), 3);
     QCOMPARE(ps.size(), 2u);
     const coordT *c2= ps.constData();
     QCOMPARE(c, c2);
     const coordT *c3= ps.data();
     QCOMPARE(c, c3);
     coordT *c4= ps.data();
     QCOMPARE(c, c4);
     std::vector<QhullPoint> vs= ps.toStdVector();
     QCOMPARE(vs.size(), 2u);
     QhullPoint p= vs[1];
     QCOMPARE(p[2], 5.0);
     QList<QhullPoint> qs= ps.toQList();
     QCOMPARE(qs.size(), 2);
     QhullPoint p2= qs[1];
     QCOMPARE(p2[2], 5.0);
 }//t_convert
 
 void QhullPoints_test::
 t_getset()
 {
     //See t_construct for coordinates, count, defineAs, dimension, empty, isempty, ==, !=, size
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     QhullPoints ps(3, 6, c);
     QhullPoints ps2(3, 6, c);
     QCOMPARE(ps2.dimension(), 3);
     QCOMPARE(ps2.coordinates(), c);
     QCOMPARE(ps2.count(), 2);
     QCOMPARE(ps2.coordinateCount(), 6);
     coordT c2[]= {-1.0, -2.0, -3.0, -4.0, -5.0, -6.0};
     ps2.defineAs(6, c2);
     QCOMPARE(ps2.coordinates(), c2);
     QCOMPARE(ps2.count(), 2);
     QCOMPARE(ps2.size(), 2u);
     QCOMPARE(ps2.dimension(), 3);
     QVERIFY(!ps2.isEmpty());
     QVERIFY(ps!=ps2);
     // ps2= ps; // assignment not available, compiler error
     ps2.defineAs(ps);
     QVERIFY(ps==ps2);
     ps2.setDimension(2);
     QCOMPARE(ps2.dimension(), 2);
     QCOMPARE(ps2.coordinates(), c);
     QVERIFY(!ps2.isEmpty());
     QCOMPARE(ps2.count(), 3);
     QCOMPARE(ps2.size(), 3u);
     QVERIFY(ps!=ps2);
     QhullPoints ps3(3);
     ps3.defineAs(5, c2);
     QCOMPARE(ps3.count(), 1);
     QCOMPARE(ps3.extraCoordinatesCount(), 2);
     QCOMPARE(ps3.extraCoordinates()[0], -4.0);
     QVERIFY(ps3.includesCoordinates(ps3.data()));
     QVERIFY(ps3.includesCoordinates(ps3.data()+ps3.count()-1));
     QVERIFY(!ps3.includesCoordinates(ps3.data()-1));
     QVERIFY(!ps3.includesCoordinates(ps3.data()+ps3.coordinateCount()));
 }//t_getset
 
 
 void QhullPoints_test::
 t_element()
 {
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     QhullPoints ps(2, 6, c);
     QhullPoint p(2, c);
     QCOMPARE(ps[0], p);
     QCOMPARE(ps.at(1), ps[1]);
     QCOMPARE(ps.first(), p);
     QCOMPARE(ps.front(), ps.first());
     QCOMPARE(ps.last(), ps.at(2));
     QCOMPARE(ps.back(), ps.last());
     QhullPoints ps2= ps.mid(2);
     QCOMPARE(ps2.count(), 1);
     QhullPoints ps3= ps.mid(3);
     QVERIFY(ps3.isEmpty());
     QVERIFY(ps3.empty());
     QhullPoints ps4= ps.mid(10);
     QVERIFY(ps4.isEmpty());
     QhullPoints ps5= ps.mid(-1);
     QVERIFY(ps5.isEmpty());
     QhullPoints ps6= ps.mid(1, 1);
     QCOMPARE(ps6.count(), 1);
     QCOMPARE(ps6[0], ps[1]);
     QhullPoints ps7= ps.mid(1, 10);
     QCOMPARE(ps7.count(), 2);
     QCOMPARE(ps7[1], ps[2]);
     QhullPoint p8;
     QCOMPARE(ps.value(2), ps[2]);
     QCOMPARE(ps.value(-1), p8);
     QCOMPARE(ps.value(3), p8);
     QCOMPARE(ps.value(3, p), p);
     QVERIFY(ps.value(1, p)!=p);
     foreach(QhullPoint p9, ps){  // Qt only
         QCOMPARE(p9.dimension(), 2);
         QVERIFY(p9[0]==0.0 || p9[0]==2.0 || p9[0]==4.0);
     }
 }//t_element
 
 void QhullPoints_test::
 t_iterator()
 {
     coordT c[]= {0.0, 1.0, 2.0};
     QhullPoints ps(1, 3, c);
     QhullPoints::Iterator i(ps);
     QhullPoints::iterator i2= ps.begin();
     QVERIFY(i==i2);
     QVERIFY(i>=i2);
     QVERIFY(i<=i2);
     i= ps.begin();
     QVERIFY(i==i2);
     i2= ps.end();
     QVERIFY(i!=i2);
     QhullPoint p(i); // QhullPoint is the base class for QhullPoints::iterator
     QCOMPARE(p.dimension(), ps.dimension());
     QCOMPARE(p.coordinates(), ps.coordinates());
     i2--;
     QhullPoint p2= *i2;
     QCOMPARE(p[0], 0.0);
     QCOMPARE(p2[0], 2.0);
     QhullPoints::Iterator i5(i2);
     QCOMPARE(*i2, *i5);
     coordT c3[]= {0.0, -1.0, -2.0};
     QhullPoints::Iterator i3(1, c3);
     QVERIFY(i!=i3);
     QCOMPARE(*i, *i3);
 
     (i3= i)++;
     QCOMPARE((*i3)[0], 1.0);
     QCOMPARE(i3->dimension(), 1);
     QCOMPARE(i3[0][0], 1.0);
     QCOMPARE(i3[0], ps[1]);
 
     QVERIFY(i==i);
     QVERIFY(i!=i2);
     QVERIFY(i<i2);
     QVERIFY(i<=i2);
     QVERIFY(i2>i);
     QVERIFY(i2>=i);
 
     QhullPoints::ConstIterator i4(1, c);
     QVERIFY(i==i4); // iterator COMP const_iterator
     QVERIFY(i<=i4);
     QVERIFY(i>=i4);
     QVERIFY(i4==i); // const_iterator COMP iterator
     QVERIFY(i4<=i);
     QVERIFY(i4>=i);
     QVERIFY(i>=i4);
     QVERIFY(i4<=i);
     QVERIFY(i2!=i4);
     QVERIFY(i2>i4);
     QVERIFY(i2>=i4);
     QVERIFY(i4!=i2);
     QVERIFY(i4<i2);
     QVERIFY(i4<=i2);
     ++i4;
     QVERIFY(i<i4);
     QVERIFY(i<=i4);
     QVERIFY(i4>i);
     QVERIFY(i4>=i);
 
     i= ps.begin();
     i2= ps.begin();
     QCOMPARE(i, i2++);
     QCOMPARE(*i2, ps[1]);
     QCOMPARE(++i, i2);
     QCOMPARE(i, i2--);
     QCOMPARE(i2, ps.begin());
     QCOMPARE(--i, i2);
     QCOMPARE(i2+=3, ps.end());
     QCOMPARE(i2-=3, ps.begin());
     QCOMPARE(i2+0, ps.begin());
     QCOMPARE(i2+3, ps.end());
     i2 += 3;
     i= i2-0;
     QCOMPARE(i, i2);
     i= i2-3;
     QCOMPARE(i, ps.begin());
     QCOMPARE(i2-i, 3);
 
     //ps.begin end tested above
 
     // QhullPoints is const-only
 }//t_iterator
 
 void QhullPoints_test::
 t_const_iterator()
 {
     coordT c[]= {0.0, 1.0, 2.0};
     const QhullPoints ps(1, 3, c);
     QhullPoints::ConstIterator i(ps);
     QhullPoints::const_iterator i2= ps.begin();
     QVERIFY(i==i2);
     QVERIFY(i>=i2);
     QVERIFY(i<=i2);
     i= ps.begin();
     QVERIFY(i==i2);
     i2= ps.end();
     QVERIFY(i!=i2);
     QhullPoint p(i);
     QCOMPARE(p.dimension(), ps.dimension());
     QCOMPARE(p.coordinates(), ps.coordinates());
     i2--;
     QhullPoint p2= *i2;
     QCOMPARE(p[0], 0.0);
     QCOMPARE(p2[0], 2.0);
     QhullPoints::ConstIterator i5(i2);
     QCOMPARE(*i2, *i5);
     coordT c3[]= {0.0, -1.0, -2.0};
     QhullPoints::ConstIterator i3(1, c3);
     QVERIFY(i!=i3);
     QCOMPARE(*i, *i3);
 
     (i3= i)++;
     QCOMPARE((*i3)[0], 1.0);
     QCOMPARE(i3->dimension(), 1);
     QCOMPARE(i3[0][0], 1.0);
     QCOMPARE(i3[0][0], 1.0);
     QCOMPARE(i3[0], ps[1]);
 
     QVERIFY(i==i);
     QVERIFY(i!=i2);
     QVERIFY(i<i2);
     QVERIFY(i<=i2);
     QVERIFY(i2>i);
     QVERIFY(i2>=i);
 
     // See t_iterator for const_iterator COMP iterator
 
     i= ps.begin();
     i2= ps.constBegin();
     QCOMPARE(i, i2++);
     QCOMPARE(*i2, ps[1]);
     QCOMPARE(++i, i2);
     QCOMPARE(i, i2--);
     QCOMPARE(i2, ps.constBegin());
     QCOMPARE(--i, i2);
     QCOMPARE(i2+=3, ps.constEnd());
     QCOMPARE(i2-=3, ps.constBegin());
     QCOMPARE(i2+0, ps.constBegin());
     QCOMPARE(i2+3, ps.constEnd());
     i2 += 3;
     i= i2-0;
     QCOMPARE(i, i2);
     i= i2-3;
     QCOMPARE(i, ps.constBegin());
     QCOMPARE(i2-i, 3);
 
     // QhullPoints is const-only
 }//t_const_iterator
 
 
 void QhullPoints_test::
 t_search()
 {
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 0, 1};
     QhullPoints ps(2, 8, c); //2-d array of 4 points
     QhullPoint p= ps.first();
     QhullPoint p2= ps.last();
     QVERIFY(ps.contains(p));
     QVERIFY(ps.contains(p2));
     QVERIFY(p==p2);
     QhullPoint p5= ps[2];
     QVERIFY(p!=p5);
     QVERIFY(ps.contains(p5));
     coordT c2[]= {0.0, 1.0, 2.0, 3.0};
     QhullPoint p3(2, c2); //2-d point
     QVERIFY(ps.contains(p3));
     QhullPoint p4(3, c2); //3-d point
     QVERIFY(!ps.contains(p4));
     p4.defineAs(2, c); //2-d point
     QVERIFY(ps.contains(p4));
     p4.defineAs(2, c+1); //2-d point
     QVERIFY(!ps.contains(p4));
     QhullPoint p6(2, c2+2); //2-d point
     QCOMPARE(ps.count(p), 2);
     QCOMPARE(ps.count(p2), 2);
     QCOMPARE(ps.count(p3), 2);
     QCOMPARE(ps.count(p4), 0);
     QCOMPARE(ps.count(p6), 1);
     QCOMPARE(ps.indexOf(&ps[0][0]), 0);
     //QCOMPARE(ps.indexOf(ps.end()), -1); //ps.end() is a QhullPoint which may match
     QCOMPARE(ps.indexOf(0), -1);
     QCOMPARE(ps.indexOf(&ps[3][0]), 3);
     QCOMPARE(ps.indexOf(&ps[3][1], QhullError::NOthrow), 3);
     QCOMPARE(ps.indexOf(ps.data()+ps.coordinateCount(), QhullError::NOthrow), -1);
     QCOMPARE(ps.indexOf(p), 0);
     QCOMPARE(ps.indexOf(p2), 0);
     QCOMPARE(ps.indexOf(p3), 0);
     QCOMPARE(ps.indexOf(p4), -1);
     QCOMPARE(ps.indexOf(p5), 2);
     QCOMPARE(ps.indexOf(p6), 1);
     QCOMPARE(ps.lastIndexOf(p), 3);
     QCOMPARE(ps.lastIndexOf(p4), -1);
     QCOMPARE(ps.lastIndexOf(p6), 1);
     QhullPoints ps2(3);
     QCOMPARE(ps2.indexOf(ps2.data()), -1);
     QCOMPARE(ps2.indexOf(ps2.data()+1, QhullError::NOthrow), -1);
     QCOMPARE(ps2.indexOf(p), -1);
     QCOMPARE(ps2.lastIndexOf(p), -1);
     QhullPoints ps3;
     QCOMPARE(ps3.indexOf(ps3.data()), -1);
     QCOMPARE(ps3.indexOf(ps3.data()+1, QhullError::NOthrow), -1);
     QCOMPARE(ps3.indexOf(p), -1);
     QCOMPARE(ps3.lastIndexOf(p), -1);
     QhullPoints ps4(2, 0, c);
     QCOMPARE(ps4.indexOf(p), -1);
     QCOMPARE(ps4.lastIndexOf(p), -1);
 }//t_search
 
 void QhullPoints_test::
 t_points_iterator()
 {
     coordT c2[]= {0.0};
     QhullPoints ps2(0, 0, c2); // 0-dimensional
     QhullPointsIterator i2= ps2;
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     i2.toBack();
     QVERIFY(!i2.hasNext());
     QVERIFY(!i2.hasPrevious());
 
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     QhullPoints ps(3, 6, c); // 3-dimensional
     QhullPointsIterator i(ps);
     i2= ps;
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i2.toBack();
     i.toFront();
     QVERIFY(!i2.hasNext());
     QVERIFY(i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     QhullPoint p= ps[0];
     QhullPoint p2(ps[0]);
     QCOMPARE(p, p2);
     QVERIFY(p==p2);
     QhullPoint p3(ps[1]);
  // p2[0]= 0.0;
     QVERIFY(p==p2);
     QCOMPARE(i2.peekPrevious(), p3);
     QCOMPARE(i2.previous(), p3);
     QCOMPARE(i2.previous(), p);
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekNext(), p);
     // i.peekNext()= 1.0; // compiler error
     QCOMPARE(i.next(), p);
     QCOMPARE(i.peekNext(), p3);
     QCOMPARE(i.next(), p3);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), p);
 }//t_points_iterator
 
 void QhullPoints_test::
 t_io()
 {
     QhullPoints ps;
     ostringstream os;
     os << "Empty QhullPoints\n" << ps << endl;
     coordT c[]= {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
     QhullPoints ps2(3, 6, c); // 3-dimensional explicit
     os << "QhullPoints from c[]\n" << ps2 << endl;
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullPoints ps3= q.points();
     os << "QhullPoints\n" << ps3;
     os << "RunId\n" << ps3.print(q.runId());
     os << ps3.print(q.runId(), "RunId w/ message\n");
     os << ps3.printWithIdentifier(q.runId(), "RunId w/ identifiers\n");
     cout << os.str();
     QString s= QString::fromStdString(os.str());
     QCOMPARE(s.count("p"), 3*8+3);
     // QCOMPARE(s.count(QRegExp("f\\d")), 3*7 + 13*3*2);
 }//t_io
 
 }//orgQhull
 
 #include "moc/QhullPoints_test.moc"
diff --git a/src/qhullrtest/QhullRidge_test.cpp b/src/qhullptest/QhullRidge_test.cpp
similarity index 95%
rename from src/qhullrtest/QhullRidge_test.cpp
rename to src/qhullptest/QhullRidge_test.cpp
index 18fd8eb..6407b8f 100644
--- a/src/qhullrtest/QhullRidge_test.cpp
+++ b/src/qhullptest/QhullRidge_test.cpp
@@ -1,163 +1,163 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullRidge_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullRidge_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h"
 
 #include "QhullRidge.h"
 #include "QhullError.h"
 #include "RboxPoints.h"
 #include "QhullFacet.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullRidge_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_getSet();
     void t_foreach();
     void t_io();
 };//QhullRidge_test
 
 void
 add_QhullRidge_test()
 {
     new QhullRidge_test();
 }
 
 //Executed after each testcase
 void QhullRidge_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullRidge_test::
 t_construct()
 {
     // Qhull.runQhull() constructs QhullFacets as facetT
     QhullRidge r;
     QVERIFY(!r.isDefined());
     QCOMPARE(r.dimension(),0);
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // triangulation of rotated unit cube
     QhullFacet f(q.firstFacet());
     QhullRidgeSet rs(f.ridges());
     QVERIFY(!rs.isEmpty()); // Simplicial facets do not have ridges()
     QhullRidge r2(rs.first());
     QCOMPARE(r2.dimension(), 2); // One dimension lower than the facet
     r= r2;
     QVERIFY(r.isDefined());
     QCOMPARE(r.dimension(), 2);
     QhullRidge r3= r2.getRidgeT();
     QCOMPARE(r,r3);
     QhullRidge r4= r2.getBaseT();
     QCOMPARE(r,r4);
     QhullRidge r5= r2; // copy constructor
     QVERIFY(r5==r2);
     QVERIFY(r5==r);
 }//t_construct
 
 void QhullRidge_test::
 t_getSet()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // triangulation of rotated unit cube
         QCOMPARE(q.facetCount(), 6);
         QCOMPARE(q.vertexCount(), 8);
         QhullFacet f(q.firstFacet());
         QhullRidgeSet rs= f.ridges();
         QhullRidgeSetIterator i(rs);
         while(i.hasNext()){
             const QhullRidge r= i.next();
             cout << r.id() << endl;
             QVERIFY(r.bottomFacet()!=r.topFacet());
             QCOMPARE(r.dimension(), 2); // Ridge one-dimension less than facet
             QVERIFY(r.id()>=0 && r.id()<9*27);
             QVERIFY(r.isDefined());
             QVERIFY(r==r);
             QVERIFY(r==i.peekPrevious());
             QCOMPARE(r.otherFacet(r.bottomFacet()),r.topFacet());
             QCOMPARE(r.otherFacet(r.topFacet()),r.bottomFacet());
         }
         QhullRidgeSetIterator i2(i);
         QEXPECT_FAIL("", "SetIterator copy constructor not reset to BOT", Continue);
         QVERIFY(!i2.hasPrevious());
     }
 }//t_getSet
 
 void QhullRidge_test::
 t_foreach()
 {
     RboxPoints rcube("c");  // cube
     {
         Qhull q(rcube, "QR0"); // rotated cube
         QhullFacet f(q.firstFacet());
         foreach (QhullRidge r, f.ridges()){  // Qt only
             QhullVertexSet vs= r.vertices();
             QCOMPARE(vs.count(), 2);
             foreach (QhullVertex v, vs){  // Qt only
                 QVERIFY(f.vertices().contains(v));
             }
         }
         QhullRidgeSet rs= f.ridges();
         QhullRidge r= rs.first();
         QhullRidge r2= r;
         QList<QhullVertex> vs;
         int count= 0;
         while(!count || r2!=r){
             ++count;
             QhullVertex v;
             QVERIFY2(r2.hasNextRidge3d(f),"A cube should only have non-simplicial facets.");
             QhullRidge r3= r2.nextRidge3d(f, &v);
             QVERIFY(!vs.contains(v));
             vs << v;
             r2= r2.nextRidge3d(f);
             QCOMPARE(r3, r2);
         }
         QCOMPARE(vs.count(), rs.count());
         QCOMPARE(count, rs.count());
     }
 }//t_foreach
 
 void QhullRidge_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube, "");
         QhullFacet f(q.firstFacet());
         QhullRidgeSet rs= f.ridges();
         QhullRidge r= rs.first();
         ostringstream os;
         os << "Ridges Without runId\n" << rs << "Ridge\n" << r;
         os << "Ridge with runId\n" << r.print(q.runId());
         cout << os.str();
         QString s= QString::fromStdString(os.str());
         QCOMPARE(s.count(" r"), 6+2);
     }
 }//t_io
 
 }//orgQhull
 
 #include "moc/QhullRidge_test.moc"
diff --git a/src/qhullrtest/QhullSet_test.cpp b/src/qhullptest/QhullSet_test.cpp
similarity index 98%
rename from src/qhullrtest/QhullSet_test.cpp
rename to src/qhullptest/QhullSet_test.cpp
index 18adc42..04460a8 100644
--- a/src/qhullrtest/QhullSet_test.cpp
+++ b/src/qhullptest/QhullSet_test.cpp
@@ -1,435 +1,435 @@
 /****************************************************************************
 **
-** Copyright (c) 2009-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullSet_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2009-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullSet_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include <QtCore/QList>
 #include "RoadTest.h" // QT_VERSION
 
 #include "QhullRidge.h"
 #include "QhullFacetSet.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 
 namespace orgQhull {
 
 class QhullSet_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_qhullsetbase();
     void t_convert();
     void t_element();
     void t_search();
     void t_iterator();
     void t_const_iterator();
     void t_qhullset_iterator();
     void t_io();
 };//QhullSet_test
 
 void
 add_QhullSet_test()
 {
     new QhullSet_test();
 }
 
 //Executed after each testcase
 void QhullSet_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 // Test QhullFacetSet and QhullSet.
 // Use QhullRidgeSet to test methods overloaded by QhullFacetSet
 
 void QhullSet_test::
 t_qhullsetbase()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // triangulation of rotated unit cube
         // Fake an empty set.  Default constructor not defined.  No memory allocation.
         QhullFacet f4 = q.beginFacet();
         QhullFacetSet fs = f4.neighborFacets();
         fs.defineAs(q.qhullQh()->other_points); // Force an empty set
         QVERIFY(fs.isEmpty());
         QVERIFY(fs.empty());
         QCOMPARE(fs.count(), 0);
         QCOMPARE(fs.size(), 0u);
         QCOMPARE(fs.begin(), fs.end()); // beginPointer(), endPointer()
         QVERIFY(QhullSetBase::isEmpty(fs.getSetT()));
 
         QhullRidgeSet rs = f4.ridges();
         QVERIFY(!rs.isEmpty());
         QVERIFY(!rs.empty());
         QCOMPARE(rs.count(), 4);
         QCOMPARE(rs.size(), 4u);
         QVERIFY(rs.begin()!=rs.end());
         QVERIFY(!QhullSetBase::isEmpty(rs.getSetT()));
         QhullRidgeSet rs2= rs; // copy constructor
         // rs= rs2; // disabled.  Would not copy ridges
         QCOMPARE(rs2, rs);
 
         QCOMPARE(q.facetCount(), 6);
         QhullFacet f = q.beginFacet();
         QhullFacetSet fs2 = f.neighborFacets();
         QCOMPARE(fs2.count(), 4);
         QCOMPARE(fs2.size(), 4u);
         QVERIFY(!fs2.isEmpty());
         QVERIFY(!QhullSetBase::isEmpty(fs2.getSetT()));
         QVERIFY(!fs2.empty());
         QVERIFY(fs!=fs2);
         setT *s= fs2.getSetT();
         fs.defineAs(s);
         QVERIFY(fs==fs2);
         QCOMPARE(fs[1], fs2[1]); // elementPointer
         QhullFacetSet fs3(fs2);
         QVERIFY(fs3==fs);
         // fs= fs2; // disabled.  Would not copy facets
         QhullFacetSet fs4= fs2; // copy constructor
         QVERIFY(fs4==fs2);
     }
 }//t_qhullsetbase
 
 // constructors tested by t_qhullsetbase
 
 void QhullSet_test::
 t_convert()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullFacet f= q.firstFacet();
         f= f.next();
         QhullRidgeSet rs= f.ridges();
         QCOMPARE(rs.count(),4);
         std::vector<QhullRidge> rv= rs.toStdVector();
         QCOMPARE(rv.size(), 4u);
         QList<QhullRidge> rv2= rs.toQList();
         QCOMPARE(rv2.size(), 4);
         std::vector<QhullRidge>::iterator i= rv.begin();
         foreach(QhullRidge r, rv2){  // Qt only
             QhullRidge r2= *i++;
             QCOMPARE(r, r2);
         }
 
         Qhull q2(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QCOMPARE(q2.facetCount(), 12);
         QhullFacet f2 = q2.beginFacet();
         QhullFacetSet fs = f2.neighborFacets();
         QCOMPARE(fs.size(), 3U);
         std::vector<QhullFacet> vs= fs.toStdVector();
         QCOMPARE(vs.size(), fs.size());
         for(int k= fs.count(); k--; ){
             QCOMPARE(vs[k], fs[k]);
         }
         QList<QhullFacet> qv= fs.toQList();
         QCOMPARE(qv.count(), fs.count());
         for(int k= fs.count(); k--; ){
             QCOMPARE(qv[k], fs[k]);
         }
     }
 }//t_convert
 
 //ReadOnly (count, isEmpty) tested by t_convert
 //  operator== tested by t_search
 
 void QhullSet_test::
 t_element()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullFacet f = q.beginFacet();
     QhullFacetSet fs = f.neighborFacets();
 
     QCOMPARE(fs.at(1), fs[1]);
     QCOMPARE(fs.first(), fs[0]);
     QCOMPARE(fs.front(), fs.first());
     QCOMPARE(fs.last(), fs.at(3));
     QCOMPARE(fs.back(), fs.last());
     QhullFacet *d= fs.data();
     const QhullFacet *d2= fs.data();
     const QhullFacet *d3= fs.constData();
     QVERIFY(d==d2);
     QVERIFY(d2==d3);
     QCOMPARE(*d, fs.first());
     QCOMPARE(d+4, fs.end());
     QCOMPARE((d+4)->getFacetT(), static_cast<facetT *>(0));
     QhullFacet f4= *(d+4);
     QVERIFY(!f4.isDefined());
     QCOMPARE(fs.second(), fs[1]);
     const QhullFacet f2= fs.second();
     QVERIFY(f2==fs[1]);
     const QhullFacet f3= fs[1];
     QCOMPARE(f2, f3);
 
     QCOMPARE(fs.value(2), fs[2]);
     QCOMPARE(fs.value(-1), QhullFacet());
     QCOMPARE(fs.value(10), QhullFacet());
     QCOMPARE(fs.value(2, f), fs[2]);
     QCOMPARE(fs.value(4, f), f);
     // mid() not available (read-only)
 }//t_element
 
 void QhullSet_test::
 t_search()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullFacet f = q.beginFacet();
     QhullFacetSet fs = f.neighborFacets();
     QhullFacet f2= *fs.begin();
     QhullFacet f3= fs.last();
     QVERIFY(fs.contains(f2));
     QVERIFY(fs.contains(f3));
     QVERIFY(!fs.contains(f));
 
     QhullFacetSet fs2= f2.neighborFacets();
     QVERIFY(fs==fs);
     QVERIFY(fs!=fs2);
     QCOMPARE(fs.count(f2), 1);
     QCOMPARE(fs.count(f3), 1);
     QCOMPARE(fs.count(f), 0);
     QCOMPARE(fs.indexOf(f2), 0);
     QCOMPARE(fs.indexOf(f3), 3);
     QCOMPARE(fs.indexOf(f), -1);
     QCOMPARE(fs.lastIndexOf(f2), 0);
     QCOMPARE(fs.lastIndexOf(f3), 3);
     QCOMPARE(fs.lastIndexOf(f), -1);
 }//t_search
 
 void QhullSet_test::
 t_iterator()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullFacet f = q.beginFacet();
         QhullFacetSet fs = f.neighborFacets();
         QhullFacetSet::Iterator i= fs.begin();
         QhullFacetSet::iterator i2= fs.begin();
         QVERIFY(i==i2);
         QVERIFY(i>=i2);
         QVERIFY(i<=i2);
         i= fs.begin();
         QVERIFY(i==i2);
         i2= fs.end();
         QVERIFY(i!=i2);
         QhullFacet f3(*i);
         i2--;
         QhullFacet f2= *i2;
         QCOMPARE(f3.id(), fs[0].id());
         QCOMPARE(f2.id(), fs[3].id());
         QhullFacetSet::Iterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3).id(), fs[1].id());
         QVERIFY(i==i);
         QVERIFY(i!=i2);
         QVERIFY(i<i2);
         QVERIFY(i<=i2);
         QVERIFY(i2>i);
         QVERIFY(i2>=i);
 
         QhullFacetSet::ConstIterator i4= fs.begin();
         QVERIFY(i==i4); // iterator COMP const_iterator
         QVERIFY(i<=i4);
         QVERIFY(i>=i4);
         QVERIFY(i4==i); // const_iterator COMP iterator
         QVERIFY(i4<=i);
         QVERIFY(i4>=i);
         QVERIFY(i>=i4);
         QVERIFY(i4<=i);
         QVERIFY(i2!=i4);
         QVERIFY(i2>i4);
         QVERIFY(i2>=i4);
         QVERIFY(i4!=i2);
         QVERIFY(i4<i2);
         QVERIFY(i4<=i2);
         ++i4;
         QVERIFY(i<i4);
         QVERIFY(i<=i4);
         QVERIFY(i4>i);
         QVERIFY(i4>=i);
 
         i= fs.begin();
         i2= fs.begin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, fs[1]);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, fs.begin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2 += 4, fs.end());
         QCOMPARE(i2 -= 4, fs.begin());
         QCOMPARE(i2+0, fs.begin());
         QCOMPARE(i2+4, fs.end());
         i2 += 4;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-4;
         QCOMPARE(i, fs.begin());
         QCOMPARE(i2-i, 4);
 
         //fs.begin end tested above
 
         // QhullFacetSet is const-only
     }
 }//t_iterator
 
 void QhullSet_test::
 t_const_iterator()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0");  // rotated unit cube
         QhullFacet f = q.beginFacet();
         QhullFacetSet fs = f.neighborFacets();
         QhullFacetSet::ConstIterator i= fs.begin();
         QhullFacetSet::const_iterator i2= fs.begin();
         QVERIFY(i==i2);
         QVERIFY(i>=i2);
         QVERIFY(i<=i2);
         i= fs.begin();
         QVERIFY(i==i2);
         i2= fs.end();
         QVERIFY(i!=i2);
         QhullFacet f3(*i);
         i2--;
         QhullFacet f2= *i2;
         QCOMPARE(f3.id(), fs[0].id());
         QCOMPARE(f2.id(), fs[3].id());
         QhullFacetSet::ConstIterator i3(i2);
         QCOMPARE(*i2, *i3);
 
         (i3= i)++;
         QCOMPARE((*i3).id(), fs[1].id());
         QVERIFY(i==i);
         QVERIFY(i!=i2);
         QVERIFY(i<i2);
         QVERIFY(i<=i2);
         QVERIFY(i2>i);
         QVERIFY(i2>=i);
 
         // See t_iterator for const_iterator COMP iterator
 
         i= fs.begin();
         i2= fs.constBegin();
         QCOMPARE(i, i2++);
         QCOMPARE(*i2, fs[1]);
         QCOMPARE(++i, i2);
         QCOMPARE(i, i2--);
         QCOMPARE(i2, fs.constBegin());
         QCOMPARE(--i, i2);
         QCOMPARE(i2+=4, fs.constEnd());
         QCOMPARE(i2-=4, fs.constBegin());
         QCOMPARE(i2+0, fs.constBegin());
         QCOMPARE(i2+4, fs.constEnd());
         i2 += 4;
         i= i2-0;
         QCOMPARE(i, i2);
         i= i2-4;
         QCOMPARE(i, fs.constBegin());
         QCOMPARE(i2-i, 4);
 
         // QhullFacetSet is const-only
     }
 }//t_const_iterator
 
 void QhullSet_test::
 t_qhullset_iterator()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     // Fake an empty set.  Default constructor not defined.  No memory allocation.
     QhullFacet f = q.beginFacet();
     QhullFacetSet fs = f.neighborFacets();
     fs.defineAs(q.qhullQh()->other_points);
     QhullFacetSetIterator i= fs;
     QCOMPARE(fs.count(), 0);
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
     i.toBack();
     QVERIFY(!i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     QhullFacet f2 = q.beginFacet();
     QhullFacetSet fs2 = f2.neighborFacets();
     QhullFacetSetIterator i2(fs2);
     QCOMPARE(fs2.count(), 4);
     i= fs2;
     QVERIFY(i2.hasNext());
     QVERIFY(!i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
     i2.toBack();
     i.toFront();
     QVERIFY(!i2.hasNext());
     QVERIFY(i2.hasPrevious());
     QVERIFY(i.hasNext());
     QVERIFY(!i.hasPrevious());
 
     // i at front, i2 at end/back, 4 neighbors
     QhullFacetSet fs3 = f2.neighborFacets(); // same as fs2
     QhullFacet f3(fs2[0]);
     QhullFacet f4= fs3[0];
     QCOMPARE(f3, f4);
     QVERIFY(f3==f4);
     QhullFacet f5(fs3[1]);
     QVERIFY(f4!=f5);
     QhullFacet f6(fs3[2]);
     QhullFacet f7(fs3[3]);
     QCOMPARE(i2.peekPrevious(), f7);
     QCOMPARE(i2.previous(), f7);
     QCOMPARE(i2.previous(), f6);
     QCOMPARE(i2.previous(), f5);
     QCOMPARE(i2.previous(), f4);
     QVERIFY(!i2.hasPrevious());
     QCOMPARE(i.peekNext(), f4);
     // i.peekNext()= 1.0; // compiler error
     QCOMPARE(i.next(), f4);
     QCOMPARE(i.peekNext(), f5);
     QCOMPARE(i.next(), f5);
     QCOMPARE(i.next(), f6);
     QCOMPARE(i.next(), f7);
     QVERIFY(!i.hasNext());
     i.toFront();
     QCOMPARE(i.next(), f4);
 }//t_qhullset_iterator
 
 void QhullSet_test::
 t_io()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     // Fake an empty set.  Default constructor not defined.  No memory allocation.
     QhullFacet f= q.beginFacet();
     QhullFacetSet fs= f.neighborFacets();
     fs.defineAs(q.qhullQh()->other_points);
     cout << "INFO:     empty set" << fs << std::endl;
     QhullFacet f2= q.beginFacet();
     QhullFacetSet fs2= f2.neighborFacets();
     cout << "INFO:   Neighboring facets\n";
     cout << fs2 << std::endl;
 
     QhullRidgeSet rs= f.ridges();
     cout << "INFO:   Ridges for a facet\n";
     cout << rs << std::endl;
 }//t_io
 
 }//namespace orgQhull
 
 #include "moc/QhullSet_test.moc"
diff --git a/src/qhullrtest/QhullVertexSet_test.cpp b/src/qhullptest/QhullVertexSet_test.cpp
similarity index 97%
rename from src/qhullrtest/QhullVertexSet_test.cpp
rename to src/qhullptest/QhullVertexSet_test.cpp
index b70fd6b..b56780f 100644
--- a/src/qhullrtest/QhullVertexSet_test.cpp
+++ b/src/qhullptest/QhullVertexSet_test.cpp
@@ -1,185 +1,185 @@
 /****************************************************************************
 **
 ** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullVertexSet_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** $Id: //main/2011/qhull/src/qhullptest/QhullVertexSet_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #include <iostream>
 #include "../road/RoadTest.h" // FIXUP First for QHULL_USES_QT
 
 #include "Qhull.h"
 #include "QhullError.h"
 #include "QhullFacet.h"
 #include "QhullFacetSet.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullFacetSet_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_convert();
     void t_readonly();
     void t_foreach();
     void t_io();
 };//QhullFacetSet_test
 
 void
 add_QhullFacetSet_test()
 {
     new QhullFacetSet_test();
 }
 
 //Executed after each testcase
 void QhullFacetSet_test::
 cleanup()
 {
     RoadTest::cleanup();
     UsingQhullLib::checkQhullMemoryEmpty();
 }
 
 void QhullFacetSet_test::
 t_construct()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullFacet f= q.firstFacet();
     QhullFacetSet fs2= f.neighborFacets();
     QVERIFY(!fs2.isEmpty());
     QCOMPARE(fs2.count(),4);
     QhullFacetSet fs4= fs2; // copy constructor
     QVERIFY(fs4==fs2);
     QhullFacetSet fs3(q.qhullQh()->facet_mergeset);
     QVERIFY(fs3.isEmpty());
 }//t_construct
 
 void QhullFacetSet_test::
 t_convert()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QR0 QV2");  // rotated unit cube
     QhullFacet f= q.firstFacet();
     QhullFacetSet fs2= f.neighborFacets();
     QVERIFY(!fs2.isSelectAll());
     QCOMPARE(fs2.count(),2);
     std::vector<QhullFacet> fv= fs2.toStdVector();
     QCOMPARE(fv.size(), 2u);
     QList<QhullFacet> fv2= fs2.toQList();
     QCOMPARE(fv2.size(), 2);
     fs2.selectAll();
     QVERIFY(fs2.isSelectAll());
     std::vector<QhullFacet> fv3= fs2.toStdVector();
     QCOMPARE(fv3.size(), 4u);
     QList<QhullFacet> fv4= fs2.toQList();
     QCOMPARE(fv4.size(), 4);
 }//t_convert
 
 //! Spot check properties and read-only.  See QhullSet_test
 void QhullFacetSet_test::
 t_readonly()
 {
     RboxPoints rcube("c");
     Qhull q(rcube,"QV0");  // good facets are adjacent to point 0
     QhullFacetSet fs= q.firstFacet().neighborFacets();
     QVERIFY(!fs.isSelectAll());
     QCOMPARE(fs.count(), 2);
     fs.selectAll();
     QVERIFY(fs.isSelectAll());
     QCOMPARE(fs.count(), 4);
     fs.selectGood();
     QVERIFY(!fs.isSelectAll());
     QCOMPARE(fs.count(), 2);
     QhullFacet f= fs.first();
     QhullFacet f2= fs.last();
     fs.selectAll();
     QVERIFY(fs.contains(f));
     QVERIFY(fs.contains(f2));
     QVERIFY(f.isGood());
     QVERIFY(!f2.isGood());
     fs.selectGood();
     QVERIFY(fs.contains(f));
     QVERIFY(!fs.contains(f2));
 }//t_readonly
 
 void QhullFacetSet_test::
 t_foreach()
 {
     RboxPoints rcube("c");
     // Spot check predicates and accessors.  See QhullLinkedList_test
     Qhull q(rcube,"QR0");  // rotated unit cube
     QhullFacetSet fs= q.firstFacet().neighborFacets();
     QVERIFY(!fs.contains(q.firstFacet()));
     QVERIFY(fs.contains(fs.first()));
     QhullFacet f= q.firstFacet().next();
     if(!fs.contains(f)){
         f= f.next();
     }
     QVERIFY(fs.contains(f));
     QCOMPARE(fs.first(), *fs.begin());
     QCOMPARE(*(fs.end()-1), fs.last());
 }//t_foreach
 
 void QhullFacetSet_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"QR0 QV0");   // good facets are adjacent to point 0
         QhullFacetSet fs= q.firstFacet().neighborFacets();
         ostringstream os;
         os << fs.print(q.runId(), "Neighbors of first facet with point 0");
         os << fs.printIdentifiers("\nFacet identifiers: ");
         cout<< os.str();
         QString facets= QString::fromStdString(os.str());
         QCOMPARE(facets.count(QRegExp(" f[0-9]")), 2+13*2);
     }
 }//t_io
 
 //FIXUP -- Move conditional, QhullFacetSet code to QhullFacetSet.cpp
 #ifndef QHULL_NO_STL
 std::vector<QhullFacet> QhullFacetSet::
 toStdVector() const
 {
     QhullSetIterator<QhullFacet> i(*this);
     std::vector<QhullFacet> vs;
     while(i.hasNext()){
         QhullFacet f= i.next();
         if(isSelectAll() || f.isGood()){
             vs.push_back(f);
         }
     }
     return vs;
 }//toStdVector
 #endif //QHULL_NO_STL
 
 #ifdef QHULL_USES_QT
 QList<QhullFacet> QhullFacetSet::
 toQList() const
 {
     QhullSetIterator<QhullFacet> i(*this);
     QList<QhullFacet> vs;
     while(i.hasNext()){
         QhullFacet f= i.next();
         if(isSelectAll() || f.isGood()){
             vs.append(f);
         }
     }
     return vs;
 }//toQList
 #endif //QHULL_USES_QT
 
 }//orgQhull
 
 #include "moc/QhullFacetSet_test.moc"
diff --git a/src/qhullrtest/QhullVertex_test.cpp b/src/qhullptest/QhullVertex_test.cpp
similarity index 96%
rename from src/qhullrtest/QhullVertex_test.cpp
rename to src/qhullptest/QhullVertex_test.cpp
index 012dd2f..2ac9522 100644
--- a/src/qhullrtest/QhullVertex_test.cpp
+++ b/src/qhullptest/QhullVertex_test.cpp
@@ -1,184 +1,184 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/QhullVertex_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/QhullVertex_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h"
 
 #include "QhullVertex.h"
 #include "Coordinates.h"
 #include "QhullError.h"
 #include "RboxPoints.h"
 #include "QhullFacet.h"
 #include "QhullFacetSet.h"
 #include "QhullVertexSet.h"
 #include "Qhull.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::ostream;
 using std::string;
 
 namespace orgQhull {
 
 class QhullVertex_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_constructConvert();
     void t_getSet();
     void t_foreach();
     void t_io();
 };//QhullVertex_test
 
 void
 add_QhullVertex_test()
 {
     new QhullVertex_test();
 }
 
 //Executed after each testcase
 void QhullVertex_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void QhullVertex_test::
 t_constructConvert()
 {
     // Qhull.runQhull() constructs QhullFacets as facetT
     QhullVertex v;
     QVERIFY(!v.isDefined());
     QCOMPARE(v.dimension(),0);
     RboxPoints rcube("c");
     Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
     QhullVertex v2(q.beginVertex());
     QCOMPARE(v2.dimension(),3);
     v= v2;  // copy assignment
     QVERIFY(v.isDefined());
     QCOMPARE(v.dimension(),3);
     QhullVertex v5= v2; // copy constructor
     QVERIFY(v5==v2);
     QVERIFY(v5==v);
     QhullVertex v3= v2.getVertexT();
     QCOMPARE(v,v3);
     QhullVertex v4= v2.getBaseT();
     QCOMPARE(v,v4);
 }//t_constructConvert
 
 void QhullVertex_test::
 t_getSet()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube,"Qt QR0");  // triangulation of rotated unit cube
         QCOMPARE(q.facetCount(), 12);
         QCOMPARE(q.vertexCount(), 8);
 
         // Also spot-test QhullVertexList.  See QhullLinkedList_test.cpp
         QhullVertexList vs= q.vertexList();
         QhullVertexListIterator i(vs);
         while(i.hasNext()){
             const QhullVertex v= i.next();
             cout << v.id() << endl;
             QCOMPARE(v.dimension(),3);
             QVERIFY(v.id()>=0 && v.id()<9);
             QVERIFY(v.isDefined());
             if(i.hasNext()){
                 QCOMPARE(v.next(), i.peekNext());
                 QVERIFY(v.next()!=v);
                 QVERIFY(v.next().previous()==v);
             }
             QVERIFY(i.hasPrevious());
             QCOMPARE(v, i.peekPrevious());
         }
         QhullVertexListIterator i2(i);
         QEXPECT_FAIL("", "ListIterator copy constructor not reset to BOT", Continue);
         QVERIFY(!i2.hasPrevious());
 
         // test point()
         foreach (QhullVertex v, q.vertexList()){  // Qt only
             QhullPoint p= v.point();
             int j= p.id(q.runId());
             cout << "Point " << j << ":\n" << p.print(q.runId()) << endl;
             QVERIFY(j>=0 && j<8);
         }
     }
 }//t_getSet
 
 void QhullVertex_test::
 t_foreach()
 {
     RboxPoints rcube("c W0 300");  // 300 points on surface of cube
     {
         Qhull q(rcube, "QR0 Qc"); // keep coplanars, thick facet, and rotate the cube
         foreach (QhullVertex v, q.vertexList()){  // Qt only
             QhullFacetSet fs= v.neighborFacets();
             QCOMPARE(fs.count(), 3);
             foreach (QhullFacet f, fs){  // Qt only
                 QVERIFY(f.vertices().contains(v));
             }
         }
     }
 }//t_foreach
 
 void QhullVertex_test::
 t_io()
 {
     RboxPoints rcube("c");
     {
         Qhull q(rcube, "");
         QhullVertex v= q.beginVertex();
         ostringstream os;
         os << "Vertex and vertices w/o runId:\n";
         os << v;
         QhullVertexSet vs= q.firstFacet().vertices();
         os << vs;
         os << "Vertex and vertices w/ runId:\n";
         os << v.print(q.runId());
         os << vs.print(q.runId(), "vertices:");
         cout << os.str();
         QString s= QString::fromStdString(os.str());
         QCOMPARE(s.count("(v"), 10);
         QCOMPARE(s.count(": f"), 2);
     }
     RboxPoints r10("10 D3");  // Without QhullVertex::facetNeighbors
     {
         Qhull q(r10, "");
         QhullVertex v= q.beginVertex();
         ostringstream os;
         os << "\nTry again with simplicial facets.  No neighboring facets listed for vertices.\n";
         os << "Vertex and vertices w/o runId:\n";
         os << v;
         q.defineVertexNeighborFacets();
         os << "This time with neighborFacets() defined for all vertices:\n";
         os << v;
         cout << os.str();
         QString s= QString::fromStdString(os.str());
         QCOMPARE(s.count(": f"), 1);
 
         Qhull q2(r10, "v"); // Voronoi diagram
         QhullVertex v2= q2.beginVertex();
         ostringstream os2;
         os2 << "\nTry again with Voronoi diagram of simplicial facets.  Neighboring facets automatically defined for vertices.\n";
         os2 << "Vertex and vertices w/o runId:\n";
         os2 << v2;
         cout << os2.str();
         QString s2= QString::fromStdString(os2.str());
         QCOMPARE(s2.count(": f"), 1);
     }
 }//t_io
 
 }//orgQhull
 
 #include "moc/QhullVertex_test.moc"
diff --git a/src/qhullrtest/Qhull_test.cpp b/src/qhullptest/Qhull_test.cpp
similarity index 98%
rename from src/qhullrtest/Qhull_test.cpp
rename to src/qhullptest/Qhull_test.cpp
index 8c1f5aa..5bbd2fe 100644
--- a/src/qhullrtest/Qhull_test.cpp
+++ b/src/qhullptest/Qhull_test.cpp
@@ -1,380 +1,380 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/Qhull_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/Qhull_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h" // QT_VERSION
 
 #include "Qhull.h"
 #include "QhullError.h"
 #include "RboxPoints.h"
 #include "QhullFacetList.h"
 
 using std::cout;
 using std::endl;
 using std::string;
 
 namespace orgQhull {
 
 //! Test C++ interface to Qhull
 //! See eg/q_test for tests of Qhull commands
 class Qhull_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void cleanup();
     void t_construct();
     void t_attribute();
     void t_message();
     void t_getSet();
     void t_getQh();
     void t_getValue();
     void t_foreach();
     void t_modify();
 };//Qhull_test
 
 void
 add_Qhull_test()
 {
     new Qhull_test();
 }
 
 //Executed after each testcase
 void Qhull_test::
 cleanup()
 {
     UsingLibQhull::checkQhullMemoryEmpty();
     RoadTest::cleanup();
 }
 
 void Qhull_test::
 t_construct()
 {
     {
         Qhull q;
         QCOMPARE(q.dimension(),0);
         QVERIFY(q.qhullQh()!=0);
         QVERIFY(q.runId()!=0);
         QCOMPARE(QString(q.qhullCommand()),QString(""));
         QCOMPARE(QString(q.rboxCommand()),QString(""));
         try{
             QCOMPARE(q.area(),0.0);
             QFAIL("area() did not fail.");
         }catch (const std::exception &e) {
             cout << "INFO   : Caught " << e.what();
         }
         Qhull q2(q);  // Copy constructor and copy assignment OK if not q.initialized()
         QCOMPARE(q2.dimension(),0);
         q= q2;
         QCOMPARE(q.dimension(),0);
     }
     {
         RboxPoints rbox("10000");
         Qhull q(rbox, "QR0"); // Random points in a randomly rotated cube.
         QCOMPARE(q.dimension(),3);
         QVERIFY(q.volume() < 1.0);
         QVERIFY(q.volume() > 0.99);
         try{
             Qhull q2(q);
             QFAIL("Copy constructor did not fail for initialized Qhull.");
         }catch (const std::exception &e) {
             cout << "INFO   : Caught " << e.what();
         }
         try{
             Qhull q3;
             q3= q;
             QFAIL("Copy assignment did not fail for initialized Qhull source.");
         }catch (const std::exception &e) {
             cout << "INFO   : Caught " << e.what();
         }
         QCOMPARE(q.dimension(),3);
         try{
             Qhull q4;
             q= q4;
             QFAIL("Copy assignment did not fail for initialized Qhull destination.");
         }catch (const std::exception &e) {
             cout << "INFO   : Caught " << e.what();
         }
         QCOMPARE(q.dimension(),3);
     }
     {
         double points[] = {
             0, 0,
             1, 0,
             1, 1
         };
         Qhull q("triangle", 2, 3, points, "");
         QCOMPARE(q.dimension(),2);
         QCOMPARE(q.facetCount(),3);
         QCOMPARE(q.vertexCount(),3);
         QCOMPARE(q.dimension(),2);
         QCOMPARE(q.area(), 2.0+sqrt(2.0)); // length of boundary
         QCOMPARE(q.volume(), 0.5);        // the 2-d area
     }
 }//t_construct
 
 void Qhull_test::
 t_attribute()
 {
     RboxPoints rcube("c");
     {
         double normals[] = {
             0,  -1, -0.5,
            -1,   0, -0.5,
             1,   0, -0.5,
             0,   1, -0.5
         };
         Qhull q;
         q.feasiblePoint << 0.0 << 0.0;
         Coordinates c(std::vector<double>(2, 0.0));
         QVERIFY(q.feasiblePoint==c);
         q.setOutputStream(&cout);
         q.runQhull("normals of square", 3, 4, normals, "H"); // halfspace intersect
         QCOMPARE(q.facetList().count(), 4); // Vertices of square
         cout << "Expecting summary of halfspace intersect\n";
         q.outputQhull();
         q.useOutputStream= false;
         cout << "Expecting no output from qh_fprintf() in Qhull.cpp\n";
         q.outputQhull();
     }
 }//t_attribute
 
 //! No QhullMessage for errors outside of qhull
 void Qhull_test::
 t_message()
 {
     RboxPoints rcube("c");
     {
         Qhull q;
         QCOMPARE(q.qhullMessage(), string(""));
         QCOMPARE(q.qhullStatus(), qh_ERRnone);
         QVERIFY(!q.hasQhullMessage());
         try{
             q.runQhull(rcube, "Fd");
             QFAIL("runQhull Fd did not fail.");
         }catch (const std::exception &e) {
             const char *s= e.what();
             cout << "INFO   : Caught " << s;
             QCOMPARE(QString::fromStdString(s).left(6), QString("QH6029"));
             // FIXUP QH11025 -- review decision to clearQhullMessage at QhullError()            // Cleared when copied to QhullError
             QVERIFY(!q.hasQhullMessage());
             // QCOMPARE(q.qhullMessage(), QString::fromStdString(s).remove(0, 7));
             // QCOMPARE(q.qhullStatus(), 6029);
             q.clearQhullMessage();
             QVERIFY(!q.hasQhullMessage());
         }
         q.appendQhullMessage("Append 1");
         QVERIFY(q.hasQhullMessage());
         QCOMPARE(QString::fromStdString(q.qhullMessage()), QString("Append 1"));
         q.appendQhullMessage("\nAppend 2\n");
         QCOMPARE(QString::fromStdString(q.qhullMessage()), QString("Append 1\nAppend 2\n"));
         q.clearQhullMessage();
         QVERIFY(!q.hasQhullMessage());
         QCOMPARE(QString::fromStdString(q.qhullMessage()), QString(""));
     }
     {
         cout << "INFO   : Error stream without output stream\n";
         Qhull q;
         q.setErrorStream(&cout);
         q.setOutputStream(0);
         try{
             q.runQhull(rcube, "Fd");
             QFAIL("runQhull Fd did not fail.");
         }catch (const QhullError &e) {
             cout << "INFO   : Caught " << e;
             QCOMPARE(e.errorCode(), 6029);
         }
         //FIXUP QH11026 Qhullmessage cleared when QhullError thrown.  Switched to e
         //QVERIFY(q.hasQhullMessage());
         //QCOMPARE(QString::fromStdString(q.qhullMessage()).left(6), QString("QH6029"));
         q.clearQhullMessage();
         QVERIFY(!q.hasQhullMessage());
     }
     {
         cout << "INFO   : Error output sent to output stream without error stream\n";
         Qhull q;
         q.setErrorStream(0);
         q.setOutputStream(&cout);
         try{
             q.runQhull(rcube, "Tz H0");
             QFAIL("runQhull TZ did not fail.");
         }catch (const std::exception &e) {
             const char *s= e.what();
             cout << "INFO   : Caught " << s;
             QCOMPARE(QString::fromAscii(s).left(6), QString("QH6023"));
         }
         //FIXUP QH11026 Qhullmessage cleared when QhullError thrown.  Switched to e
         //QVERIFY(q.hasQhullMessage());
         //QCOMPARE(QString::fromStdString(q.qhullMessage()).left(17), QString("qhull: no message"));
         //QCOMPARE(q.qhullStatus(), 6023);
         q.clearQhullMessage();
         QVERIFY(!q.hasQhullMessage());
     }
     {
         cout << "INFO   : No error stream or output stream\n";
         Qhull q;
         q.setErrorStream(0);
         q.setOutputStream(0);
         try{
             q.runQhull(rcube, "Fd");
             QFAIL("outputQhull did not fail.");
         }catch (const std::exception &e) {
             const char *s= e.what();
             cout << "INFO   : Caught " << s;
             QCOMPARE(QString::fromAscii(s).left(6), QString("QH6029"));
         }
         //FIXUP QH11026 Qhullmessage cleared when QhullError thrown.  Switched to e
         //QVERIFY(q.hasQhullMessage());
         //QCOMPARE(QString::fromStdString(q.qhullMessage()).left(9), QString("qhull err"));
         //QCOMPARE(q.qhullStatus(), 6029);
         q.clearQhullMessage();
         QVERIFY(!q.hasQhullMessage());
     }
 }//t_message
 
 void Qhull_test::
 t_getSet()
 {
     RboxPoints rcube("c");
     {
         Qhull q;
         QVERIFY(!q.initialized());
         q.runQhull(rcube, "s");
         QVERIFY(q.initialized());
         QCOMPARE(q.dimension(), 3);
         QhullPoint p= q.origin();
         QCOMPARE(p.dimension(), 3);
         QCOMPARE(p[0]+p[1]+p[2], 0.0);
         QVERIFY(q.runId()!=0);
         q.setErrorStream(&cout);
         q.outputQhull();
     }
     {
         Qhull q;
         q.runQhull(rcube, "");
         q.setOutputStream(&cout);
         q.outputQhull();
     }
     // qhullQh -- UsingLibQhull [Qhull.cpp]
     // runId -- UsingLibQhull [Qhull.cpp]
 }//t_getSet
 
 void Qhull_test::
 t_getQh()
 {
     RboxPoints rcube("c");
     {
         Qhull q;
         q.runQhull(rcube, "s");
         QCOMPARE(QString(q.qhullCommand()), QString("qhull s"));
         QCOMPARE(QString(q.rboxCommand()), QString("rbox \"c\""));
         QCOMPARE(q.facetCount(), 6);
         QCOMPARE(q.vertexCount(), 8);
         // Sample fields from Qhull's qhT [libqhull.h]
         QCOMPARE(q.qhullQh()->ALLpoints, 0u);
         QCOMPARE(q.qhullQh()->GOODpoint, 0);
         QCOMPARE(q.qhullQh()->IStracing, 0);
         QCOMPARE(q.qhullQh()->MAXcoplanar+1.0, 1.0); // fuzzy compare
         QCOMPARE(q.qhullQh()->MERGING, 1u);
         QCOMPARE(q.qhullQh()->input_dim, 3);
         QCOMPARE(QString(q.qhullQh()->qhull_options).left(8), QString("  run-id"));
         QCOMPARE(q.qhullQh()->run_id, q.runId());
         QCOMPARE(q.qhullQh()->num_facets, 6);
         QCOMPARE(q.qhullQh()->hasTriangulation, 0u);
         QCOMPARE(q.qhullQh()->max_outside - q.qhullQh()->min_vertex + 1.0, 1.0); // fuzzy compare
         QCOMPARE(*q.qhullQh()->gm_matrix+1.0, 1.0); // fuzzy compare
     }
 }//t_getQh
 
 void Qhull_test::
 t_getValue()
 {
     RboxPoints rcube("c");
     {
         Qhull q;
         q.runQhull(rcube, "");
         QCOMPARE(q.area(), 6.0);
         QCOMPARE(q.volume(), 1.0);
     }
 }//t_getValue
 
 void Qhull_test::
 t_foreach()
 {
     RboxPoints rcube("c");
     {
         Qhull q;
         QCOMPARE(q.beginFacet(),q.endFacet());
         QCOMPARE(q.beginVertex(),q.endVertex());
         q.runQhull(rcube, "");
         QCOMPARE(q.facetList().count(), 6);
 
         // defineVertexNeighborFacets() tested in QhullVertex_test::t_io()
 
         QhullFacetList facets(q.beginFacet(), q.endFacet());
         QCOMPARE(facets.count(), 6);
         QCOMPARE(q.firstFacet(), q.beginFacet());
         QhullVertexList vertices(q.beginVertex(), q.endVertex());
         QCOMPARE(vertices.count(), 8);
         QCOMPARE(q.firstVertex(), q.beginVertex());
         QhullPoints ps= q.points();
         QCOMPARE(ps.count(), 8);
         QhullPointSet ps2= q.otherPoints();
         QCOMPARE(ps2.count(), 0);
         // ps2= q.otherPoints(); //disabled, would not copy the points
         QCOMPARE(q.facetCount(), 6);
         QCOMPARE(q.vertexCount(), 8);
         coordT *c= q.pointCoordinateBegin(); // of q.points()
         QVERIFY(*c==0.5 || *c==-0.5);
         coordT *c3= q.pointCoordinateEnd();
         QVERIFY(c3[-1]==0.5 || c3[-1]==-0.5);
         QCOMPARE(c3-c, 8*3);
         QCOMPARE(q.vertexList().count(), 8);
     }
 }//t_foreach
 
 void Qhull_test::
 t_modify()
 {
     //addPoint() tested in t_foreach
     RboxPoints diamond("d");
     Qhull q(diamond, "o");
     q.setOutputStream(&cout);
     cout << "Expecting vertexList and facetList of a 3-d diamond.\n";
     q.outputQhull();
     cout << "Expecting normals of a 3-d diamond.\n";
     q.outputQhull("n");
     // runQhull tested in t_attribute(), t_message(), etc.
 }//t_modify
 
 }//orgQhull
 
 // Redefine Qhull's usermem.c
 void qh_exit(int exitcode) {
     cout << "FAIL!  : Qhull called qh_exit().  Qhull's error handling not available.\n.. See the corresponding Qhull:qhull_message or setErrorStream().\n";
     exit(exitcode);
 }
 void qh_free(void *mem) {
     free(mem);
 }
 void *qh_malloc(size_t size) {
     return malloc(size);
 }
 
 #if 0
 template<> char * QTest::
 toString(const std::string &s)
 {
     QByteArray ba = s.c_str();
     return qstrdup(ba.data());
 }
 #endif
 
 #include "moc/Qhull_test.moc"
diff --git a/src/qhullrtest/RboxPoints_test.cpp b/src/qhullptest/RboxPoints_test.cpp
similarity index 96%
rename from src/qhullrtest/RboxPoints_test.cpp
rename to src/qhullptest/RboxPoints_test.cpp
index fd2c8f3..aca7c1b 100644
--- a/src/qhullrtest/RboxPoints_test.cpp
+++ b/src/qhullptest/RboxPoints_test.cpp
@@ -1,216 +1,216 @@
 /****************************************************************************
 **
-** Copyright (c) 2006-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/RboxPoints_test.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2006-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/RboxPoints_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
 **
 ****************************************************************************/
 //pre-compiled headers
 #include <iostream>
 #include "RoadTest.h" // QT_VERSION
 
 #include "RboxPoints.h"
 #include "QhullError.h"
 
 using std::cout;
 using std::endl;
 using std::ostringstream;
 using std::string;
 using std::stringstream;
 
 namespace orgQhull {
 
 //! Test C++ interface to Rbox
 //! See eg/q_test for tests of rbox commands
 class RboxPoints_test : public RoadTest
 {
     Q_OBJECT
 
 #//Test slots
 private slots:
     void t_construct();
     void t_error();
     void t_test();
     void t_getSet();
     void t_foreach();
     void t_change();
     void t_ostream();
 };
 
 void
 add_RboxPoints_test()
 {
     new RboxPoints_test();
 }
 
 void RboxPoints_test::
 t_construct()
 {
     RboxPoints rp;
     QCOMPARE(rp.dimension(), 0);
     QCOMPARE(rp.count(), 0);
     QVERIFY(QString::fromStdString(rp.comment()) != QString(""));
     QVERIFY(rp.isEmpty());
     QVERIFY(!rp.hasRboxMessage());
     QCOMPARE(rp.rboxStatus(), qh_ERRnone);
     QCOMPARE(QString::fromStdString(rp.rboxMessage()), QString("rbox warning: no points generated\n"));
 
     RboxPoints rp2("c"); // 3-d cube
     QCOMPARE(rp2.dimension(), 3);
     QCOMPARE(rp2.count(), 8);
     QCOMPARE(QString::fromStdString(rp2.comment()), QString("rbox \"c\""));
     QVERIFY(!rp2.isEmpty());
     QVERIFY(!rp2.hasRboxMessage());
     QCOMPARE(rp2.rboxStatus(), qh_ERRnone);
     QCOMPARE(QString::fromStdString(rp2.rboxMessage()), QString("rbox: OK\n"));
 }//t_construct
 
 void RboxPoints_test::
 t_error()
 {
     RboxPoints rp;
     try{
         rp.appendPoints("D0 c");
         QFAIL("'D0 c' did not fail.");
     }catch (const std::exception &e) {
         const char *s= e.what();
         cout << "INFO   : Caught " << s;
         QCOMPARE(QString(s).left(6), QString("QH6189"));
         QVERIFY(rp.hasRboxMessage());
         QCOMPARE(QString::fromStdString(rp.rboxMessage()).left(8), QString("rbox err"));
         QCOMPARE(rp.rboxStatus(), 6189);
         rp.clearRboxMessage();
         QVERIFY(!rp.hasRboxMessage());
     }
     try{
         RboxPoints rp2;
         rp2.setDimension(-1);
         QFAIL("setDimension(-1) did not fail.");
     }catch (const RoadError &e) {
         const char *s= e.what();
         cout << "INFO   : Caught " << s;
         QCOMPARE(QString(s).left(7), QString("QH10062"));
         QCOMPARE(e.errorCode(), 10062);
         QCOMPARE(QString::fromStdString(e.what()), QString(s));
         RoadLogEvent logEvent= e.roadLogEvent();
         QCOMPARE(logEvent.int1(), -1);
     }
 }//t_error
 
 void RboxPoints_test::
 t_test()
 {
     // isEmpty -- t_construct
 }//t_test
 
 void RboxPoints_test::
 t_getSet()
 {
     // comment -- t_construct
     // count -- t_construct
     // dimension -- t_construct
 
     RboxPoints rp;
     QCOMPARE(rp.dimension(), 0);
     rp.setDimension(2);
     QCOMPARE(rp.dimension(), 2);
     rp.setDimension(2);
     QCOMPARE(rp.dimension(), 2);
     try{
         rp.setDimension(102);
         QFAIL("setDimension(102) did not fail.");
     }catch (const std::exception &e) {
         cout << "INFO   : Caught " << e.what();
     }
     QCOMPARE(rp.newCount(), 0);
     rp.appendPoints("D2 P1 P2");
     QCOMPARE(rp.count(), 2);
     QCOMPARE(rp.newCount(), 2); // From previous appendPoints();
     PointCoordinates pc(2);
     pc << 1.0 << 0.0 << 2.0 << 0.0;
     QCOMPARE(pc.dimension(), 2);
     QCOMPARE(pc.count(), 2);
     QVERIFY(rp==pc);
     rp.setNewCount(10);  // Normally only used by appendPoints for rbox processing
     QCOMPARE(rp.newCount(), 10);
     rp.reservePoints();
     QVERIFY(rp==pc);
 }//t_getSet
 
 void RboxPoints_test::
 t_foreach()
 {
     RboxPoints rp("c");
     Coordinates::ConstIterator cci= rp.beginCoordinates();
     orgQhull::Coordinates::Iterator ci= rp.beginCoordinates();
     QCOMPARE(*cci, -0.5);
     QCOMPARE(*ci, *cci);
     int i=1;
     while(++cci<rp.endCoordinates()){
         QVERIFY(++ci<rp.endCoordinates());
         QCOMPARE(*cci, *ci);
         i++;
     }
     QVERIFY(++ci==rp.endCoordinates());
     QCOMPARE(i, 8*3);
     orgQhull::Coordinates::Iterator ci4= rp.beginCoordinates(4);
     QCOMPARE(rp.endCoordinates()-ci4, 4*3);
     orgQhull::Coordinates::ConstIterator cci4= rp.beginCoordinates(4);
     orgQhull::Coordinates::ConstIterator cci5= rp.endCoordinates();
     QCOMPARE(cci5-cci4, 4*3);
 }//t_foreach
 
 void RboxPoints_test::
 t_change()
 {
     RboxPoints rp("c D2");
     stringstream s;
     s << "4 count" << endl;
     s << "2 dimension" << endl;
     s << "1 2 3 4 5 6 7 8" << endl;
     rp.appendPoints(s);
     QCOMPARE(rp.count(), 8);
     orgQhull::Coordinates::Iterator ci= rp.beginCoordinates(7);
     QCOMPARE(*ci, 7.0);
     try{
         stringstream s2;
         s2 << "4 count" << endl;
         s2 << "2 dimension" << endl;
         s2 << "1 2 3 4 5 6 7 " << endl;
         rp.appendPoints(s2);
         QFAIL("incomplete appendPoints() did not fail.");
     }catch (const std::exception &e) {
         cout << "INFO   : Caught " << e.what();
     }
     RboxPoints rp2;
     rp2.append(rp);
     QCOMPARE(rp2.count(), 8);
     orgQhull::Coordinates::ConstIterator cci2= rp2.beginCoordinates(6);
     QCOMPARE(*(cci2+1), 6.0);
     rp2.appendPoints("D2 10 P0");
     QCOMPARE(rp2.count(), 19);
     orgQhull::Coordinates::ConstIterator cie= rp2.beginCoordinates(8);
     QCOMPARE(*cie, 0.0);
     RboxPoints rp3;
     coordT points[] = { 0, 1,1,0,1,1,0,0};
     rp3.setDimension(2);
     rp3.append(8,points);
     QCOMPARE(rp3.count(), 4);
     orgQhull::Coordinates::Iterator ci3= rp3.beginCoordinates(3);
     QCOMPARE(*ci3, 0.0);
 }//t_change
 
 void RboxPoints_test::
 t_ostream()
 {
     RboxPoints rp("c D2");
     ostringstream oss;
     oss << rp;
     string s= oss.str();
     QString qs= QString::fromStdString(s);
     QCOMPARE(qs.count("-0.5"), 4);
 }//t_ostream
 
 }//orgQhull
 
 #include "moc/RboxPoints_test.moc"
diff --git a/src/qhullrtest/RoadTest.cpp b/src/qhullptest/RoadTest.cpp
similarity index 90%
rename from src/qhullrtest/RoadTest.cpp
rename to src/qhullptest/RoadTest.cpp
index eefdc59..1920114 100644
--- a/src/qhullrtest/RoadTest.cpp
+++ b/src/qhullptest/RoadTest.cpp
@@ -1,84 +1,84 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/RoadTest.cpp#1 $$Change: 1640 $
-** $Date: 2014/01/15 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/RoadTest.cpp#1 $$Change: 1652 $
+** $Date: 2014/01/17 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include <stdexcept>
 #include "RoadTest.h"
 
 using std::cout;
 using std::endl;
 
 namespace orgQhull {
 
 #//class variable
 
 QList<RoadTest*> RoadTest::
 s_testcases;
 
 int RoadTest::
 s_test_count= 0;
 
 int RoadTest::
 s_test_fail= 0;
 
 QStringList RoadTest::
 s_failed_tests;
 
 #//Slot
 
 //! Executed after each test
 void RoadTest::
 cleanup()
 {
     s_test_count++;
     if(QTest::currentTestFailed()){
         recordFailedTest();
     }
 }//cleanup
 
 #//Helper
 
 void RoadTest::
 recordFailedTest()
 {
     s_test_fail++;
     QString className= metaObject()->className();
     s_failed_tests << className + "::" + QTest::currentTestFunction();
 }
 
 #//class function
 
 int RoadTest::
 runTests(QStringList arguments)
 {
     int result= 0; // assume success
 
     foreach(RoadTest *testcase, s_testcases){
         try{
             result += QTest::qExec(testcase, arguments);
         }catch(const std::exception &e){
             cout << "FAIL!  : Threw error ";
             cout << e.what() << endl;
     s_test_count++;
             testcase->recordFailedTest();
             // Qt 4.5.2 OK.  In Qt 4.3.3, qtestcase did not clear currentTestObject
         }
     }
     if(s_test_fail){
         cout << "Failed " << s_test_fail << " of " << s_test_count << " tests.\n";
         cout << s_failed_tests.join("\n").toLocal8Bit().constData() << std::endl;
     }else{
         cout << "Passed " << s_test_count << " tests.\n";
     }
     return result;
 }//runTests
 
 }//orgQhull
 
 #include "moc/moc_RoadTest.cpp"
diff --git a/src/qhullrtest/RoadTest.h b/src/qhullptest/RoadTest.h
similarity index 91%
rename from src/qhullrtest/RoadTest.h
rename to src/qhullptest/RoadTest.h
index a234c79..4826711 100644
--- a/src/qhullrtest/RoadTest.h
+++ b/src/qhullptest/RoadTest.h
@@ -1,101 +1,101 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/RoadTest.h#1 $$Change: 1640 $
-** $Date: 2014/01/15 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/RoadTest.h#1 $$Change: 1652 $
+** $Date: 2014/01/17 $$Author: bbarber $
 **
 ****************************************************************************/
 
 #ifndef ROADTEST_H
 #define ROADTEST_H
 
 //pre-compiled with RoadTest.h
 #include <QObject>    // Qt C++ Framework
 #include <QtTest/QtTest>
 
 #define QHULL_USES_QT 1
 
 namespace orgQhull {
 
 #//!\name Defined here
 
     //! RoadTest -- Generic test for Qt's QTest
     class RoadTest;
     //! TESTadd_(t) -- Add a RoadTest
 
 /** Test Name objects using Qt's QTestLib
 
 Template:
 
 class Name_test : public RoadTest
 {
     Q_OBJECT
 #//Test slot
 private slots:
     void t_name();
     //Executed before any test
     void initTestCase();
     void init();          // Each test
     //Executed after each test
     void cleanup(); //RoadTest::cleanup();
     // Executed after last test
     void cleanupTestCase();
 };
 
 void
 add_Name_test()
 {
     new Name_test();
 }
 
 Send additional output to cout
 */
 
 class RoadTest : public QObject
 {
     Q_OBJECT
 
 #//!\name Class globals
 protected:
     static QList<RoadTest *>
                         s_testcases; ///! List of testcases to execute.  Initialized via add_...()
     static int          s_test_count; ///! Total number of tests executed
     static int          s_test_fail; ///! Number of failed tests
     static QStringList  s_failed_tests; ///! List of failed tests
 
 #//!\name Test slots
 public slots:
     void cleanup();
 
 public:
 #//!\name Constructors, etc.
     RoadTest()  { s_testcases.append(this); }
     ~RoadTest() { s_testcases.removeAll(this); }
 
 #//Helper
     void                recordFailedTest();
 
 
 #//!\name Class functions
     static int          runTests(QStringList arguments);
 
 };//RoadTest
 
 #define TESTadd_(t) extern void t(); t();
 
 
 }//orgQhull
 
 namespace QTest{
 
 template<>
 inline char *
 toString(const std::string &s)
 {
     return qstrdup(s.c_str());
 }
 
 }//namespace QTest
 
 #endif //ROADTEST_H
 
diff --git a/src/qhullptest/UsingLibQhull_test.cpp b/src/qhullptest/UsingLibQhull_test.cpp
new file mode 100644
index 0000000..3c4f529
--- /dev/null
+++ b/src/qhullptest/UsingLibQhull_test.cpp
@@ -0,0 +1,210 @@
+/****************************************************************************
+**
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/UsingLibQhull_test.cpp#1 $$Change: 1652 $
+** $DateTime: 2014/01/17 09:01:32 $$Author: bbarber $
+**
+****************************************************************************/
+
+//pre-compiled headers
+#include <iostream>
+#include "RoadTest.h" // QT_VERSION
+
+#include "UsingLibQhull.h"
+#include "QhullError.h"
+#include "Qhull.h"
+
+using std::cout;
+using std::endl;
+using std::string;
+
+namespace orgQhull {
+
+//! Test C++ interface to Qhull
+//! See eg/q_test for tests of Qhull commands
+class UsingLibQhull_test : public RoadTest
+{
+    Q_OBJECT
+
+#//Test slots
+private slots:
+    void cleanup();
+    void t_classMembers();
+    void t_globalPoints();
+    void t_UsingLibQhull();
+    void t_methods();
+    void t_cleanuptestcase();
+};//UsingLibQhull_test
+
+void
+add_UsingLibQhull_test()
+{
+    new UsingLibQhull_test();
+}
+
+//Executed after each testcase
+void UsingLibQhull_test::
+cleanup()
+{
+    UsingLibQhull::checkQhullMemoryEmpty();
+    RoadTest::cleanup();
+}
+
+void UsingLibQhull_test::
+t_classMembers()
+{
+    {
+        //checkQhullMemoryEmpty tested by cleanup()
+        QCOMPARE(UsingLibQhull::globalMachineEpsilon()+1.0, 1.0);
+        RboxPoints r10("10");
+        Qhull q(r10,"v");  // voronoi diagram of 10 points
+        UsingLibQhull::unsetGlobalAngleEpsilon();
+        UsingLibQhull::unsetGlobalDistanceEpsilon();
+        cout << "MachineEpsilon " << UsingLibQhull::globalMachineEpsilon()
+            << " angleEpsilon " << UsingLibQhull::globalAngleEpsilon()
+            << " distanceEpsilon " << UsingLibQhull::globalDistanceEpsilon()
+            << endl;
+        QCOMPARE(UsingLibQhull::currentAngleEpsilon()+1.0, 1.0);
+        QVERIFY(UsingLibQhull::currentAngleEpsilon() > UsingLibQhull::globalMachineEpsilon());
+        QCOMPARE(UsingLibQhull::currentDistanceEpsilon()+1.0, 1.0);
+        QVERIFY(UsingLibQhull::currentDistanceEpsilon() >= UsingLibQhull::currentAngleEpsilon());
+        QCOMPARE(UsingLibQhull::currentQhull().runId(), q.runId());
+        QCOMPARE(UsingLibQhull::globalAngleEpsilon()+1.0, UsingLibQhull::currentAngleEpsilon()+1.0);
+        QCOMPARE(UsingLibQhull::currentVertexDimension(), q.dimension());
+        QCOMPARE(UsingLibQhull::globalDistanceEpsilon()+1.0, UsingLibQhull::currentDistanceEpsilon()+1.0);
+        UsingLibQhull::setGlobalAngleEpsilon(1.0);
+        UsingLibQhull::setGlobalDistanceEpsilon(1.0);
+        cout << " Global angleEpsilon " << UsingLibQhull::globalAngleEpsilon()
+            << " distanceEpsilon " << UsingLibQhull::globalDistanceEpsilon()
+            << endl;
+        QCOMPARE(UsingLibQhull::globalAngleEpsilon(), UsingLibQhull::globalDistanceEpsilon());
+        QVERIFY(UsingLibQhull::currentAngleEpsilon() != UsingLibQhull::globalAngleEpsilon());
+        UsingLibQhull::setGlobalVertexDimension(3);
+        QCOMPARE(UsingLibQhull::globalVertexDimension(), UsingLibQhull::currentVertexDimension());
+        UsingLibQhull::setGlobalVertexDimension(2);
+        QCOMPARE(UsingLibQhull::globalVertexDimension(), 2);
+        QCOMPARE(UsingLibQhull::currentVertexDimension(), q.dimension());
+        QVERIFY(UsingLibQhull::currentDistanceEpsilon() != UsingLibQhull::globalDistanceEpsilon());
+        UsingLibQhull::unsetGlobalAngleEpsilon();
+        UsingLibQhull::unsetGlobalVertexDimension();
+        UsingLibQhull::unsetGlobalDistanceEpsilon();
+        QCOMPARE(UsingLibQhull::currentAngleEpsilon()+1.0, UsingLibQhull::globalAngleEpsilon()+1.0);
+        QCOMPARE(UsingLibQhull::globalVertexDimension(), UsingLibQhull::currentVertexDimension());
+        QCOMPARE(UsingLibQhull::currentDistanceEpsilon()+1.0, UsingLibQhull::globalDistanceEpsilon()+1.0);
+        UsingLibQhull::setGlobals();
+    }
+    QCOMPARE(UsingLibQhull::globalAngleEpsilon()+1.0, 1.0);
+    QCOMPARE(UsingLibQhull::globalVertexDimension(), 4); // 'v'.  VertexDimension is only used for QhullVertex where dim>15
+    QCOMPARE(UsingLibQhull::globalDistanceEpsilon()+1.0, 1.0);
+    UsingLibQhull::unsetGlobals();
+    try{
+        cout << UsingLibQhull::globalVertexDimension();
+        QFAIL("Did not throw error for undefined dimension.");
+    }catch(const std::exception &e){
+        cout << "INFO     Caught error -- " << e.what() << endl;
+    }
+}//t_classMembers
+
+void UsingLibQhull_test::
+t_globalPoints()
+{
+    const coordT *r10PointsBegin;
+    {
+        RboxPoints r10("10");
+        Qhull q(r10,"v");  // voronoi diagram of 10 points
+        UsingLibQhull::unsetGlobalPoints();
+        int dimension;
+        const coordT *pointsEnd;
+        const coordT *pointsBegin= UsingLibQhull::globalPoints(&dimension, &pointsEnd);
+        cout << "pointsBegin " << pointsBegin
+            << " pointsEnd " << pointsEnd
+            << " dimension " << dimension
+            << endl;
+        int dimension2;
+        const coordT *pointsEnd2;
+        const coordT *pointsBegin2= UsingLibQhull::currentPoints(&dimension2, &pointsEnd2);
+        QCOMPARE(pointsBegin2, pointsBegin);
+        QCOMPARE(pointsEnd2, pointsEnd);
+        QCOMPARE(dimension2, dimension);
+        coordT c[]= { 1.0,2.0, 3.0,4.0, 5.0,6.0 };
+        UsingLibQhull::setGlobalPoints(2, c, c+3*2);
+        pointsBegin= UsingLibQhull::globalPoints(&dimension, &pointsEnd);
+        QCOMPARE(pointsBegin, c);
+        QCOMPARE(pointsEnd[-1], 6.0);
+        QCOMPARE(dimension, 2);
+        UsingLibQhull::unsetGlobalPoints();
+        pointsBegin= UsingLibQhull::globalPoints(&dimension, &pointsEnd);
+        QCOMPARE(pointsBegin, pointsBegin2);
+        QCOMPARE(pointsEnd, pointsEnd2);
+        QCOMPARE(dimension, dimension2);
+        UsingLibQhull::setGlobals();
+        r10PointsBegin= pointsBegin;
+    }
+    int dimension3;
+    const coordT *pointsEnd3;
+    const coordT *pointsBegin3= UsingLibQhull::currentPoints(&dimension3, &pointsEnd3);
+    QCOMPARE(pointsBegin3, r10PointsBegin); // Memory was freed
+    QCOMPARE(pointsEnd3, r10PointsBegin+10*4);
+    QCOMPARE(dimension3, 4);
+    UsingLibQhull::unsetGlobals();
+    try{
+        pointsBegin3= UsingLibQhull::globalPoints(&dimension3, &pointsEnd3);
+        QFAIL("Did not throw error for undefined global points.");
+    }catch(const std::exception &e){
+        cout << "INFO     Caught error -- " << e.what() << endl;
+    }
+}//t_globalPoints
+
+void UsingLibQhull_test::
+t_UsingLibQhull()
+{
+    {
+        Qhull q;
+        UsingLibQhull uq(&q); // Normally created in a method using 'this'
+
+        try{
+            Qhull q2; // If qh_QHpointer, QhullQh() calls usinlibqhull()
+            UsingLibQhull uq2(&q2);
+            QFAIL("UsingLibQhull did not fail.");
+        }catch (const std::exception &e) {
+            cout << "INFO   : Caught " << e.what();
+        }
+    }
+    Qhull q3;
+    UsingLibQhull uq3(&q3);
+    // UsingLibQhull uq4; // Default constructors disabled.
+}//t_UsingLibQhull
+
+void UsingLibQhull_test::
+t_methods()
+{
+    Qhull q;
+    UsingLibQhull u(&q); // Normally created in a method using 'this'
+    QVERIFY(u.defined());
+    u.maybeThrowQhullMessage(0);  // Nothing thrown
+    try{
+        u.maybeThrowQhullMessage(1);
+        QFAIL("maybeThrowQhullMessage(1) did not fail.");
+    }catch (const std::exception &e) {
+        cout << "INFO   : Caught " << e.what();
+    }
+    // Can not check checkRunId() in maybeThrowQhullMessage().  Requires another thread.
+    u.maybeThrowQhullMessage(2, UsingLibQhull::NOthrow);
+    try{
+        throw QhullError(10054, "Report previous NOthrow error");
+    }catch (const std::exception &e) {
+        cout << "INFO   : " << e.what();
+    }
+}//t_methods
+
+// Executed after last test
+void UsingLibQhull_test::
+t_cleanuptestcase()
+{
+    UsingLibQhull::unsetGlobals();
+}//t_cleanuptestcase
+
+}//orgQhull
+
+#include "moc/UsingLibQhull_test.moc"
+
diff --git a/src/qhullrtest/qhullrtest.cpp b/src/qhullptest/qhullptest.cpp
similarity index 92%
rename from src/qhullrtest/qhullrtest.cpp
rename to src/qhullptest/qhullptest.cpp
index 935b012..f095254 100644
--- a/src/qhullrtest/qhullrtest.cpp
+++ b/src/qhullptest/qhullptest.cpp
@@ -1,86 +1,86 @@
 /****************************************************************************
 **
-** Copyright (c) 2008-2012 C.B. Barber. All rights reserved.
-** $Id: //main/2011/qhull/src/qhullrtest/qhullrtest.cpp#1 $$Change: 1640 $
-** $DateTime: 2014/01/15 09:12:08 $$Author: bbarber $
+** Copyright (c) 2008-2014 C.B. Barber. All rights reserved.
+** $Id: //main/2011/qhull/src/qhullptest/qhullptest.cpp#1 $$Change: 1653 $
+** $DateTime: 2014/01/17 10:27:02 $$Author: bbarber $
 **
 ****************************************************************************/
 
 //pre-compiled headers
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <stdexcept>
 #include "RoadTest.h"
 
 #include "../libqhullcpp/RoadError.h"
 
 using std::cout;
 using std::endl;
 
 namespace orgQhull {
 
 void addQhullTests(QStringList &args)
 {
     TESTadd_(add_QhullVertex_test); //copy
 
     if(args.contains("--all")){
         args.removeAll("--all");
         // up-to-date
         TESTadd_(add_Coordinates_test);
         TESTadd_(add_PointCoordinates_test);
         TESTadd_(add_QhullFacet_test);
         TESTadd_(add_QhullFacetList_test);
         TESTadd_(add_QhullFacetSet_test);
         TESTadd_(add_QhullHyperplane_test);
         TESTadd_(add_QhullLinkedList_test);
         TESTadd_(add_QhullPoint_test);
         TESTadd_(add_QhullPoints_test);
         TESTadd_(add_QhullPointSet_test);
         TESTadd_(add_QhullRidge_test);
         TESTadd_(add_QhullSet_test);
         TESTadd_(add_QhullVertex_test);
         TESTadd_(add_RboxPoints_test);
         TESTadd_(add_UsingLibQhull_test);
         // needs review
         // qhullStat
         TESTadd_(add_Qhull_test);
     }//--all
 }//addQhullTests
 
 int main(int argc, char *argv[])
 {
     QCoreApplication app(argc, argv);
     QStringList args= app.arguments();
     bool isAll= args.contains("--all");
     addQhullTests(args);
     int status=1010;
     try{
         status= RoadTest::runTests(args);
     }catch(const std::exception &e){
         cout << "FAIL!  : runTests() did not catch error\n";
         cout << e.what() << endl;
         if(!RoadError::emptyGlobalLog()){
             cout << RoadError::stringGlobalLog() << endl;
             RoadError::clearGlobalLog();
         }
     }
     if(!RoadError::emptyGlobalLog()){
         cout << RoadError::stringGlobalLog() << endl;
         RoadError::clearGlobalLog();
     }
     if(isAll){
         cout << "Finished test of libqhullcpp.  Test libqhull with eg/q_test" << endl;
     }else{
         cout << "Finished test of one class.  Test all classes with 'qhulltest --all'" << endl;
     }
     return status;
 }
 
 }//orgQhull
 
 int main(int argc, char *argv[])
 {
     return orgQhull::main(argc, argv); // Needs RoadTest:: for TESTadd_() linkage
 }
 
diff --git a/src/qhullrtest/qhullrtest.pro b/src/qhullptest/qhullptest.pro
similarity index 84%
rename from src/qhullrtest/qhullrtest.pro
rename to src/qhullptest/qhullptest.pro
index dce1404..d9cedaf 100644
--- a/src/qhullrtest/qhullrtest.pro
+++ b/src/qhullptest/qhullptest.pro
@@ -1,34 +1,34 @@
 # -------------------------------------------------
-# qhulltest.pro -- Qt project for qhulltest.exe (QTestLib)
+# qhulltest.pro -- Qt project for qhullptest.exe (QTestLib)
 # -------------------------------------------------
 
 include(../qhull-app-cpp.pri)
 
-TARGET = qhulltest
+TARGET = qhullptest
 CONFIG += qtestlib
 MOC_DIR = moc
 INCLUDEPATH += ..  # for MOC_DIR
 
 PRECOMPILED_HEADER = RoadTest.h
 
-SOURCES += ../libqhullcpp/qt-qhull.cpp
+SOURCES += ../libqhullpcpp/qt-qhull.cpp
 SOURCES += Coordinates_test.cpp
 SOURCES += PointCoordinates_test.cpp
 SOURCES += Qhull_test.cpp
 SOURCES += QhullFacet_test.cpp
 SOURCES += QhullFacetList_test.cpp
 SOURCES += QhullFacetSet_test.cpp
 SOURCES += QhullHyperplane_test.cpp
 SOURCES += QhullLinkedList_test.cpp
 SOURCES += QhullPoint_test.cpp
 SOURCES += QhullPoints_test.cpp
 SOURCES += QhullPointSet_test.cpp
 SOURCES += QhullRidge_test.cpp
 SOURCES += QhullSet_test.cpp
-SOURCES += qhulltest.cpp
+SOURCES += qhullptest.cpp
 SOURCES += QhullVertex_test.cpp
 SOURCES += RboxPoints_test.cpp
 SOURCES += RoadTest.cpp
 SOURCES += UsingLibQhull_test.cpp
 
 HEADERS += RoadTest.h
diff --git a/src/qhullr/qhullr.pro b/src/qhullr/qhullr.pro
index 74af2ab..a1ad790 100644
--- a/src/qhullr/qhullr.pro
+++ b/src/qhullr/qhullr.pro
@@ -1,28 +1,9 @@
 # -------------------------------------------------
 # qhullr.pro -- Qt project file for qhullr.exe
 # -------------------------------------------------
 
-TARGET = qhullr
-
-include(../qhull-warn.pri)
-
-DESTDIR = ../../bin
-TEMPLATE = app
-CONFIG += console warn_on
-CONFIG -= qt
-
-LIBS += -L../../lib
-build_pass:CONFIG(debug, debug|release){
-   LIBS += -lqhullstatic_rd
-   OBJECTS_DIR = Debug
-}else:build_pass:CONFIG(release, debug|release){
-   LIBS += -lqhullstatic_r
-   OBJECTS_DIR = Release
-}
-win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
-
-INCLUDEPATH += ../libqhullr
-CONFIG += qhull_warn_conversion
+include(../qhull-app-c_r.pri)
 
+TARGET = qhullr
 
 SOURCES += unix_r.c
diff --git a/src/rboxr/rboxr.pro b/src/rboxr/rboxr.pro
index 20e878a..59d16d9 100644
--- a/src/rboxr/rboxr.pro
+++ b/src/rboxr/rboxr.pro
@@ -1,28 +1,9 @@
 # -------------------------------------------------
 # rboxr.pro -- Qt project for rboxr.exe
 # -------------------------------------------------
 
-TARGET = rboxr
-
-include(../qhull-warn.pri)
-
-DESTDIR = ../../bin
-TEMPLATE = app
-CONFIG += console warn_on
-CONFIG -= qt
-
-LIBS += -L../../lib
-build_pass:CONFIG(debug, debug|release){
-   LIBS += -lqhullstatic_rd
-   OBJECTS_DIR = Debug
-}else:build_pass:CONFIG(release, debug|release){
-   LIBS += -lqhullstatic_r
-   OBJECTS_DIR = Release
-}
-win32-msvc* : QMAKE_LFLAGS += /INCREMENTAL:NO
-
-INCLUDEPATH += ../libqhullr
-CONFIG += qhull_warn_conversion
+include(../qhull-app-c_r.pri)
 
+TARGET = rboxr
 
 SOURCES += rbox_r.c
diff --git a/src/user_eg3/user_eg3.pro b/src/user_eg3/user_eg3.pro
index cb17b17..73b9ff6 100644
--- a/src/user_eg3/user_eg3.pro
+++ b/src/user_eg3/user_eg3.pro
@@ -1,10 +1,10 @@
 # -------------------------------------------------
 # user_eg3.pro -- Qt project for cpp demonstration user_eg3.exe
 # -------------------------------------------------
 
-include(../qhull-app-cpp.pri)
+include(../qhull-app-cpp_p.pri)
 
 TARGET = user_eg3
 CONFIG -= qt
 
 SOURCES += user_eg3.cpp