Support using OpenQMC for Cauchy/Crofton sampling instead of PRNG

facetize: add source-guided adaptive SPSR
Fixed-size point dumps make Poisson reconstruction unreliable as a last-resort facetization method. They can miss thin partitions while oversampling surfaces that are already well resolved, and an arbitrary point count does not show whether source characterization is complete. Seed reconstruction with stabilized Crofton samples. Retain paired entry and exit normals, partition thickness, and ray identities so thin geometry contributes explicit local information instead of unrelated points. Add a bounded adaptive libbg driver around the existing upstream Poisson solver. Each solve reports residual, density, normal, and surface-variation hints to a caller callback. Facetize responds with exact source rays and validates partitions, endpoints, chord length, area, volume, and closed-manifold topology before accepting a result. Bound refinement by time, point, pass, and convergence limits. Relax only chord and thin-partition thresholds when the source BoT is already known to be non-manifold. Deprecate the fixed-array API, remove the intermediate point-sampling path, adapt pnts callers, and add focused coverage. The vendored SPSR implementation remains unchanged. Use configured method priority for perturbation variants so an MDC-only run never invokes NMG. Report finalization progress and retry counts while the fallback hierarchy is evaluated.
2026-09-18 09:59:52 -04:00 · 2026-09-18 09:59:52 -04:00 · 2026-09-18 09:59:52 -04:00 · 2026-09-18 09:59:52 -04:00 · 2026-09-18 09:59:52 -04:00 · 2026-09-18 09:59:52 -04:00
277 changed files with 17717 additions and 32503 deletions
@@ -384,7 +384,7 @@ jobs:
  osx:
    name: macOS Clang
    needs: [linux]
-    runs-on: macos-15
+    runs-on: macos-14
    strategy:
      fail-fast: true
    steps:
@@ -403,7 +403,7 @@ jobs:
      - name: Prepare bext dependencies
        uses: ./brlcad/.github/actions/prepare-bext
        with:
-          platform-channel: macos-15-${{ runner.arch }}-release
+          platform-channel: macos-14-${{ runner.arch }}-release
          source-dir: ${{ github.workspace }}/brlcad
          output-dir: ${{ runner.temp }}/bext_output
          build-type: Release
@@ -177,7 +177,7 @@ jobs:
  osx_bext:
    name: macOS - BRL-CAD bext build
    needs: [linux_bext]
-    runs-on: macos-15
+    runs-on: macos-14
    strategy:
      fail-fast: true
    if: ${{ !cancelled() }}
@@ -231,7 +231,7 @@ set(CMAKE_FIND_USE_PACKAGE_REGISTRY FALSE)
 # Prepare to manage and build BRL-CAD's external dependencies. Specifies a
 # specific commit hash to use in the 'bext' repository.
 include(BRLCAD_ExternalDeps)
-brlcad_bext_init(42d8d7ca57f9d2f61192b41f0b41a731f1ba6c47)
+brlcad_bext_init(12115e6c5922e2db27a9b88e00dd714af5315f69)

 #---------------------------------------------------------------------
 # Define various utilities.
@@ -352,10 +352,9 @@ set(CMAKE_SKIP_BUILD_RPATH FALSE)
 # it should only be set to the installation value when actually installed.
 set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)

-# Installed runtime paths are defined explicitly below.  Do not append
-# directories discovered on the build host, since those paths may not exist
-# or may resolve to unrelated libraries on the installed system.
-set(CMAKE_INSTALL_RPATH_USE_LINK_PATH FALSE)
+# Add the automatically determined parts of the RPATH which point to
+# directories outside the build tree to the install RPATH
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)

 # The following logic is what allows binaries to run successfully in the build
 # directory AND install directory.
@@ -679,13 +678,8 @@ endif(MSVC)
 # before use so platforms without GNU/LLVM-style linker options are skipped.
 brlcad_check_linker_flag(C "LINKER:--no-undefined" BRLCAD_LINKER_NO_UNDEFINED_C_FLAG_FOUND)
 brlcad_check_linker_flag(CXX "LINKER:--no-undefined" BRLCAD_LINKER_NO_UNDEFINED_CXX_FLAG_FOUND)
-if(BRLCAD_LINKER_NO_UNDEFINED_C_FLAG_FOUND AND BRLCAD_LINKER_NO_UNDEFINED_CXX_FLAG_FOUND
-   AND NOT BRLCAD_ENABLE_ADDRESS_SANITIZER)
+if(BRLCAD_LINKER_NO_UNDEFINED_C_FLAG_FOUND AND BRLCAD_LINKER_NO_UNDEFINED_CXX_FLAG_FOUND)
  set(BRLCAD_LINKER_NO_UNDEFINED_FLAG "LINKER:--no-undefined" CACHE STRING "Linker flag requiring resolved shared library symbols" FORCE)
-else()
-  # Clang links the AddressSanitizer runtime into executables, leaving its
-  # shared-library instrumentation symbols unresolved until then.
-  set(BRLCAD_LINKER_NO_UNDEFINED_FLAG "" CACHE STRING "Linker flag requiring resolved shared library symbols" FORCE)
 endif()
 brlcad_check_linker_flags(C BRLCAD_LINKER_WHOLE_ARCHIVE_GROUP_C_FLAG_FOUND "LINKER:--whole-archive" "LINKER:--no-whole-archive")
 brlcad_check_linker_flags(CXX BRLCAD_LINKER_WHOLE_ARCHIVE_GROUP_CXX_FLAG_FOUND "LINKER:--whole-archive" "LINKER:--no-whole-archive")
@@ -1648,31 +1642,21 @@ if(NOT MSVC)
  endif(BRLCAD_WARNINGS OR BRLCAD_ENABLE_STRICT)

  if(BRLCAD_ENABLE_COVERAGE)
-    if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-      check_c_flag(fprofile-instr-generate)
-      check_cxx_flag(fprofile-instr-generate)
-      check_c_flag(fcoverage-mapping)
-      check_cxx_flag(fcoverage-mapping)
-      if(NOT FPROFILE_INSTR_GENERATE_C_FLAG_FOUND OR
-         NOT FPROFILE_INSTR_GENERATE_CXX_FLAG_FOUND OR
-         NOT FCOVERAGE_MAPPING_C_FLAG_FOUND OR
-         NOT FCOVERAGE_MAPPING_CXX_FLAG_FOUND)
-        message(FATAL_ERROR "Clang source-based coverage is not supported by this toolchain.")
-      endif()
-      add_compile_options(-fprofile-instr-generate -fcoverage-mapping)
-      add_link_options(-fprofile-instr-generate)
-    else()
-      check_c_flag(ftest-coverage)
-      check_cxx_flag(ftest-coverage)
-      if(FTEST_COVERAGE_C_FLAG_FOUND AND FTEST_COVERAGE_CXX_FLAG_FOUND)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
-        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lgcov -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lgcov -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
-      else()
-        message(FATAL_ERROR "GCC coverage is not supported by this toolchain.")
-      endif()
-    endif()
+    # TODO: These seem to GCC specific flags - should probably set up for clang
+    # as well if that's our compiler...
+    # https://clang.llvm.org/docs/SourceBasedCodeCoverage.html
+    # If we need different settings for different tools, should
+    # encapsulate each tool's setup in a function
+    check_c_flag(ftest-coverage)
+    check_cxx_flag(ftest-coverage)
+    if(FTEST_COVERAGE_C_FLAG_FOUND)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
+      set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lgcov -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
+      set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lgcov -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
+    else(FTEST_COVERAGE_C_FLAG_FOUND)
+      message(SEND_ERROR "Building with coverage is not supported by BRL-CAD on this platform.")
+    endif(FTEST_COVERAGE_C_FLAG_FOUND)
  endif(BRLCAD_ENABLE_COVERAGE)

  if(BRLCAD_ENABLE_STRICT)
@@ -151,13 +151,10 @@ recommended for serious developers.

 Various useful configurations for working with bext:

-* Acquire bext and its dependencies from another repository host
+* Get a git clone that has everything which might be needed (large,
+  but useful for offline building)

-cmake .. -DBRLCAD_REPOSITORY_ROOT=https://git.example.org/brlcad
-
-* Acquire bext and its dependencies from local bare Git mirrors
-
-cmake .. "-DBRLCAD_REPOSITORY_ROOT=/path/to/mirror/BRL-CAD"
+git clone --recurse-submodules https://github.com/BRL-CAD/brlcad

 * Have prebuilt bext outputs to reuse - BRL-CAD will simply copy and prepare
  the pre-existing files
@@ -401,40 +398,10 @@ Aliases:  ENABLE_RUNTIME_DEBUG, ENABLE_RUN_TIME_DEBUG, ENABLE_RUNTIME_DEBUGGING
          ENABLE_RUN_TIME_DEBUGGING


--- BRLCAD_REPOSITORY_ROOT ---
-
-Repository URL or local directory containing bext and its dependency
-repositories. Defaults to https://github.com/BRL-CAD. The root directly
-contains repositories such as bext.git and astyle.git; BRL-CAD does not
-append BRL-CAD to the root.
-
-Remote Git URLs (including SSH), native paths, and file:// URLs are supported.
-Relative native paths are resolved against the BRL-CAD source directory.
-Quote the entire -D argument for paths containing spaces. The setting is
-cached and is also passed as BEXT_REPOSITORY_ROOT when BRL-CAD configures
-bext, including when BRLCAD_EXT_SOURCE_DIR supplies an existing checkout.
-Alternate roots require bext sources with BEXT_REPOSITORY_ROOT support.
-
-Local roots restrict CMake-driven Git acquisition and queries to file
-transport, with no online fallback. Mirrors must contain all required pinned
-commits and recursive submodules. Dependencies outside bext's canonical URL
-prefix require their own Git URL mappings. This setting does not restrict
-network access by dependency build scripts or change persistent Git settings.
-BRLCAD_EXT_DIR still selects prebuilt outputs, and changing the repository
-root alone does not force those outputs to be rebuilt.
-
-To return to the default source:
-
-cmake .. -DBRLCAD_REPOSITORY_ROOT=https://github.com/BRL-CAD
-
-
 --- BRLCAD_EXT_DIR ---

 If specified, BRL-CAD will look in this directory for bext compiled outputs to
-bundle and use during the build. Relative paths are resolved against the
-BRL-CAD source directory. Distcheck subconfigures reuse this resolved output
-directory and preserve BRLCAD_REPOSITORY_ROOT, BRLCAD_EXT_SOURCE_DIR, and
-BRLCAD_EXT_PARALLEL when specified.
+bundle and use during the build.


 --- BRLCAD_EXT_SOURCE_DIR ---
@@ -442,8 +409,7 @@ BRLCAD_EXT_PARALLEL when specified.
 If specified, BRL-CAD will look in this directory for bext source files. Use
 this when you have a pre-existing bext clone and don't want BRL-CAD's configure
 process to pull down another copy, but are still looking to have the BRL-CAD
-configure process manage producing bext build outputs. Relative paths are
-resolved against the BRL-CAD source directory.
+configure process manage producing bext build outputs.


 --- BRLCAD_EXT_PARALLEL ---
@@ -10,113 +10,78 @@ descriptive text that emphasizes or further describes significant
 changes made.  See document footer for additional details.

 ----------------------------------------------------------------------
--- 202X-XX-XX  Release 7.48.0                                     ---
+--- 20XX-XX-XX  Release 7.46.0                                     ---
 ----------------------------------------------------------------------

-
----------------------------------------------------------------------
--- 2026-10-12  Release 7.46.0                                     ---
----------------------------------------------------------------------
-
-This release expands geometry conversion and improves modeling
-reliability.  STEP support adds AP203e2, AP214, and AP242
-import/export, native CSG round trips, and AP242 product and
-manufacturing information (PMI) import.  IGES and JT conversion is
-expanded, and new OpenSCAD CSG import/export tools are available.
-
-Facetization is more reliable, NMG solid ray tracing is 10-20 times
-faster, CSG ray tracing is faster, and BoT, DSP, and point-cloud ray
-intersections are corrected.  MGED gains numerous fixes to primitive,
-sketch, and combination editing, drawing, dialogs, and preferences.
-
-New tools support object nesting with arrange, building generation
-with mkbuilding, annotation editing, and primitive repair.  Geometry
-analysis, image utilities, Windows support, documentation, and bundled
-dependencies also receive substantial updates.
-
-* corrected Archer logic for saving window size - Cliff Yapp
-* fixed inside BoT rays, DSP surface normals, PNTS bounds - Cliff Yapp
-* improved mged fallback HTML manual viewer - Cliff Yapp
-* fixed gqa undefined densities and exit status - Chris McGregor
-* added ARBN support to the mged inside command - Cliff Yapp
-* improved HYP neck-ratio labels and BoT face selection - Cliff Yapp
-* fixed mged view panning, edit rotation, & ray queries - Cliff Yapp
-* preserved ARB, CLINE, TGC, & extrusion geometry edits - Cliff Yapp
-* restored mged command prompt focus at GUI startup - Cliff Yapp
-* new documentation on geometry representation schemes - Sean Morrison
-* improved pixscale & bwscale scaling and image piping - Sean Morrison
-* restored pixdiff behavior on .pix, added -b for .bw - Sean Morrison
-* improved facetize fallback methods and reliability - Cliff Yapp
-* updated mged and Archer for Tcl 8.6.18 and Itcl/Itk 4 - Cliff Yapp
+* updated MGED and Archer for Tcl 8.6.18 and Itcl/Itk 4 - Cliff Yapp
 * fixed writes to fileless geometry databases - Cliff Yapp
 * fixed nastran-g handling of large property IDs - Rupesh, Cliff Yapp
-* fixed dxf-g invalid polyface idx crash - Meghna45-code, Cliff Yapp
+* fixed dxf-g invalid polyface index crashes - Meghna45-code, Cliff Yapp
+* fixed Archer primitive editors under Itcl 4 - Cliff Yapp
+* fixed Archer shutdown menu cleanup errors - Cliff Yapp
+* fixed MGED Build Pattern dialog under Itcl 4 - Cliff Yapp
 * fixed TclCAD framebuffer listing and deletion - Cliff Yapp
-* fixed mged Build Pattern progress updates - Cliff Yapp
-* fixed mged search -exec reentry and Ctrl-C crashes - Cliff Yapp
-* fixed mged asynchronous commands and clone progress - Cliff Yapp
-* accelerated large and repeated mged path drawing - Cliff Yapp
+* fixed MGED Build Pattern progress updates - Cliff Yapp
+* fixed MGED search -exec reentry and Ctrl-C crashes - Cliff Yapp
+* fixed MGED asynchronous commands and clone progress - Cliff Yapp
+* accelerated large and repeated MGED path drawing - Cliff Yapp
 * fixed ARB7 inside solid construction - Cliff Yapp
 * fixed direct ARB face and edge-direction editing - Cliff Yapp
 * fixed rtwizard startup with framebuffer contention - Cliff Yapp
 * fixed Archer annotation line display updates - Cliff Yapp
 * fixed Archer sketch scale drift in non-mm databases - Cliff Yapp
 * fixed toggle arrow callbacks during setup - Cliff Yapp
-* fixed Tcl dialogs with multi-word titles and msgs - Cliff Yapp
+* fixed Tcl dialogs with multi-word titles and messages - Cliff Yapp
 * fixed Archer Tank Wizard gun generation - Cliff Yapp
-* fixed mged and Archer sketch arc tangency editing - Cliff Yapp
+* fixed MGED and Archer sketch arc tangency editing - Cliff Yapp
 * fixed Archer ARB4 point 3 editing - Cliff Yapp
 * fixed ARB4 storage from make and mk_arb4 - Cliff Yapp
 * fixed ARB4 and ARB6 center point calculations - Cliff Yapp
-* fixed concurrent mged and rtwizard framebuffer use - Cliff Yapp
-* fixed mged ShotVis editing and reload failures - Cliff Yapp
+* fixed concurrent MGED and rtwizard framebuffer use - Cliff Yapp
+* fixed MGED ShotVis editing and reload failures - Cliff Yapp
 * fixed Tcl widget geometry and selection defects - Cliff Yapp
-* fixed mged BoT editor property handling - Cliff Yapp
-* fixed mged LOD dialog and adaptive BoT wireframes - Cliff Yapp
-* fixed mged Plot, PostScript, and manual launch tools - Cliff Yapp
-* fixed mged Overlap Tool multi-object result handling - Cliff Yapp
+* fixed MGED BoT editor property handling - Cliff Yapp
+* fixed MGED LOD dialog and adaptive BoT wireframes - Cliff Yapp
+* fixed MGED Plot, PostScript, and manual launch tools - Cliff Yapp
+* fixed MGED Overlap Tool multi-object result handling - Cliff Yapp
 * eliminated 16-fold redundant gchecker grid analysis - Cliff Yapp
-* fixed submodel transforms & relative database paths - Sean Morrison
-* fixed Archer tree handling for names with spaces - Cliff Yapp
+* fixed Archer tree handling for object names with spaces - Cliff Yapp
 * fixed RtWizard multi-object edge occlusion handling - Cliff Yapp
 * fixed RtWizard title, About, and preference handling - Cliff Yapp
-* fixed mged startup file false legacy-syntax warnings - Cliff Yapp
-* fixed mged saved-view deletion and collaboration sync - Cliff Yapp
-* fixed mged font preferences apply and persistence - Cliff Yapp
+* fixed MGED startup file false legacy-syntax warnings - Cliff Yapp
+* fixed MGED saved-view deletion and collaboration sync - Cliff Yapp
+* fixed MGED font preferences apply and persistence - Cliff Yapp
 * fixed Archer combination edits changing Boolean trees - Cliff Yapp
 * fixed Archer command-line help startup crash - Cliff Yapp
-* fixed mged Geometry Browser menu and close behavior - Cliff Yapp
-* fixed mged collaboration view unshare crash - Cliff Yapp
-* added override for Archer's preference file location - Cliff Yapp
+* fixed MGED Geometry Browser menu and close behavior - Cliff Yapp
+* fixed MGED collaboration view unshare crash - Cliff Yapp
+* added an override for Archer's preference file location - Cliff Yapp
 * fixed embedded Archer display and mode menus - Cliff Yapp
 * added Archer -h and --help command-line options - Cliff Yapp
 * fixed Archer Help opening the documentation menu - Sean Morrison
-* added arrange nest command for packing db objects - Sean Morrison
-* added mkbuilding for parametric/OSM/CityJSON models - Sean Morrison
+* added arrange nest command for packing database objects - Sean Morrison
+* new mkbuilding tool for parametric/OSM/CityJSON models - Sean Morrison
 * cross-platform BINUNIF and DSP byte-order handling - Sean Morrison
-* improved several cv default behaviors (s,32,64,n) - Sean Morrison
+* improved several cv default behaviors (s, 32, 64, n) - Sean Morrison
 * fixed invalid bot handling bug applying matrices - Sean Morrison
 * improved glTF import robustness via gcv - Sean Morrison
 * fixed bot dump glTF/GLB export; -F is now rejected - Cliff Yapp
 * faster NMG solid ray tracing (10-20x faster) - Sean Morrison
-* preserved prim colors in shaded BoT and B-Rep drawing - Cliff Yapp
-* preserved B-Rep attrs through in-place geometry edits - Cliff Yapp
-* fixed gcv filter arguments w/ one-character values - Cliff Yapp
+* preserved primitive colors in shaded BoT and B-Rep drawing - Cliff Yapp
+* preserved B-Rep attributes through in-place geometry edits - Cliff Yapp
+* fixed gcv filter arguments containing one-character values - Cliff Yapp
 * improved iges-g importer robustness - Cliff Yapp
 * expanded g-iges native CSG and B-Rep export support - Cliff Yapp
 * added IGES import and export support to gcv - Cliff Yapp
-* rt -b query option now supports a single value idx - Sean Morrison
+* rt -b query option now supports a single value index - Sean Morrison
 * fixed .dpix file format portability and icv support - Sean Morrison
 * expanded pixscale support for piped image data - Sean Morrison
 * fixed HYP volume and ARBN totals reported by analyze - Cliff Yapp
-* fixed VOL data-file lookup and missing-data errors - Chris McGregor
-* corrected rtarea sampling/exposed-area calculations - Cliff Yapp
+* corrected rtarea sampling and exposed-area calculations - Cliff Yapp
 * bot split now groups results and preserves mesh data - Cliff Yapp
-* bot decimate now preserves nrmls, UVs, and plate data - Cliff Yapp
+* bot decimate now preserves normals, UVs, and plate data - Cliff Yapp
 * added raytracing support for annotation objects - Cliff Yapp
-* fixed Windows subprocess quoting and empty arguments - Cliff Yapp
-* fixed mged X embedded framebuffer display manager crash - Cliff Yapp
-* fixed Windows drive-letter path handling - Cliff Yapp
+* fixed MGED X embedded framebuffer display manager crash - Cliff Yapp
 * added annotate command for managing annotation objects - Cliff Yapp
 * added repair command for supported invalid primitives - Cliff Yapp
 * changed default new-region material code from 1 to 0 - Keith Bowman
@@ -138,34 +103,26 @@ dependencies also receive substantial updates.
 * added option validation to image & framebuffer tools - Sean Morrison
 * added contributor, API, command, & raytracing guides - Sean Morrison
 * added and updated command and library manual pages - Sean Morrison
-* added pnts write -f xyz export option - Chris McGregor
-* fixed mged ARB5 point editing - Cliff Yapp
-* fixed mged gqa and rtcheck stale overlap plots - Cliff Yapp
-* fixed procedural tree generator crashes - Sean Morrison, Cliff Yapp
-* added gaia Earth models with day/dusk/night textures - Sean Morrison
-* fixed fbcolor ramps & Windows input - Cliff Yapp, Sean Morrison
 * added parashot gravity trajectory path generator - Sean Morrison
-* added metaball pnt scaling (via metaball_move_pnt) - Sean Morrison
+* added metaball point scaling (via metaball_move_pnt) - Sean Morrison
 * all raytracing apps now report object prep failures - Sean Morrison
 * improved fast4-g robustness and error reporting - Cliff Yapp
 * improved robustness of g-vrml plate mode handling - Cliff Yapp
-* added support for tick drawing on mged model axis - Cliff Yapp
+* fixed MGED ARB5 point, pipe, and sketch editing - Cliff Yapp
+* added pnts write -f xyz export option - Chris McGregor
+* added support for tick drawing on MGED model axis - Cliff Yapp
 * added naca456 left and paired wing generation - Cliff Yapp
 * added patch-g -j option, specify object thicknesses - Sean Morrison
-* corrected bwstat median and input error handling - Sean Morrison
+* fixed fbcolor color ramp bug drawing the last color - Sean Morrison
 * fixed gist -Q quick preview option - Sean Morrison
 * rt preserves eye_pt setting in command scripts - Sean Morrison
-* removed trailing whitespace from nirt output - Sean Morrison
 * rt -l8 heat graphs now measure CPU time - Sean Morrison
 * documented gqa centroid & moments of inertia options - Sean Morrison
 * pixdiff now calculates pixel differences on bw files - Sean Morrison
-* fixed bwcrop single-axis crops & pixembed edge fill - Sean Morrison
+* fixed bwcrop single-axis crops and pixembed edge fill - Sean Morrison
 * fixed isize in non-mm databases - Josh Baker
 * fixed metaball adjust clearing points on errors - Sean Morrison
 * fixed benchmark+pixcmp correctness validation bug - Sean Morrison
-* fixed mged gqa option and value parsing - Sean Morrison
-* improved gist hierarchy overflow rendering - Chris McGregor
-* fixed rtxray -o grayscale/BW output - Sean Morrison
 * fbhelp writes help to stdout and rest to stderr - Sean Morrison
 * FB now supports /dev/stdout and /dev/stderr devices - Sean Morrison
 * fixed mged rt -C + -o background color to file bug - Sean Morrison
@@ -174,7 +131,7 @@ dependencies also receive substantial updates.
 * added rtsil -o support for bw output - Sean Morrison
 * added cutting plane animation generation to rtwizard - Cliff Yapp
 * fixed pixdiff bug on Windows - Sean Morrison
-* fixed mged startup window placement on Windows - Chris McGregor
+* fixed MGED startup window placement on Windows - Chris McGregor
 * fixed pixborder utility right-side edge bug - Sean Morrison
 * fixed 'wavelet' image processing tool on Windows - Sean Morrison
 * quieted mged killtree spurious lookup failure output - Sean Morrison
@@ -185,16 +142,14 @@ dependencies also receive substantial updates.
 * new doc guide, a visual overview of BRL-CAD objects - Sean Morrison
 * improved triangle quality produced by bot remesh - Cliff Yapp
 * updated numerous manpage command references - Josh Baker
+* fixed submodel paths relative to parent databases - Sean Morrison
 * improved performance making huge combinations - Sean Morrison
-* added PNTS get, adjust, form, & g2asc/asc2g support - Chris McGregor
-* fixed ANNOT get, adjust, & g2asc/asc2g support - Chris McGregor
 * added make -t primitive type listing - Chris McGregor
 * added gcv import conversion support for vrml/wrl 1.0 - Sean Morrison
 * fixed gcv appending to existing geometry databases - Sean Morrison
 * added CSS names, hex, HSL/HSV to libbu color parsing - Sean Morrison
 * improved OpenNURBS B-Rep import and adjustment safety - Cliff Yapp
-* improved Debian application menus/MIME associations - Jordi Sayol
-* updated Tcl/Tk dependency to v8.6.18 using bundled Itcl - Cliff Yapp
+* improved Debian application menus and MIME associations - Jordi Sayol
 * updated Clipper2 dependency to v1.5.4 - Cliff Yapp
 * updated Eigen dependency to v5.0.1 - Cliff Yapp
 * updated GDAL dependency to v3.13.3 - Cliff Yapp
@@ -206,6 +161,7 @@ dependencies also receive substantial updates.
 * updated OpenNURBS dependency to v8.34.26223.11001 - Cliff Yapp
 * updated PROJ dependency to v9.8.1 - Cliff Yapp
 * updated PoissonRecon dependency to v18.75 - Cliff Yapp
+* updated Tcl/Tk dependency to v8.6.18, using bundled Itcl - Cliff Yapp
 * updated libjpeg-turbo dependency to v3.2.0 - Cliff Yapp
 * updated libosmesa dependency to SHA1 bfa90de - Cliff Yapp
 * updated libpng dependency to v1.6.58 - Cliff Yapp
@@ -314,7 +270,7 @@ and extensively improving existing docs.
 * added metadata-aware image diff & nirt analysis - Cliff Yapp
 * added basic PNTS point-cloud ray tracing - Sean Morrison
 * improved nirt behavior in Windows bash consoles - Cliff Yapp
-* added g2asc/asc2g support for DSP and EBM - Sean Morrison
+* added g2asc/asc2g support for PNTS, DSP, and EBM - Sean Morrison
 * updated gct mesh decimation dependency to mmesh - Cliff Yapp
 * added procedural wing, propeller & tree generators - Cliff Yapp
 * added ISO tire dimensions & named tread presets - Cliff Yapp
@@ -586,7 +542,6 @@ for more information.
 ----------------------------------------------------------------------
 --- 2023-11-06  Release 7.38.0                                     ---
 ----------------------------------------------------------------------
-
 This major release of BRL-CAD introduces significant improvements to
 the robustness of the facetize command by leveraging the Manifold
 library for boolean evaluation of meshes. Facetization is an operation
@@ -625,7 +580,6 @@ processing high level assemblies in BRL-CAD's example geometry files:
 ----------------------------------------------------------------------
 --- 2023-07-26  Release 7.36.0                                     ---
 ----------------------------------------------------------------------
-
 This major release of BRL-CAD introduces significant updates to
 geometry conversion support. The update includes modernization for
 NURBS importing and interaction, BoT manipulation, and incorporates
@@ -1,6 +1,6 @@
-                          BRL-CAD
-                      Release 7.46.0
-                    http://brlcad.org/
+			    BRL-CAD
+			 Release 7.44.2
+		       http://brlcad.org/

 BRL-CAD is a powerful cross-platform open source combinatorial
 solid modeling system that includes an interactive 3D solid geometry
@@ -2668,6 +2668,15 @@ DOCUMENTATION
 	Comparison of how BRL-CAD overlaps feature-wise with various
 	major commercial CAD systems.

+* Solid Geometry Representation Comparisons
+	Describe the implications, tradeoffs, and conversion issues
+	involved when converting between different geometry
+	representations.  Includes describing implicit geometry,
+	explicit polygonal boundary representations, explicit spline
+	surface representations, volumetric models, wireframes,
+	boolean operations, feature edit operations, and parametric
+	modeling.
+
 * BRL-CAD Open Source
 	An overview of how BRL-CAD is organized as an open source
 	project and community describing the developer meritocracy,
@@ -20,7 +20,6 @@ set(
  procedural_geometry.adoc
  projection_shader.adoc
  renderer_showcase.adoc
-  solid_geometry_comparison.adoc
  taxonomy.adoc
  tire.adoc
 )
@@ -228,17 +227,6 @@ set(
  images/renderer_gallery_rthide.png
  images/renderer_gallery_rtdepth.png
  images/renderer_gallery_rtxray.png
-  images/solid_rep_csg.png
-  images/solid_rep_brep_boolean.png
-  images/solid_rep_brep_evaluated.png
-  images/solid_rep_polygonal_boolean.png
-  images/solid_rep_nmg.png
-  images/solid_rep_bot.png
-  images/solid_rep_revolve.png
-  images/solid_rep_voxel_cells.png
-  images/solid_rep_volume.png
-  images/solid_rep_point_cloud.png
-  images/solid_rep_wireframe.png
  images/adrt_castle_path.png
  images/adrt_castle_rt.png
  images/adrt_castle_rt_ao.png
@@ -421,54 +409,6 @@ if(
  set_target_properties(renderer-gallery-snapshot PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD 1)
 endif()

-# Solid geometry comparison -- opt-in regeneration of committed snapshots.
-#
-# The article and solid_rep_*.png images are normal committed documentation.
-# This target rebuilds the common pawn, derives each representation with the
-# built tools, and refreshes the images for review.
-option(
-  BRLCAD_GENERATE_SOLID_REPRESENTATION_COMPARISON
-  "Regenerate the solid geometry representation comparison snapshots"
-  OFF
-)
-if(
-  BRLCAD_GENERATE_SOLID_REPRESENTATION_COMPARISON
-  AND TARGET mged
-  AND TARGET rt
-  AND TARGET g-voxel
-  AND TARGET asc2pix
-  AND TARGET fbclear
-  AND TARGET plot3-fb
-  AND TARGET fb-png
-)
-  add_custom_target(
-    solid-representation-comparison-snapshot
-    COMMAND
-      ${CMAKE_COMMAND}
-      -DMGED=$<TARGET_FILE:mged>
-      -DRT=$<TARGET_FILE:rt>
-      -DGVOXEL=$<TARGET_FILE:g-voxel>
-      -DASC2PIX=$<TARGET_FILE:asc2pix>
-      -DFBCLEAR=$<TARGET_FILE:fbclear>
-      -DPLOT3FB=$<TARGET_FILE:plot3-fb>
-      -DFBPNG=$<TARGET_FILE:fb-png>
-      -DMODEL_SCRIPT=${CMAKE_CURRENT_SOURCE_DIR}/solid_geometry_comparison/create_pawn.tcl
-      -DIMGDIR=${CMAKE_CURRENT_SOURCE_DIR}/images
-      -DWORKDIR=${CMAKE_CURRENT_BINARY_DIR}/solid_representation_comparison_work
-      -DSIZE=512
-      -P ${CMAKE_CURRENT_SOURCE_DIR}/solid_geometry_comparison/generate_comparison.cmake
-    DEPENDS mged rt g-voxel asc2pix fbclear plot3-fb fb-png
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    COMMENT "Regenerating solid geometry representation comparison snapshots"
-    VERBATIM
-    USES_TERMINAL
-  )
-  set_target_properties(
-    solid-representation-comparison-snapshot
-    PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD 1
-  )
-endif()
-
 # ADRT path-tracing gallery -- opt-in regeneration of the committed snapshot.
 #
 # Like the galleries above, the adrt_pathtrace.adoc article is hand-written and
@@ -524,8 +464,6 @@ cmakefiles(
  gallery/generate_gallery.cmake
  renderer_gallery/renderer_gallery_manifest.cmake
  renderer_gallery/generate_renderer_gallery.cmake
-  solid_geometry_comparison/create_pawn.tcl
-  solid_geometry_comparison/generate_comparison.cmake
  adrt_gallery/generate_adrt_gallery.cmake
  gallery/inputs/pipe.stdin
  gallery/inputs/wire.stdin
@@ -1,294 +0,0 @@
-= Solid Geometry Representation Comparisons
-:doctype: article
-:toc:
-:toclevels: 2
-
-The same shape can be stored in very different ways.  This comparison uses a
-purpose-built chess pawn to show which information BRL-CAD retains, evaluates,
-or samples when moving among its principal geometry representations.  It is a
-guide to semantics and conversion choices, not a claim that one representation
-is universally best.
-
-== Common model and method
-
-The reference pawn is a region containing seven overlapping ellipsoids.  Their
-union is non-trivial enough to exercise curved surfaces, overlapping interiors,
-and several component boundaries while remaining reliable across the
-conversions shown here.  The sketch-and-revolve version independently follows
-the same nominal profile; it is not an exact conversion of the seven-piece CSG
-model.
-
-Every shaded image uses the same orthographic view, 512x512 image size,
-material, and single-threaded renderer.  The wireframe uses the same view and
-image size.  The faceting and sampling settings are intentionally coarse enough
-to remain visible.  A similar silhouette therefore does not mean that two
-database objects have the same structure or numerical boundary.
-
-NOTE: This article and its images are a committed snapshot.  Developers can
-regenerate the figures from built BRL-CAD tools by configuring with
-`-DBRLCAD_GENERATE_SOLID_REPRESENTATION_COMPARISON=ON` and building the
-`solid-representation-comparison-snapshot` target.
-
-== At a glance
-
-[cols="2,2,1,2,4",options="header"]
-|===
-|Form
-|BRL-CAD storage
-|Solid?
-|Boolean state
-|Editing and conversion consequences
-
-|Analytic CSG
-|Seven `ell` leaves in a combination
-|Yes
-|Retained
-|Compact primitive parameters and tree edits preserve construction intent.
-
-|B-rep tree
-|Closed `brep` leaves in a combination
-|Yes
-|Retained
-|NURBS surfaces and trims replace analytic leaves, but the assembly tree remains.
-
-|Evaluated B-rep
-|One closed `brep`
-|Yes
-|Evaluated
-|Direct face, edge, trim, and control-point editing is possible; original
-features and hierarchy are gone.
-
-|Polygonal tree
-|Solid-mode `bot` leaves in a combination
-|Yes
-|Retained
-|Leaf tessellation is approximate, but components and their union tree remain
-independently replaceable.
-
-|Evaluated NMG
-|One `nmg`
-|Yes
-|Evaluated
-|Stores explicit, topology-rich polygonal boundaries and can record
-non-manifold relationships.
-
-|Evaluated triangle mesh
-|One solid-mode `bot`
-|Yes
-|Evaluated
-|Portable triangle connectivity, but curved geometry and construction history
-have been sampled away.
-
-|Sketch and revolve
-|One `sketch` referenced by one `revolve`
-|Yes
-|Not needed here
-|The profile, axis, and sweep angle are compact, meaningful parameters.
-
-|Voxel cells
-|A region containing many `arb8` boxes
-|Yes (sampled)
-|Cell union retained
-|Individual cells are ordinary CSG geometry; size grows rapidly as cells
-shrink.
-
-|Sampled volume
-|A file-backed `vol` scalar grid
-|Yes (thresholded)
-|None
-|Compact regular-grid occupancy; resolution and threshold determine the boundary.
-
-|Point cloud
-|One `pnts` object with positions and normals
-|No pawn interior
-|None
-|Useful as measured or sampled evidence, but it has no inherent connected
-boundary or inside/outside rule.
-
-|Wireframe
-|Derived line display of the CSG object
-|No
-|Uses source tree
-|A view-dependent drawing aid, not an independent solid representation.
-|===
-
-"Solid" in this table means that the stored object supplies usable
-inside/outside semantics for the pawn.  An arbitrary B-rep or mesh is not
-automatically a solid: its boundary must be closed and consistently oriented.
-The point size used to render `pnts` makes each sample a small sphere, but those
-spheres do not reconstruct the pawn interior.  A wireframe likewise does not
-become a solid merely because its curves appear closed in one view.
-
-== Implicit and parametric forms
-
-[cols="1,1"]
-[%noheader]
-|===
-|image:images/solid_rep_csg.png[Analytic CSG pawn,512]
-|image:images/solid_rep_revolve.png[Sketch and revolve pawn,512]
-
-|*Analytic CSG.* Native primitives retain their equations and dimensions; the
-region evaluates their union during ray tracing.
-|*Sketch plus revolve.* A closed line-segment profile is swept through 360
-degrees.  The stepped profile is intentional and remains editable in two
-dimensions.
-|===
-
-Analytic CSG is an implicit representation: intersections with ideal primitive
-surfaces are computed as needed rather than read from a stored boundary mesh.
-It is usually the most compact form here and makes edits such as changing the
-head radius or stem proportions direct.  Its Boolean hierarchy also records why the
-shape was assembled.
-
-`sketch` plus `revolve` is another procedural, parameterized description.  It
-works especially well for an axisymmetric part, although a sketch with only
-line segments produces conical and cylindrical bands rather than the pawn's
-original ellipsoidal surfaces.  BRL-CAD supports primitive parameters, placement
-matrices, sketches, and sweeps; that should not be confused with a general
-constraint solver or an associative feature-history system.
-
-== Spline boundary representations
-
-[cols="1,1"]
-[%noheader]
-|===
-|image:images/solid_rep_brep_boolean.png[B-rep leaves with Boolean tree,512]
-|image:images/solid_rep_brep_evaluated.png[Single evaluated B-rep,512]
-
-|*B-rep with Booleans.* Each analytic leaf becomes a closed B-rep whose
-boundaries are trimmed NURBS surfaces.  The original union tree is retained.
-|*B-rep without Booleans.* Boolean evaluation produces one explicit boundary;
-operand identities and the construction tree no longer exist as editable
-features.
-|===
-
-A B-rep stores faces, trims, edges, vertices, and their topology explicitly.
-Rational NURBS can represent the source quadrics exactly as surfaces, but that
-does not make every CSG-to-B-rep conversion exact: intersections, trimming,
-topology classification, and repair use numerical tolerances.  Keeping a tree
-of B-rep leaves isolates conversion to each primitive and retains high-level
-editing.  Evaluating the tree yields a more self-contained boundary for
-exchange and face-level work, at the cost of that history.  This snapshot's
-evaluated result passes both `brep ... valid` and `brep ... solid`; conversion
-results should be checked rather than assumed to be closed.
-
-== Polygonal boundaries
-
-[cols="1,1,1"]
-[%noheader]
-|===
-|image:images/solid_rep_polygonal_boolean.png[BoT leaves with Boolean tree,512]
-|image:images/solid_rep_nmg.png[Evaluated NMG pawn,512]
-|image:images/solid_rep_bot.png[Evaluated BoT pawn,512]
-
-|*Polygonal with Booleans.* Each leaf is independently tessellated to a BoT,
-then placed in the original union tree.
-|*Evaluated NMG.* One non-manifold geometry object records the evaluated
-polygonal boundary and its richer topology.
-|*Evaluated triangle mesh.* One solid, counter-clockwise BoT stores 982
-vertices and 1,960 triangular faces in this snapshot.
-|===
-
-All three images expose the same coarse tessellation.  Their similar appearance
-hides an important distinction: the first still has seven editable operands,
-whereas the NMG and single BoT are evaluated results.  NMG can represent
-polygonal faces and non-manifold adjacency; BoT faces are triangles only.
-Neither recreates analytic curvature when converted back.  Finer tessellation
-reduces visible error but increases storage and processing cost.
-
-== Sampled forms
-
-[cols="1,1,1"]
-[%noheader]
-|===
-|image:images/solid_rep_voxel_cells.png[Pawn represented by CSG voxel cells,512]
-|image:images/solid_rep_volume.png[Pawn represented by a VOL grid,512]
-|image:images/solid_rep_point_cloud.png[Pawn represented by surface points,512]
-
-|*Explicit voxel cells.* `voxelize` tests 3 mm cells and creates a CSG union of
-699 boxes for cells exceeding the occupancy threshold.
-|*Sampled volume.* `g-voxel` samples a 2 mm grid; a file-backed `vol` interprets
-the resulting 17x17x30 byte array through an occupancy window.
-|*Point cloud.* `pnts gen` samples the analytic surface on a 2 mm grid.  Small
-rendered spheres make the otherwise zero-area sample locations visible.
-|===
-
-The two voxel images are deliberately separate.  The `voxelize` command emits
-ordinary box primitives and a combination, while `vol` reads scalar samples on
-a regular grid and derives a threshold boundary at ray-trace time.  Both are
-volumetric approximations whose accuracy, memory, and feature size depend on
-cell spacing.  A point cloud samples only the surface and has no connectivity;
-surface reconstruction requires additional assumptions and may invent or omit
-geometry.
-
-== Wireframe display
-
-image::images/solid_rep_wireframe.png[Wireframe display of the analytic CSG pawn,512]
-
-This wireframe is a view-plane plot of MGED's unevaluated display of the
-analytic CSG pawn; hidden lines are not removed.  Wireframes are useful for
-selection, orientation, and seeing component curves, but they are ambiguous:
-curves alone do not say which side is material, which loops bound faces, or
-which surfaces enclose volume.  Keep the solid that generated the display
-rather than treating the drawing as an equivalent conversion target.
-
-== Conversion and editing consequences
-
-A conversion command is not an equivalence guarantee.  Before replacing source
-data, check at least these effects:
-
-* *Tolerance and resolution:* B-rep Boolean evaluation uses intersection and
-  topology tolerances; tessellation uses chord and angular tolerances; voxels
-  and points use sample spacing and thresholds.  Each can erase a feature
-  smaller than its controlling tolerance.
-* *Construction intent:* evaluating a Boolean tree discards operand identity,
-  primitive parameters, and ordering.  Converting leaves while retaining the
-  tree keeps more of that intent.
-* *Topology:* a visually plausible B-rep or mesh may contain gaps, duplicate
-  faces, self-intersections, or inconsistent orientation.  Validate closure
-  and ray behavior, not only a shaded image.
-* *Attributes:* collapsing a hierarchy may change where region identifiers,
-  materials, colors, and other attributes reside.  Verify them separately
-  from geometry.
-* *Round trips:* CSG to mesh to B-rep does not recover the original equations;
-  points to a surface requires reconstruction; resampling a volume compounds
-  discretization.  Retain the highest-level trustworthy source.
-
-For parameter changes and repeated design work, prefer analytic primitives,
-sketch sweeps, and preserved combination trees.  Prefer a validated B-rep when
-trimmed-surface topology or exchange requires it.  Use NMG for topology-rich
-polygonal processing and BoT for triangle-oriented interchange or algorithms.
-Use voxels for occupancy operations and point clouds for measured or sampled
-data, not as silent substitutes for a watertight solid.
-
-BRL-CAD also supports specialized forms such as DSP height fields, EBM
-extrusions, ARS surfaces, metaballs, and legacy `poly` and `bspline` objects.
-They are not shown as interchangeable pawn encodings: DSP and EBM are
-domain-specific, metaballs change the modeling method, and BoT and B-rep are the
-preferred general successors to the legacy polygon and spline forms.
-
-== Reproducing the conversions
-
-The snapshot generator creates the database and runs these principal MGED
-operations (names shortened here only where noted):
-
-[source]
----
-brep comparison.csg.r brep --no-evaluation
-brep comparison.csg.r brep comparison.brep_evaluated.s
-facetize -n comparison.csg.r comparison.nmg.s
-facetize --methods NMG comparison.csg.r comparison.bot.s
-facetize --methods NMG base.s base.bot        # repeated for all seven leaves
-voxelize -s "3 3 3" -d 4 -t 0.45 comparison.voxel_cells.r comparison.csg.r
-pnts gen -t 2 --surface --grid comparison.csg.r comparison.samples
-pnts write comparison.samples comparison.xyz
-pnts read -f xyzijk --size 0.45 comparison.xyz comparison.point_cloud.s
----
-
-The generator also runs `g-voxel` and expands its sparse occupied-cell report
-into the x-fastest byte array used by `vol`.  It then renders every shaded
-object with `rt -B -M -P1` and the saved view; MGED's `plot -2d`, `plot3-fb`,
-and `fb-png` produce the wireframe image.  See
-`solid_geometry_comparison/generate_comparison.cmake` and
-`solid_geometry_comparison/create_pawn.tcl` for the complete reproducible
-inputs.
@@ -1,24 +0,0 @@
-# Create the shared pawn used by the solid-representation comparison.
-
-title {Solid geometry representation comparison pawn}
-units mm
-
-# Deliberate overlaps keep the pawn connected while exercising curved-surface
-# intersections during Boolean evaluation.
-db put base.s ell V {0 0 4.5} A {17 0 0} B {0 17 0} C {0 0 4.5}
-db put base_bead.s ell V {0 0 9.5} A {14 0 0} B {0 14 0} C {0 0 5}
-db put body.s ell V {0 0 18} A {12 0 0} B {0 12 0} C {0 0 9}
-db put stem.s ell V {0 0 29} A {7 0 0} B {0 7 0} C {0 0 13}
-db put collar.s ell V {0 0 39} A {9 0 0} B {0 9 0} C {0 0 3.5}
-db put neck.s ell V {0 0 43} A {6.5 0 0} B {0 6.5 0} C {0 0 5}
-db put head.s ell V {0 0 50} A {9 0 0} B {0 9 0} C {0 0 9}
-
-db put comparison.csg.r comb region yes id 1000 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {u {u {u {l base.s} {l base_bead.s}} {u {l body.s} {l stem.s}}} {u {u {l collar.s} {l neck.s}} {l head.s}}}
-
-# The revolve uses a deliberately independent outline.  Its single closed
-# sketch approximates the same pawn silhouette without copying the CSG tree.
-db put comparison.profile sketch V {0 0 0} A {1 0 0} B {0 0 1} VL {{0 0} {17 0} {17 2} {16.3 4} {15 6} {14 8} {15.4 7} {16 9} {15.4 11} {13.5 12.5} {11.2 14} {12 18} {11 21} {9.5 23} {8 26} {7.5 32} {6.5 36} {7.5 37} {9 39} {7.5 41} {6.5 42} {6.5 43} {7.5 44} {8.5 46} {9 50} {8.5 54} {6.7 56.5} {0 59}} SL {{line S 0 E 1} {line S 1 E 2} {line S 2 E 3} {line S 3 E 4} {line S 4 E 5} {line S 5 E 6} {line S 6 E 7} {line S 7 E 8} {line S 8 E 9} {line S 9 E 10} {line S 10 E 11} {line S 11 E 12} {line S 12 E 13} {line S 13 E 14} {line S 14 E 15} {line S 15 E 16} {line S 16 E 17} {line S 17 E 18} {line S 18 E 19} {line S 19 E 20} {line S 20 E 21} {line S 21 E 22} {line S 22 E 23} {line S 23 E 24} {line S 24 E 25} {line S 25 E 26} {line S 26 E 27} {line S 27 E 0}}
-db put comparison.revolve.s revolve V {0 0 0} axis {0 0 1} R {1 0 0} ang 6.283185307179586 sk_name comparison.profile
-db put comparison.revolve.r comb region yes id 1001 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {l comparison.revolve.s}
-
-q
@@ -1,372 +0,0 @@
-# Regenerate the solid geometry representation comparison snapshots.
-#
-# The article is hand-written.  This script builds its common pawn model,
-# derives each representation using BRL-CAD tools, and replaces the committed
-# images.  All databases and sidecar data remain in WORKDIR.
-
-cmake_minimum_required(VERSION 3.20)
-
-foreach(v MGED RT GVOXEL ASC2PIX FBCLEAR PLOT3FB FBPNG
-          MODEL_SCRIPT IMGDIR WORKDIR)
-  if(NOT DEFINED ${v})
-    message(FATAL_ERROR "generate_comparison: -D${v}=... is required")
-  endif()
-endforeach()
-
-if(NOT DEFINED SIZE)
-  set(SIZE 512)
-endif()
-
-set(RENDER_TIMEOUT 1800)
-set(PAWN_DB "${WORKDIR}/solid_representation_pawn.g")
-set(VIEW_SCRIPT "${WORKDIR}/pawn.view")
-set(MGED_SCRIPT "${WORKDIR}/assemble_variants.tcl")
-set(VOXELIZE_SCRIPT "${WORKDIR}/voxelize.tcl")
-set(VOXEL_LIST "${WORKDIR}/voxels1.txt")
-set(VOLUME_ASCII "${WORKDIR}/comparison_volume.asc")
-set(VOLUME_FILE "${WORKDIR}/comparison.vol")
-
-file(REMOVE_RECURSE "${WORKDIR}")
-file(MAKE_DIRECTORY "${WORKDIR}")
-file(MAKE_DIRECTORY "${IMGDIR}")
-
-function(run_process label)
-  execute_process(
-    COMMAND ${ARGN}
-    WORKING_DIRECTORY "${WORKDIR}"
-    TIMEOUT ${RENDER_TIMEOUT}
-    RESULT_VARIABLE process_result
-    OUTPUT_VARIABLE process_stdout
-    ERROR_VARIABLE process_stderr
-  )
-  if(NOT process_result EQUAL 0)
-    message(
-      FATAL_ERROR
-      "${label} failed (exit ${process_result})\n${process_stdout}${process_stderr}"
-    )
-  endif()
-  message(STATUS "${label}")
-endfunction()
-
-function(require_brep_property object property expected_output)
-  execute_process(
-    COMMAND "${MGED}" --no-rc -c "${PAWN_DB}" brep "${object}" "${property}"
-    WORKING_DIRECTORY "${WORKDIR}"
-    TIMEOUT ${RENDER_TIMEOUT}
-    RESULT_VARIABLE property_result
-    OUTPUT_VARIABLE property_stdout
-    ERROR_VARIABLE property_stderr
-  )
-  set(property_output "${property_stdout}${property_stderr}")
-  if(NOT property_result EQUAL 0 OR NOT property_output MATCHES "${expected_output}")
-    message(
-      FATAL_ERROR
-      "B-rep ${object} is not ${property}\n${property_output}"
-    )
-  endif()
-  message(STATUS "Validated B-rep ${object}: ${property}")
-endfunction()
-
-execute_process(
-  COMMAND "${MGED}" --no-rc -c "${PAWN_DB}"
-  WORKING_DIRECTORY "${WORKDIR}"
-  TIMEOUT ${RENDER_TIMEOUT}
-  INPUT_FILE "${MODEL_SCRIPT}"
-  RESULT_VARIABLE create_result
-  OUTPUT_VARIABLE create_stdout
-  ERROR_VARIABLE create_stderr
-)
-if(NOT create_result EQUAL 0 OR NOT EXISTS "${PAWN_DB}")
-  message(
-    FATAL_ERROR
-    "Creating the comparison pawn failed (exit ${create_result})\n${create_stdout}${create_stderr}"
-  )
-endif()
-
-# Preserve one Boolean hierarchy as B-rep leaves, and evaluate another into a
-# single B-rep.  The default suffix is intentional: supplying an explicit
-# suffix changes parsing in older MGED versions.
-set(PAWN_LEAVES base base_bead body stem collar neck head)
-run_process(
-  "Created Boolean tree of B-rep leaves"
-  "${MGED}" --no-rc -c "${PAWN_DB}" brep comparison.csg.r brep --no-evaluation
-)
-foreach(leaf IN LISTS PAWN_LEAVES)
-  require_brep_property("${leaf}.s.brep" solid "brep is solid")
-endforeach()
-run_process(
-  "Created evaluated B-rep"
-  "${MGED}" --no-rc -c "${PAWN_DB}" brep comparison.csg.r brep comparison.brep_evaluated.s
-)
-require_brep_property(comparison.brep_evaluated.s valid "brep is valid")
-require_brep_property(comparison.brep_evaluated.s solid "brep is solid")
-
-# Generate both the topology-rich NMG form and the triangle-only BoT form.
-run_process(
-  "Created evaluated NMG"
-  "${MGED}" --no-rc -c "${PAWN_DB}" facetize -n comparison.csg.r comparison.nmg.s
-)
-run_process(
-  "Created evaluated BoT"
-  "${MGED}" --no-rc -c "${PAWN_DB}" facetize --methods NMG comparison.csg.r comparison.bot.s
-)
-
-# Tessellating leaves independently preserves the editable Boolean hierarchy.
-foreach(leaf IN LISTS PAWN_LEAVES)
-  run_process(
-    "Tessellated ${leaf}.s"
-    "${MGED}" --no-rc -c "${PAWN_DB}" facetize --methods NMG "${leaf}.s" "${leaf}.bot"
-  )
-endforeach()
-
-file(WRITE "${VOXELIZE_SCRIPT}" "voxelize -s {3 3 3} -d 4 -t 0.45 comparison.voxel_cells.r comparison.csg.r\nq\n")
-execute_process(
-  COMMAND "${MGED}" --no-rc -c "${PAWN_DB}"
-  WORKING_DIRECTORY "${WORKDIR}"
-  TIMEOUT ${RENDER_TIMEOUT}
-  INPUT_FILE "${VOXELIZE_SCRIPT}"
-  RESULT_VARIABLE voxelize_result
-  OUTPUT_VARIABLE voxelize_stdout
-  ERROR_VARIABLE voxelize_stderr
-)
-if(NOT voxelize_result EQUAL 0)
-  message(
-    FATAL_ERROR
-    "Creating explicit voxel cells failed (exit ${voxelize_result})\n${voxelize_stdout}${voxelize_stderr}"
-  )
-endif()
-message(STATUS "Created explicit voxel cells")
-
-# PNTS stores point size at import time.  The generator first writes all
-# sampled fields (xyzijk), then reads them back with a visible point diameter.
-run_process(
-  "Sampled pawn surface"
-  "${MGED}" --no-rc -c "${PAWN_DB}" pnts gen -t 2 --surface --grid
-  comparison.csg.r comparison.samples
-)
-run_process(
-  "Exported pawn point samples"
-  "${MGED}" --no-rc -c "${PAWN_DB}" pnts write comparison.samples comparison.xyz
-)
-run_process(
-  "Created visible point cloud"
-  "${MGED}" --no-rc -c "${PAWN_DB}" pnts read -f xyzijk --size 0.45
-  comparison.xyz comparison.point_cloud.s
-)
-
-# g-voxel reports occupied cells.  Expand that sparse report into the regular,
-# x-fastest byte array required by VOL.  The pawn bounds are [-17,17] in X/Y
-# and [0,60] in Z; 2 mm cells therefore form a 17 x 17 x 30 grid.
-file(REMOVE "${VOXEL_LIST}")
-run_process(
-  "Sampled VOL grid"
-  "${GVOXEL}" -s "2 2 2" -d 4 -t 0.5 "${PAWN_DB}" comparison.csg.r
-)
-if(NOT EXISTS "${VOXEL_LIST}")
-  message(FATAL_ERROR "g-voxel did not create ${VOXEL_LIST}")
-endif()
-
-file(STRINGS "${VOXEL_LIST}" voxel_lines)
-list(LENGTH voxel_lines occupied_voxels)
-if(occupied_voxels EQUAL 0)
-  message(FATAL_ERROR "g-voxel reported no occupied cells")
-endif()
-
-foreach(line IN LISTS voxel_lines)
-  string(
-    REGEX MATCH
-    "^\\((-?[0-9]+)\\.0+, (-?[0-9]+)\\.0+, (-?[0-9]+)\\.0+\\)[ \t]+[^ \t]+[ \t]+[0-9.]+$"
-    parsed "${line}"
-  )
-  if(NOT parsed)
-    message(FATAL_ERROR "Cannot parse g-voxel output: ${line}")
-  endif()
-  set(x_coord "${CMAKE_MATCH_1}")
-  set(y_coord "${CMAKE_MATCH_2}")
-  set(z_coord "${CMAKE_MATCH_3}")
-  math(EXPR x_index "(${x_coord} + 16) / 2")
-  math(EXPR y_index "(${y_coord} + 16) / 2")
-  math(EXPR z_index "(${z_coord} - 1) / 2")
-  if(x_index LESS 0 OR x_index GREATER 16 OR
-     y_index LESS 0 OR y_index GREATER 16 OR
-     z_index LESS 0 OR z_index GREATER 29)
-    message(FATAL_ERROR "g-voxel coordinate outside the expected pawn grid: ${line}")
-  endif()
-  set("voxel_${x_index}_${y_index}_${z_index}" 255)
-endforeach()
-
-set(volume_text "")
-foreach(z_index RANGE 0 29)
-  foreach(y_index RANGE 0 16)
-    foreach(x_index RANGE 0 16)
-      if(DEFINED voxel_${x_index}_${y_index}_${z_index})
-        set(sample ff)
-      else()
-        set(sample 00)
-      endif()
-      string(APPEND volume_text "${sample}\n")
-    endforeach()
-  endforeach()
-endforeach()
-file(WRITE "${VOLUME_ASCII}" "${volume_text}")
-
-execute_process(
-  COMMAND "${ASC2PIX}"
-  WORKING_DIRECTORY "${WORKDIR}"
-  TIMEOUT ${RENDER_TIMEOUT}
-  INPUT_FILE "${VOLUME_ASCII}"
-  OUTPUT_FILE "${VOLUME_FILE}"
-  RESULT_VARIABLE asc2pix_result
-  ERROR_VARIABLE asc2pix_error
-)
-if(NOT asc2pix_result EQUAL 0)
-  message(FATAL_ERROR "asc2pix failed (exit ${asc2pix_result})\n${asc2pix_error}")
-endif()
-file(SIZE "${VOLUME_FILE}" volume_size)
-if(NOT volume_size EQUAL 8670)
-  message(FATAL_ERROR "VOL sidecar is ${volume_size} bytes; expected 8670")
-endif()
-message(STATUS "Encoded ${occupied_voxels} occupied VOL cells")
-
-# Wrap single primitives in regions so every shaded comparison uses the same
-# material.  The polygonal tree repeats the original CSG union hierarchy with
-# BoT leaves.  VOL references a sidecar basename resolved beside the database.
-file(WRITE "${MGED_SCRIPT}" [=[
-db put comparison.brep_evaluated.r comb region yes id 1010 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {l comparison.brep_evaluated.s}
-db put comparison.nmg.r comb region yes id 1020 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {l comparison.nmg.s}
-db put comparison.bot.r comb region yes id 1030 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {l comparison.bot.s}
-db put comparison.polygonal_boolean.r comb region yes id 1040 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {u {u {u {l base.bot} {l base_bead.bot}} {u {l body.bot} {l stem.bot}}} {u {u {l collar.bot} {l neck.bot}} {l head.bot}}}
-attr set comparison.voxel_cells.r region R region_id 1050 material_id 1 los 100 shader plastic color 235/190/90
-db put comparison.point_cloud.r comb region yes id 1060 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {l comparison.point_cloud.s}
-db put comparison.volume.s vol file {comparison.vol} name {comparison.vol} src f w 17 n 17 d 30 lo 1 hi 255 size {2 2 2} mat {1 0 0 -17 0 1 0 -17 0 0 1 0 0 0 0 1}
-db put comparison.volume.r comb region yes id 1070 los 100 GIFTmater 1 rgb {235 190 90} shader {plastic} tree {l comparison.volume.s}
-q
-]=])
-
-execute_process(
-  COMMAND "${MGED}" --no-rc -c "${PAWN_DB}"
-  WORKING_DIRECTORY "${WORKDIR}"
-  TIMEOUT ${RENDER_TIMEOUT}
-  INPUT_FILE "${MGED_SCRIPT}"
-  RESULT_VARIABLE assemble_result
-  OUTPUT_VARIABLE assemble_stdout
-  ERROR_VARIABLE assemble_stderr
-)
-if(NOT assemble_result EQUAL 0)
-  message(
-    FATAL_ERROR
-    "Assembling comparison regions failed (exit ${assemble_result})\n${assemble_stdout}${assemble_stderr}"
-  )
-endif()
-
-file(WRITE "${VIEW_SCRIPT}" "viewsize 8.000000000000000e+01;\n")
-file(APPEND "${VIEW_SCRIPT}" "orientation 2.480970000000000e-01 4.765910000000000e-01 7.480970000000000e-01 3.894350000000000e-01;\n")
-file(APPEND "${VIEW_SCRIPT}" "eye_pt 4.199070000000000e+01 2.940060000000000e+01 5.329140000000000e+01;\n")
-file(APPEND "${VIEW_SCRIPT}" "start 0; clean;\n")
-file(APPEND "${VIEW_SCRIPT}" "end;\n")
-
-function(copy_snapshot local_image)
-  if(NOT EXISTS "${local_image}")
-    message(FATAL_ERROR "Expected image was not created: ${local_image}")
-  endif()
-  file(SIZE "${local_image}" image_size)
-  if(image_size EQUAL 0)
-    message(FATAL_ERROR "Rendered image is empty: ${local_image}")
-  endif()
-  file(COPY "${local_image}" DESTINATION "${IMGDIR}")
-  get_filename_component(image_name "${local_image}" NAME)
-  file(
-    CHMOD "${IMGDIR}/${image_name}"
-    PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  )
-endfunction()
-
-function(render_snapshot name object)
-  set(filename "solid_rep_${name}.png")
-  set(local_image "${WORKDIR}/${filename}")
-  file(REMOVE "${local_image}")
-  execute_process(
-    COMMAND "${RT}" -B -M -W "-s${SIZE}" -P1 -o "${filename}" "${PAWN_DB}" "${object}"
-    WORKING_DIRECTORY "${WORKDIR}"
-    TIMEOUT ${RENDER_TIMEOUT}
-    INPUT_FILE "${VIEW_SCRIPT}"
-    RESULT_VARIABLE render_result
-    OUTPUT_VARIABLE render_stdout
-    ERROR_VARIABLE render_stderr
-  )
-  if(NOT render_result EQUAL 0)
-    message(
-      FATAL_ERROR
-      "Rendering ${name} failed (exit ${render_result})\n${render_stdout}${render_stderr}"
-    )
-  endif()
-  copy_snapshot("${local_image}")
-  message(STATUS "Rendered ${filename}")
-endfunction()
-
-render_snapshot(csg comparison.csg.r)
-render_snapshot(brep_boolean comparison.csg.r.brep)
-render_snapshot(brep_evaluated comparison.brep_evaluated.r)
-render_snapshot(polygonal_boolean comparison.polygonal_boolean.r)
-render_snapshot(nmg comparison.nmg.r)
-render_snapshot(bot comparison.bot.r)
-render_snapshot(revolve comparison.revolve.r)
-render_snapshot(voxel_cells comparison.voxel_cells.r)
-render_snapshot(volume comparison.volume.r)
-render_snapshot(point_cloud comparison.point_cloud.r)
-
-# MGED exports its current wireframe display as view-plane plot3.  Rasterize
-# that plot through a disk framebuffer so regeneration needs no display.
-set(WIREFRAME_PLOT "${WORKDIR}/solid_rep_wireframe.plot3")
-set(WIREFRAME_PNG "${WORKDIR}/solid_rep_wireframe.png")
-set(WIREFRAME_FB_NAME "solid_rep_wireframe.fb")
-set(WIREFRAME_SCRIPT "${WORKDIR}/wireframe.tcl")
-file(REMOVE "${WIREFRAME_PLOT}" "${WORKDIR}/${WIREFRAME_FB_NAME}" "${WIREFRAME_PNG}")
-file(WRITE "${WIREFRAME_SCRIPT}" [=[
-draw comparison.csg.r
-size 80
-orientation 0.248097 0.476591 0.748097 0.389435
-eye_pt 41.9907 29.4006 53.2914
-plot -2d solid_rep_wireframe.plot3
-q
-]=])
-execute_process(
-  COMMAND "${MGED}" --no-rc -c "${PAWN_DB}"
-  WORKING_DIRECTORY "${WORKDIR}"
-  TIMEOUT ${RENDER_TIMEOUT}
-  INPUT_FILE "${WIREFRAME_SCRIPT}"
-  RESULT_VARIABLE wireframe_result
-  OUTPUT_VARIABLE wireframe_stdout
-  ERROR_VARIABLE wireframe_stderr
-)
-if(NOT wireframe_result EQUAL 0 OR NOT EXISTS "${WIREFRAME_PLOT}")
-  message(
-    FATAL_ERROR
-    "MGED wireframe export failed (exit ${wireframe_result})\n${wireframe_stdout}${wireframe_stderr}"
-  )
-endif()
-message(STATUS "Exported wireframe plot")
-run_process(
-  "Cleared wireframe framebuffer"
-  "${FBCLEAR}" -c -F "${WIREFRAME_FB_NAME}" -w "${SIZE}" -n "${SIZE}" 24 24 24
-)
-execute_process(
-  COMMAND "${PLOT3FB}" -F "${WIREFRAME_FB_NAME}" -o -w "${SIZE}" -n "${SIZE}"
-  WORKING_DIRECTORY "${WORKDIR}"
-  TIMEOUT ${RENDER_TIMEOUT}
-  INPUT_FILE "${WIREFRAME_PLOT}"
-  RESULT_VARIABLE plot_result
-  OUTPUT_VARIABLE plot_stdout
-  ERROR_VARIABLE plot_stderr
-)
-if(NOT plot_result EQUAL 0)
-  message(FATAL_ERROR "plot3-fb failed (exit ${plot_result})\n${plot_stdout}${plot_stderr}")
-endif()
-run_process(
-  "Rasterized wireframe snapshot"
-  "${FBPNG}" -F "${WIREFRAME_FB_NAME}" -w "${SIZE}" -n "${SIZE}"
-  "solid_rep_wireframe.png"
-)
-copy_snapshot("${WIREFRAME_PNG}")
-
-message(STATUS "Solid representation comparison: 11 snapshots regenerated")
@@ -4,54 +4,38 @@
 :manmanual: BRL-CAD

 == NAME
-pixdiff - highlight differences between two pix or bw images
+pixdiff - highlight samples which differ between two pix or bw files

 == SYNOPSIS

 [source]
 ----
 pixdiff _file1.pix_ _file2.pix_ > _out.pix_
-pixdiff -b _file1.bw_ _file2.bw_ > _out.bw_
+pixdiff _file1.bw_ _file2.bw_ > _out.bw_
 ----


 [[description]]
 == DESCRIPTION

-By default, *pixdiff* compares raw *pix*(5) images as RGB pixels and writes
-a PIX difference image to standard output. When all three channels of a
-pixel match, it writes a dim grayscale version of that pixel to all three
-output channels. When any channel differs, each matching channel is written
-as zero, each channel differing by one is written as 192, and each channel
-differing by more than one is written as 255.
+*pixdiff* compares two raw *pix*(5) or *bw*(5) images byte by byte and
+writes a difference image of the same size to standard output. Bytes that
+differ by +/-1 are written at intensity 192, while larger differences are
+written at full intensity 255. Matching bytes are written at half their
+original intensity, providing visual context for locating differences.

-With *-b*, *pixdiff* compares raw *bw*(5) images one byte at a time and
-writes a BW difference image. Differing samples use the same 192 and 255
-intensities; matching samples are written at half their original intensity.
-
-No image dimensions are needed. The two inputs must be the same size in
-bytes, and PIX input must contain complete three-byte pixels. Otherwise,
-*pixdiff* reports an error. Either input file may be given as
+Because the comparison does not interpret pixel structure, no format option
+is needed and *pixdiff* is independent of image resolution. The two inputs
+must be the same size in bytes; otherwise the program reports the mismatch
+and exits. Either input file may be given as
 *-* to read from standard input. Output must be redirected; *pixdiff*
 refuses to write a raw image stream to a terminal.

-Upon completion, *pixdiff* reports matching, off-by-one, and larger-difference
-channel or sample counts on standard error.
+Upon completion, the count of bytes that matched, that were off by 1, and
+that were off by many is reported on standard error.

-*bwdiff -n -b* produces a similar BW highlight image, but writes 255 rather
-than 192 for off-by-one differences. The default *bwdiff*(1) output instead
-shows signed differences around a neutral gray.
-
-
-[[options]]
-== OPTIONS
-
-*-b*::
-Treat both inputs and the output as one-byte-per-pixel BW images. Without
-this option, use three-byte-per-pixel PIX images.
-
-*-h*::
-Show usage information.
+Also see *bwdiff*(1), which can also operate on *pix*(5) files and can
+produce other kinds of difference output.


 [[examples]]
@@ -75,10 +59,10 @@ on standard error give a quick quantitative sense of how much changed.
 ====
 [source,bash]
 ----
-pixdiff -b depth_a.bw depth_b.bw > depth_diff.bw
+pixdiff depth_a.bw depth_b.bw > depth_diff.bw
 ----
-Writes a grayscale highlight image using byte-wise comparison. Matching
-samples retain half their input intensity as context.
+Writes a grayscale highlight image using the same byte comparison and
+statistics as the color example; no format option is needed.
 ====


@@ -200,56 +200,6 @@ ____

 The LIBRT_DEBUG environment variable may be set to the hexadecimal bit vector as described by the DEBUG_* flags listed in the raytrace.h header. Similarly, many LIBRT applications provide a "-x #" command-line option which will take precedence over the environment variable.

-The RT_DEBUG_RTCMP flag (0x10000000) (set with LIBRT_DEBUG=10000000)
-sets up rtcmp capture, but recording starts disabled. Set
-LIBRT_RTCMP_FILE before enabling the flag, then call
-rt_rtcmp_capture_set_enabled(1) from the application or a debugger to
-record selected rays. Call rt_rtcmp_capture_set_enabled(0) to stop
-recording. Enabling returns -1 if the debug flag is unset or the output
-writer failed to initialize; disabling returns 0 even before setup. A
-ray must begin while recording is enabled, and leaving recording
-disabled when it finishes suppresses its record. The debug flag must be
-set before concurrent ray shooting; use the setter to change recording
-state while rays are running.
-
-Captured hits append one high-precision rtcmp JSON record per ray with
-final partitions. Misses produce no record. librt never clears the
-output file; the caller must clear or rotate it before a new comparison
-as needed. Separate processes must not write to the same file
-concurrently. Pending records are flushed within two seconds under
-normal operation and during normal process shutdown; call
-rt_rtcmp_capture_flush() to wait for pending records when using a
-debugger. Disabling recording does not discard records already queued. A
-process terminated abnormally may lose pending records. rtcmp comparison
-files should use the same hit-only capture mode on both sides; its
-generation mode also includes misses. The output can be expanded to also
-include primitive segments if LIBRT_RTCMP_PRIMITIVES is set to 1 before
-capture is set up.
-
-For example, run a single-threaded ray tracing application in a debugger
-and stop at `rt_shootray` for the suspect ray. Capture just that call,
-then compare it with a capture of the same ray from a reference build:
-
-[source,shell]
----
-$ LIBRT_DEBUG=10000000 LIBRT_RTCMP_FILE=trial.json \
-    gdb --args ./ray_application model.g
-(gdb) break rt_shootray
-(gdb) run
-(gdb) call rt_rtcmp_capture_set_enabled(1)
-(gdb) finish
-(gdb) call rt_rtcmp_capture_set_enabled(0)
-(gdb) call rt_rtcmp_capture_flush()
-(gdb) quit
-$ rtcmp -c reference.json trial.json
----
-
-Continue to the suspect ray before enabling capture if the breakpoint
-first stops on another ray. Produce `reference.json` with the same ray
-and the same capture mode; set LIBRT_RTCMP_PRIMITIVES=1 for both runs
-when primitive segments are needed to locate a difference before Boolean
-evaluation.
-
 The LIBRT_V4FLIP environment variable may be set to a true or false value to respectively force or disable endianness interpretation of v4 geometry database files. The default behavior is to automatically detect whether flipping the endian interpretation will help LIBRT read a binary-incompatible v4 geometry database file. Setting LIBRT_V4FLIP will override automatic detection.


@@ -22,5 +22,4 @@ Task-focused guides and how-to articles.
 * link:articles/procedural_geometry.html[BRL-CAD Procedural Geometry Gallery]
 * link:articles/projection_shader.html[Using the Projection Shader]
 * link:articles/renderer_showcase.html[BRL-CAD Renderer Showcase]
-* link:articles/solid_geometry_comparison.html[Solid Geometry Representation Comparisons]
 * link:articles/tire.html[Vehicle Tire and Wheel Creation in BRL-CAD]
@@ -61,4 +61,5 @@ Author: Paul Mackerras (paulus@cs.anu.edu.au),

 file:/src/libtclcad/tkImgFmtPIX.c
 file:/src/tclscripts/cad_clrpick.tcl
+file:/src/tclscripts/html_library.tcl

@@ -55,7 +55,6 @@
 #include "bg/clip.h"
 #include "bg/lseg.h"
 #include "bg/obr.h"
-#include "bg/pca.h"
 #include "bg/plane.h"
 #include "bg/polygon.h"
 #include "bg/sat.h"
@@ -50,12 +50,12 @@ BG_EXPORT extern int bg_lseg_clip(fastf_t *xp1, fastf_t *yp1, fastf_t *xp2, fast
 * The RPP has faces parallel to the coordinate planes and is defined
 * by a minimum point and a maximum point.
 *
- * Despite its historical name, this function clips the finite line segment
- * from a to b.
+ * FIXME: the function name implies this takes a point,dir for a,b but
+ * it actually takes a line segment going from points a to b!
 *
 * Returns -
- * 0 if the segment does not hit the RPP,
- * !0 if the segment hits the RPP.
+ * 0 if ray does not hit RPP,
+ * !0 if ray hits RPP.
 *
 * Implicit Return -
 * if !0 was returned, "a" and "b" have been clipped to the RPP.
@@ -126,12 +126,9 @@ BG_EXPORT extern int bg_3d_coplanar_obr(point_t *center,
 * \endverbatim
 *
 *
- * @param[out] pnts     eight non-NULL, caller-provided point_t storage
- *                       locations for the oriented bounding box vertices
- * @param[in] points_3d flat array containing 3 * pnt_cnt coordinate values
- * @param[in] pnt_cnt   number of points in points_3d
- *
- * @return 0 on success and -1 for invalid input or when no box can be fit
+ * @param[out] pnts     eight points of oriented bounding box
+ * @param points_3d	array of 3D points
+ * @param pnt_cnt	number of points in pnts array
 */
 BG_EXPORT extern int bg_3d_obb(point_t **pnts,
 			       const fastf_t *points_3d,
@@ -21,7 +21,7 @@
 /*----------------------------------------------------------------------*/
 /** @addtogroup bg_pca
 *
- * Principal Component Analysis
+ * Principle Component Analysis
 *
 * Calculates an XYZ coordinate system such that it aligns with the largest
 * variations in the supplied data.  Intuitively, it "aligns" with the
@@ -50,7 +50,7 @@
 * point_t p;
 * for (size_t i = 0; i < pntcnt; i++) {
 *     MAT4X3PNT(p, RT, pnts[i]);
- *     VMOVE(pnts[i], p);
+ *     VMOVE(pnts[i], v);
 * }
 * @endcode
 */
@@ -69,7 +69,7 @@ __BEGIN_DECLS

 /**
 * @brief
- * Perform a Principal Component Analysis on a set of points.
+ * Perform a Principle Component Analysis on a set of points.
 *
 * Outputs are a center point and XYZ vectors for the coordinate system.
 *
@@ -88,7 +88,7 @@ BG_EXPORT extern int bg_pca(point_t *c, vect_t *xaxis, vect_t *yaxis, vect_t *za

 __END_DECLS

-#endif  /* BG_PCA_H */
+#endif  /* BG_PLANE_H */
 /** @} */
 /*
 * Local Variables:
@@ -1171,10 +1171,9 @@ BG_EXPORT extern int bg_isect_planes(point_t pt,

 /**
 * @brief
- * Given an origin and a normal, create a plane_t with a unit normal.
- * The input point and normal are not modified.  A zero-length normal fails.
+ * Given an origin and a normal, create a plane_t.
 */
-BG_EXPORT extern int bg_plane_pt_nrml(plane_t *p, const point_t pt, const vect_t nrml);
+BG_EXPORT extern int bg_plane_pt_nrml(plane_t *p, point_t pt, vect_t nrml);

 /**
 * @brief
@@ -1189,15 +1188,13 @@ BG_EXPORT extern int bg_fit_plane(point_t *c, vect_t *n, size_t npnts, point_t *

 /**
 * @brief
- * Find the closest U,V point on the plane p to 3d point pt.  The plane normal
- * need not be unit length.
+ * Find the closest U,V point on the plane p to 3d point pt.
 */
 BG_EXPORT extern int bg_plane_closest_pt(fastf_t *u, fastf_t *v, plane_t *p, point_t *pt);

 /**
 * @brief
- * Return the 3D point on the plane at parametric coordinates u, v.  The plane
- * normal need not be unit length.
+ * Return the 3D point on the plane at parametric coordinates u, v.
 */
 BG_EXPORT extern int bg_plane_pt_at(point_t *pt, plane_t *p, fastf_t u, fastf_t v);

@@ -293,7 +293,6 @@ BG_EXPORT extern int bg_3d_polygon_area(fastf_t *area, size_t npts, const point_
 * @param[in] npts Number of point_ts, stored in pts
 * @param[in] pts all points of the polygon, sorted counter-clockwise.
 * The array mustn't contain duplicated points or non-coplanar points.
- * A zero-area polygon fails.
 *
 * @return 0 if calculation was successful
 * @return 1 if calculation failed, e.g. because one in-parameter is a NULL-pointer
@@ -308,7 +307,7 @@ BG_EXPORT extern int bg_3d_polygon_centroid(point_t *cent, size_t npts, const po
 *@param[in] npts Number of points, pts contains
 *@param pts Array of point_ts, building a convex polygon. Duplicated points
 *aren't allowed. The points in the array will be sorted counter-clockwise.
- *@param[in] cmp Plane equation of the polygon.  Its normal must be nonzero.
+ *@param[in] cmp Plane equation of the polygon
 *
 *@return 0 if calculation was successful
 *@return 1 if calculation failed, e.g. because pts is a NULL-pointer
@@ -39,9 +39,7 @@
 __BEGIN_DECLS

 /**
- * Test for an intersection between an infinite line and an Axis-Aligned
- * Bounding Box (AABB).  ldir need not be unit length, but must be nonzero.
- * aabb_extent supplies the positive half extents along the coordinate axes.
+ * Test for an intersection between a line and an Axis-Aligned Bounding Box (AABB).
 *
 * Returns 1 if they intersect, 0 otherwise.
 */
@@ -52,10 +50,7 @@ bg_sat_line_aabb(
 	);

 /**
- * Test for an intersection between an infinite line and an Oriented Bounding
- * Box (OBB).  ldir need not be unit length, but must be nonzero.  Each OBB
- * extent vector points from the center to a face center; nonzero vectors must
- * be mutually perpendicular, and a zero vector represents a degenerate axis.
+ * Test for an intersection between a line and an Oriented Bounding Box (OBB).
 *
 * Returns 1 if they intersect, 0 otherwise.
 */
@@ -66,9 +61,7 @@ bg_sat_line_obb(
 	);

 /**
- * Test for an intersection between a triangle and an Axis-Aligned Bounding
- * Box (AABB).  extent supplies the positive half extents along the coordinate
- * axes.
+ * Test for an intersection between a triangle and an Axis-Aligned Bounding Box (AABB).
 *
 * Returns 1 if they intersect, 0 otherwise.
 */
@@ -79,10 +72,7 @@ bg_sat_tri_aabb(
 	);

 /**
- * Test for an intersection between a triangle and an Oriented Bounding Box
- * (OBB).  Each extent vector points from the center to a face center; nonzero
- * vectors must be mutually perpendicular, and a zero vector represents a
- * degenerate axis.
+ * Test for an intersection between a triangle and an Oriented Bounding Box (OBB).
 *
 * Returns 1 if they intersect, 0 otherwise.
 */
@@ -95,9 +85,8 @@ bg_sat_tri_obb(
 /**
 * Test for an intersection between an Axis-Aligned Bounding Box (AABB) and an
 * Oriented Bounding Box (OBB). The latter is defined by a center point and
- * three extent vectors from the center to the centers of the various faces.
- * Nonzero extent vectors must be mutually perpendicular; a zero vector
- * represents a degenerate axis.
+ * three perpendicular vectors from the center to the centers of the various
+ * faces.
 *
 * Returns 1 if they intersect, 0 otherwise.
 */
@@ -109,9 +98,8 @@ bg_sat_aabb_obb(

 /**
 * Test for an intersection between two Oriented Bounding Boxes (OBBs). The
- * boxes are defined by a center point and three extent vectors from the center
- * to the centers of the various faces.  Nonzero extent vectors must be
- * mutually perpendicular; a zero vector represents a degenerate axis.
+ * boxes are defined by a center point and three perpendicular vectors from the
+ * center to the centers of the various faces.
 *
 * Returns 1 if they intersect, 0 otherwise.
 */
@@ -52,7 +52,7 @@ BG_EXPORT extern double bg_tri_closest_pt(

 __END_DECLS

-#endif  /* BG_TRI_PT_H */
+#endif  /* BG_TRI_TRI_H */
 /** @} */
 /*
 * Local Variables:
@@ -54,7 +54,7 @@ BG_EXPORT extern int bg_isect_tri_line(point_t *isect,
 * If isect is non-NULL, it is written only when an intersection is found.
 */
 BG_EXPORT extern int bg_isect_tri_ray(const point_t orig,
-				      const vect_t dir,
+				      const point_t dir,
 				      const point_t vert0,
 				      const point_t vert1,
 				      const point_t vert2,
@@ -87,11 +87,7 @@ BG_EXPORT extern int bg_trimesh_oriented(int vcnt, int fcnt, fastf_t *v, int *f)
 /**
 * Check if a mesh is topologically solid. Returns 1 if the mesh is NOT SOLID
 * and 0 if the mesh is SOLID. A SOLID (0) outcome indicates the mesh satisfies
- * all three criteria:  Closed, Manifold, Oriented.  If @p bedges is non-NULL,
- * it is set to NULL when no edge diagnostics are present, or to a bu_calloc()
- * allocated array of vertex-index pairs for unmatched, misoriented, and excess
- * edges.  The caller must bu_free() a non-NULL result.  Use
- * bg_trimesh_solid2() when structured diagnostics and their counts are needed.
+ * all three criteria:  Closed, Manifold, Oriented
 */
 BG_EXPORT extern int bg_trimesh_solid(int vcnt, int fcnt, fastf_t *v, int *f, int **bedges);

@@ -214,8 +214,8 @@ BN_EXPORT extern void bn_mat_ae(mat_t m,
 				double elev);

 /**
- * Find the azimuth and elevation angles, in degrees, that correspond
- * to the direction (not including twist) given by a direction vector.
+ * Find the azimuth and elevation angles that correspond to the
+ * direction (not including twist) given by a direction vector.
 */
 BN_EXPORT extern void bn_ae_vec(fastf_t *azp,
 				fastf_t *elp,
@@ -236,16 +236,14 @@ BN_EXPORT extern void bn_aet_vec(fastf_t *az,
 				 fastf_t accuracy);

 /**
- * Find a unit vector from the origin given azimuth and elevation in
- * radians.
+ * Find a unit vector from the origin given azimuth and elevation.
 */
 BN_EXPORT extern void bn_vec_ae(vect_t vec,
 				fastf_t az,
 				fastf_t el);

 /**
- * Find a vector from the origin given azimuth and elevation in radians,
- * and distance.
+ * Find a vector from the origin given azimuth, elevation, and distance.
 */
 BN_EXPORT extern void bn_vec_aed(vect_t vec,
 				 fastf_t az,
@@ -312,10 +310,8 @@ BN_EXPORT extern void bn_vec_perp(vect_t new_vec,
 * space by the angle between the two.  There are many candidate
 * matrices.
 *
- * The input 'from' and 'to' vectors need not be unit length.  They are
- * normalized internally.  Near-parallel inputs are handled using the
- * angular tolerance in 'tol'.  If either input cannot be normalized,
- * the result is the identity matrix.
+ * The input 'from' and 'to' vectors need not be unit length.
+ * MAT4X3VEC(to, m, from) is the identity that is created.
 *
 */
 BN_EXPORT extern void bn_mat_fromto(mat_t m,
@@ -348,11 +344,12 @@ BN_EXPORT extern void bn_mat_zrot(mat_t m,
 				  double cosz);

 /**
- * Given a nonzero direction vector D, produce a matrix which
- * rotates D onto the -Z axis.  D is normalized internally.  Z-axis
- * directions use a deterministic roll, and a zero direction produces
- * the identity matrix.  This matrix will be suitable for use as a
- * model2view matrix.
+ * Given a direction vector D of unit length, product a matrix which
+ * rotates that vector D onto the -Z axis.  This matrix will be
+ * suitable for use as a "model2view" matrix.
+ *
+ * XXX This routine will fail if the vector is already more or less
+ * aligned with the Z axis.
 *
 * This is done in several steps.
 *
@@ -37,42 +37,11 @@ __BEGIN_DECLS

 typedef struct bn_multipoly {
    uint32_t magic;
-    /**< Number of coefficients in the first polynomial variable. */
    int dgrs;
-    /**< Number of coefficients in the second polynomial variable. */
    int dgrt;
-    /**< Coefficient of S^s * T^t is cf[s][t]. */
    double **cf;
 }  bn_multipoly_t;

-/**
- * Allocate a zero-valued bivariate polynomial with the specified
- * coefficient counts.  Both counts must be positive.
- */
-BN_EXPORT extern struct bn_multipoly *bn_multipoly_new(int dgrs, int dgrt);
-
-/** Release a bivariate polynomial allocated by bn_multipoly_new(). */
-BN_EXPORT extern void bn_multipoly_free(struct bn_multipoly *poly);
-
-/** Grow a polynomial to at least the specified coefficient counts. */
-BN_EXPORT extern struct bn_multipoly *bn_multipoly_grow(struct bn_multipoly *poly,
-							 int dgrs,
-							 int dgrt);
-
-/** Set the coefficient of S^s * T^t, growing the polynomial as needed. */
-BN_EXPORT extern struct bn_multipoly *bn_multipoly_set(struct bn_multipoly *poly,
-							int s,
-							int t,
-							double value);
-
-/** Return the sum of two bivariate polynomials. */
-BN_EXPORT extern struct bn_multipoly *bn_multipoly_add(const struct bn_multipoly *p1,
-							const struct bn_multipoly *p2);
-
-/** Return the product of two bivariate polynomials. */
-BN_EXPORT extern struct bn_multipoly *bn_multipoly_mul(const struct bn_multipoly *p1,
-							const struct bn_multipoly *p2);
-
 __END_DECLS

 #endif  /* BN_MULTIPOLY_H */
@@ -45,10 +45,7 @@ __BEGIN_DECLS

 /**
 * Polynomial data type
- *
- * Coefficients are stored from the highest to the lowest degree:
- * `cf[0]` is the coefficient of `X^dgr` and `cf[dgr]` is the
- * constant coefficient.
+ * bn_poly->cf[n] corresponds to X^n
 */
 typedef struct bn_poly {
    uint32_t magic;
@@ -66,9 +63,6 @@ typedef struct bn_poly {
 *
 * @brief
 * multiply two polynomials
- *
- * The output may alias either input.  If the result exceeds
- * BN_MAX_POLY_DEGREE, returns BN_POLY_NULL without modifying product.
 */
 BN_EXPORT extern struct bn_poly *bn_poly_mul(struct bn_poly *product,
 					     const struct bn_poly *m1,
@@ -87,8 +81,6 @@ BN_EXPORT extern struct bn_poly *bn_poly_scale(struct bn_poly *eqn,
 * bn_poly_add
 * @brief
 * add two polynomials
- *
- * The output may alias either input.
 */
 BN_EXPORT extern struct bn_poly *bn_poly_add(struct bn_poly *sum,
 					     const struct bn_poly *poly1,
@@ -98,8 +90,6 @@ BN_EXPORT extern struct bn_poly *bn_poly_add(struct bn_poly *sum,
 * bn_poly_sub
 * @brief
 * subtract two polynomials
- *
- * The output may alias either input.
 */
 BN_EXPORT extern struct bn_poly *bn_poly_sub(struct bn_poly *diff,
 					     const struct bn_poly *poly1,
@@ -108,10 +98,7 @@ BN_EXPORT extern struct bn_poly *bn_poly_sub(struct bn_poly *diff,
 /**
 * @brief
 * Divides any polynomial into any other polynomial using synthetic
- * division.  Both polynomials must have real coefficients and the
- * divisor's leading coefficient must be nonzero.  The quotient and
- * remainder outputs must be distinct; the quotient may alias the
- * dividend.  All other output/input pairs must be distinct.
+ * division.  Both polynomials must have real coefficients.
 */
 BN_EXPORT extern void bn_poly_synthetic_division(struct bn_poly *quo,
 						 struct bn_poly *rem,
@@ -121,8 +108,7 @@ BN_EXPORT extern void bn_poly_synthetic_division(struct bn_poly *quo,
 /**
 *@brief
 * Uses the quadratic formula to find the roots (in `complex' form) of
- * any quadratic equation with real coefficients.  A nonzero leading
- * coefficient need not be one.
+ * any quadratic equation with real coefficients.
 *
 *	@return 1 for success
 *	@return 0 for fail.
@@ -158,7 +144,6 @@ BN_EXPORT extern int bn_poly_quadratic_roots(struct bn_complex roots[],
 * If D < 0, there will be three unequal real roots.
 *
 * Returns 1 for success, 0 for fail.
- * A nonzero leading coefficient need not be one.
 */
 BN_EXPORT extern int bn_poly_cubic_roots(struct bn_complex roots[],
 					 const struct bn_poly *eqn);
@@ -166,8 +151,7 @@ BN_EXPORT extern int bn_poly_cubic_roots(struct bn_complex roots[],
 /**
 *@brief
 * Uses the quartic formula to find the roots (in `complex' form)
- * of any quartic equation with real coefficients.  A nonzero leading
- * coefficient need not be one.
+ * of any quartic equation with real coefficients.
 *
 *	@return 1 for success
 *	@return 0 for fail.
@@ -100,8 +100,8 @@ BN_EXPORT extern void quat_double(quat_t qout,
 /**
 *@brief Gives the bisector of quaternions q1 and q2.
 *
- * Inputs must be unit quaternions.  Antipodal inputs use a valid
- * great-circle midpoint.
+ * (Could be done with quat_slerp and factor 0.5)
+ * [I believe they must be unit quaternions this to work]
 */
 BN_EXPORT extern void quat_bisect(quat_t qout,
 				  const quat_t q1,
@@ -161,8 +161,7 @@ BN_EXPORT extern void quat_exp(quat_t out,

 /**
 *@brief
- *  Take the natural logarithm of a unit quaternion.  The identity
- *  quaternion maps to the zero quaternion.
+ *  Take the natural logarithm of a unit quaternion.
 *  Code by Ken Shoemake.
 */
 BN_EXPORT extern void quat_log(quat_t out,
@@ -205,30 +205,23 @@ BU_EXPORT extern int bu_sscanf(const char *src, const char *fmt, ...) _BU_ATTR_S
 /** Routines for scanning certain kinds of data. */

 /**
- * Scans a sequence of fastf_t numbers from a string or stdin.
+ * Scans a sequence of fastf_t numbers from a string or stdin
 *
 * Scanning fastf_t numbers with bu_sscanf() is difficult, because
 * doing so requires scanning to some intermediate type like double
 * and then assigning to the fastf_t variable to convert the value to
 * whatever type fastf_t really is.  This function makes it possible
- * to scan a series of fastf_t numbers easily, by doing the required
- * conversion internally.  Delimiters form a non-empty character set:
- * one or more delimiter characters must separate values, and repeated
- * delimiters are skipped.  Empty scan fields are therefore not
- * supported (e.g., "0.0,,0.0,1.0" scans as 3 fields, not 4 with the
- * second skipped).  A trailing delimiter is not consumed after the
- * final requested value.
+ * to scan a series of fastf_t numbers separated by some character(s)
+ * easily, by doing the required conversion internally to the
+ * functions.  As series of delimiter characters will be skipped,
+ * empty scan fields are not supported (e.g., "0.0,,0.0,1.0" will scan
+ * as 3 fields, not 4 with the 2nd skipped).
 *
- * @param[out] c Optional destination for the number of input characters
- *     consumed.  It is set to zero before scanning and remains zero for
- *     invalid arguments or when no value is scanned.
+ * @param[out] c Returns number of characters scanned by the function
 * @param[in] src A source string to scan from, or NULL to read from stdin
- * @param[in] delim Non-empty set of delimiter characters to skip between
- *     scan values
+ * @param[in] delim Any delimiter character(s) to skip between scan values
 * @param[in] n Number of fastf_t values to scan from the src input string
- * @param[out] ... Exactly n fastf_t pointers for storing scanned values;
- *     individual pointers may be NULL
- * @return Number of values scanned
+ * @param[out] ... Pointers to fastf_t for storing scanned values (optional)
 *
 */
 BU_EXPORT extern int bu_scan_fastf_t(int *c, const char *src, const char *delim, size_t n, ...);
@@ -1 +1 @@
-47
+45
@@ -84,7 +84,7 @@ __BEGIN_DECLS
 #define RT_DEBUG_HF		0x04000000	/**< @brief 27 Height Field solids */

 #define RT_DEBUG_MESHING	0x08000000	/**< @brief 28 Print meshing/triangulation details */
-#define RT_DEBUG_RTCMP		0x10000000      /**< @brief 29 Set up rtcmp capture; recording uses a runtime toggle.  If LIBRT_RTCMP_PRIMITIVES=1 includes primitive segments. */
+#define RT_DEBUG_UNUSED_3	0x10000000	/**< @brief 29 Unassigned */
 #define RT_DEBUG_UNUSED_4	0x20000000	/**< @brief 30 Unassigned */

 /* Options which will cause the library to write binary debugging output */
@@ -96,7 +96,7 @@ __BEGIN_DECLS
    "\040PL_BOX" \
    "\037PL_SOLIDS" \
    "\036UNUSED_4" \
-    "\035RTCMP" \
+    "\035UNUSED_3" \
    "\034UNUSED_2" \
    "\033HF" \
    "\032EBM" \
@@ -465,17 +465,6 @@ rt_get_solid_keypoint(struct rt_edit *s, point_t *pt, const char **strp, fastf_t
 RT_EXPORT extern void
 rt_edit_set_edflag(struct rt_edit *s, int edflag);

-/**
- * Set a parameter-edit translation target expressed in model base units.
- *
- * rt_edit's parameter-edit handlers consume e_para in database local units,
- * while keypoints and edit axes are maintained in model base units.  This
- * helper performs the boundary conversion for callers that have computed a
- * target from a keypoint, axis, or view transform.
- */
-RT_EXPORT extern void
-rt_edit_set_translation_target(struct rt_edit *s, const point_t target);
-
 RT_EXPORT extern int
 rt_edit_knob_cmd_process(
 	struct rt_edit *s,
@@ -510,10 +499,8 @@ rt_knob_edit_sca(
 	int matrix_edit);

 /* Equivalent to sedit - run editing logic after input data is set in
- * rt_edit container.  Transient input flags are consumed whether the edit
- * succeeds or fails; parameter values remain available to the caller.
- * Returns BRLCAD_ERROR if the primitive edit fails. */
-RT_EXPORT extern int
+ * rt_edit container */
+RT_EXPORT extern void
 rt_edit_process(struct rt_edit *s);

 /**
@@ -534,7 +521,7 @@ rt_edit_snap_point(point2d_t pt, const struct rt_edit *s);
 * restored later with rt_edit_revert().
 *
 * The snapshot is stored inside the rt_edit struct.  Calling this
- * function again replaces the previous snapshot only on success.
+ * function again overwrites any previous snapshot (single-level undo).
 *
 * @return BRLCAD_OK on success, BRLCAD_ERROR if the export failed.
 */
@@ -545,8 +532,8 @@ rt_edit_checkpoint(struct rt_edit *s);
 * Restore primitive parameters from the snapshot saved by
 * rt_edit_checkpoint().
 *
- * The snapshot remains available for repeated restores.  If none has
- * been saved, this function logs a message and returns BRLCAD_ERROR.
+ * If no snapshot has been saved (or the last snapshot was already
+ * consumed) this function logs a message and returns BRLCAD_ERROR.
 *
 * @return BRLCAD_OK on success, BRLCAD_ERROR otherwise.
 */
@@ -710,11 +697,7 @@ enum rt_constraint_edit_op_kind {
    RT_CONSTRAINT_EDIT_OP_SET_BEND,
    RT_CONSTRAINT_EDIT_OP_SCALE_OD,
    RT_CONSTRAINT_EDIT_OP_SCALE_ID,
-    RT_CONSTRAINT_EDIT_OP_SCALE_BEND,
-    /* Set every point when an all-zero dimension has no scale reference. */
-    RT_CONSTRAINT_EDIT_OP_SET_ALL_OD,
-    RT_CONSTRAINT_EDIT_OP_SET_ALL_ID,
-    RT_CONSTRAINT_EDIT_OP_SET_ALL_BEND
+    RT_CONSTRAINT_EDIT_OP_SCALE_BEND
 };

 struct rt_constraint_edit_param_ref {
@@ -284,6 +284,26 @@ struct rt_crofton_result {
 *          bound fit failure.  A return
 *          value of 0 means no geometry was intersected by the sampler.
 *
+ * @section crofton_sampler Sampling method
+ *
+ * When BRL-CAD is built with BRLCAD_ENABLE_QMC, Crofton sampling defaults to
+ * OpenQMC's randomized rank-one lattice.  It maps four uniformly distributed
+ * coordinates directly to the two direction and two perpendicular-offset
+ * coordinates of an oriented line.  Directions are isotropic, and the offset
+ * radius uses R*sqrt(u) so lines are uniform by area across the bounding disk,
+ * not concentrated toward its center.  This is the same invariant line
+ * measure used by the independent-random-endpoint construction, so the
+ * Crofton area and volume formulas and stopping criteria do not change.
+ *
+ * The lattice improves finite-sample coverage but its samples are correlated,
+ * unlike ordinary Monte Carlo samples.  OpenQMC shuffles indices and applies
+ * toroidal shifts to mitigate alignment artifacts; a fixed pattern schedule
+ * keeps runs reproducible.  Set the LIBRT_CROFTON_USE_PRNG environment
+ * variable to a value accepted by bu_str_true() to force the original
+ * independent-PRNG generator.  That path is useful for compatibility and for
+ * checking whether an unexpected result is specific to lattice correlation.
+ *
+ *
 * @section crofton_near_tol Near-tolerance sliver geometry: CSG vs BoT divergence
 *
 * The Cauchy-Crofton formula is mathematically exact for any well-defined
@@ -387,8 +407,8 @@ RT_EXPORT extern void rt_crofton_result_free(
 /**
 * Cauchy-Crofton surface-area and/or volume estimator for a primitive.
 *
- * Creates a temporary in-memory raytrace of @p ip and fires random chord
- * rays until the stopping criteria in @p params are satisfied (or all
+ * Creates a temporary in-memory raytrace of @p ip and samples Crofton lines
+ * until the stopping criteria in @p params are satisfied (or all
 * criteria are zero / params is NULL, in which case the 2 000-ray default
 * is used).  Stores the estimated surface area in @p *area (if non-NULL)
 * and the estimated volume in @p *vol (if non-NULL).
@@ -55,11 +55,14 @@ struct clt_tri_specific {
 };
 #endif

+#define RT_BOT_SURFNO_INTERIOR (-1)
+
 /* Shared between bot and ars at the moment */
 struct bot_specific {
    unsigned char bot_mode;
    unsigned char bot_orientation;
    unsigned char bot_flags;
+    unsigned char bot_parity_shot;
    size_t bot_ntri;
    fastf_t *bot_thickness;
    struct bu_bitv *bot_facemode;
@@ -41,7 +41,6 @@ struct rt_nmg_edit {
    struct loopuse *lu_copy;    /* copy of loop to be extruded */
    plane_t lu_pl;              /* plane equation for loop to be extruded */
    struct shell *es_s;         /* Shell where extrusion is to end up */
-    int es_s_from_extrusion;    /* Replace this edit's prior preview */
    point_t lu_keypoint;        /* keypoint of lu_copy for extrusion */
    struct vertex *es_v;        /* Currently selected NMG vertex (ECMD_NMG_VPICK) */
    struct faceuse *es_fu;      /* Currently selected NMG faceuse (ECMD_NMG_FPICK) */
@@ -55,18 +55,6 @@

 __BEGIN_DECLS

-#define RT_RTCMP_CAPTURE_RUNTIME_TOGGLE 1
-
-/** Set RT_DEBUG_RTCMP recording: nonzero enables, zero disables.
- * Enabling requires the debug flag and a usable output writer.
- * Return 0 on success and -1 on failure. Disabling succeeds even
- * before setup.
- */
-RT_EXPORT extern int rt_rtcmp_capture_set_enabled(int enabled);
-
-/** Wait until pending RT_DEBUG_RTCMP records have reached the output file. */
-RT_EXPORT extern int rt_rtcmp_capture_flush(void);
-
 /**
 * @brief
 * Shoot a ray
@@ -30,7 +30,6 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 include(CMakeParseArguments)
-include("${CMAKE_CURRENT_LIST_DIR}/BRLCAD_Repository.cmake")

 # Try to locate a usable git executable. On Windows, Visual Studio may
 # provide git in non-standard locations; try common Program Files and
@@ -89,15 +88,6 @@ function(brlcad_bext_init BEXT_SHA1)
    set(BRLCAD_EXT_DIR "${BRLCAD_EXT_DIR_ENV}")
  endif(BRLCAD_EXT_DIR_ENV AND NOT DEFINED BRLCAD_EXT_DIR)

-  # Resolve paths before probing them so later subconfigures use the same
-  # directories even when launched from a different working directory.
-  foreach(_brlcad_ext_path_var BRLCAD_EXT_DIR BRLCAD_EXT_SOURCE_DIR)
-    if(DEFINED ${_brlcad_ext_path_var} AND NOT "${${_brlcad_ext_path_var}}" STREQUAL "")
-      get_filename_component(${_brlcad_ext_path_var} "${${_brlcad_ext_path_var}}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
-      set(${_brlcad_ext_path_var} "${${_brlcad_ext_path_var}}" PARENT_SCOPE)
-    endif()
-  endforeach()
-
  set(_brlcad_ext_dir_specified FALSE)
  set(_brlcad_ext_dir_managed FALSE)

@@ -158,14 +148,14 @@ function(brlcad_bext_init BEXT_SHA1)
    elseif(NOT _brlcad_ext_dir_specified)
      message(
 	WARNING
-	"External dependencies will be acquired from ${_BRLCAD_REPOSITORY_ROOT}, configured, and built automatically as-needed. Set BRLCAD_EXT_DIR to specify instead."
+	"External dependencies will be downloaded, configured, and built automatically as-needed. Set BRLCAD_EXT_DIR to specify instead."
 	)
    endif()
    message(
      STATUS
      "BRLCAD_EXT_DIR specifies prebuilt external dependencies directory\n"
      "containing 'install' and 'noinstall' folders, outputs from installing\n"
-      "${_BRLCAD_BEXT_REPOSITORY}.\n"
+      "https://github.com/BRL-CAD/bext.\n"
    )
  endif(NOT BRLCAD_EXT_NOINSTALL_DIR OR NOT BRLCAD_EXT_INSTALL_DIR)

@@ -221,24 +211,28 @@ function(brlcad_rel_version BRLCAD_REL)
  set(${BRLCAD_REL} "rel-${VMAJOR}-${VMINOR}-${VPATCH}" PARENT_SCOPE)
 endfunction()

-# Branch/tag queries are advisory; an unavailable source cannot validate them.
+# Look up branch or tag SHA1 hashes from primary github.com repo
 function(remote_sha1 SHA1_VAR BRANCH)
-  set(${SHA1_VAR} "" PARENT_SCOPE)
  if(NOT GIT_EXEC)
+    set(${SHA1_VAR} "" PARENT_SCOPE)
    return()
  endif()
-  brlcad_repository_git_command(git_command)
+  # This needs a working internet connection to succeed (and GitHub
+  # must be up and working as well.)
  execute_process(
-    COMMAND "${CMAKE_COMMAND}" -E env GIT_TERMINAL_PROMPT=0 --
-      ${git_command} -c credential.helper= -c credential.interactive=false
-      ls-remote "${_BRLCAD_BEXT_REPOSITORY}" "${BRANCH}"
-    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-    RESULT_VARIABLE git_result
-    OUTPUT_VARIABLE remote_refs
-    ERROR_QUIET
-  )
-  if(git_result STREQUAL "0" AND remote_refs MATCHES "^([0-9a-f]+)[ \t]")
-    set(${SHA1_VAR} "${CMAKE_MATCH_1}" PARENT_SCOPE)
+    COMMAND ${GIT_EXEC} ls-remote https://github.com/BRL-CAD/bext.git ${BRANCH}
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    RESULT_VARIABLE LS_REMOTE_STATUS
+    OUTPUT_VARIABLE LS_REMOTE_STR
+    ERROR_VARIABLE LS_REMOTE_STR
+    )
+  if(NOT LS_REMOTE_STATUS AND LS_REMOTE_STR)
+    string(REPLACE " " ";" LS_REMOTE_STR "${LS_REMOTE_STR}")
+    string(REPLACE "\t" ";" LS_REMOTE_STR "${LS_REMOTE_STR}")
+    list(GET LS_REMOTE_STR 0 REMOTE_SHA1)
+    set(${SHA1_VAR} "${REMOTE_SHA1}" PARENT_SCOPE)
+  else()
+    set(${SHA1_VAR} "" PARENT_SCOPE)
  endif()
 endfunction()

@@ -373,29 +367,24 @@ function(setup_bext_dir)
    # no pre-existing sources, so we're cloning into the build dir
    set(BRLCAD_EXT_SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/bext")

-    brlcad_repository_git_command(git_command)
-    message(STATUS "Cloning bext from ${_BRLCAD_BEXT_REPOSITORY}")
-    execute_process(
-      COMMAND ${git_command} clone "${_BRLCAD_BEXT_REPOSITORY}" "${BRLCAD_EXT_SOURCE_DIR}"
-      WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
-      RESULT_VARIABLE git_result
-    )
-    if(NOT git_result STREQUAL "0")
-      message(FATAL_ERROR "Unable to clone bext from ${_BRLCAD_BEXT_REPOSITORY} (${git_result})")
-    endif()
-    execute_process(
-      COMMAND ${git_command} -c advice.detachedHead=false checkout "${BEXT_SHA1}"
-      WORKING_DIRECTORY "${BRLCAD_EXT_SOURCE_DIR}"
-      RESULT_VARIABLE git_result
-    )
-    if(NOT git_result STREQUAL "0")
-      message(FATAL_ERROR "Unable to check out pinned bext commit ${BEXT_SHA1} from ${_BRLCAD_BEXT_REPOSITORY} (${git_result}); ensure the repository contains this commit")
-    endif()
-
-    # Record the pin only after checkout succeeds.
+    # Write current SHA1 for subsequent processing
    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/bext.sha1" "${BEXT_SHA1}")
    distclean("${CMAKE_CURRENT_BINARY_DIR}/bext.sha1")

+    # Clone
+    message("BRL-CAD bext clone command: ${GIT_EXEC} clone https://github.com/BRL-CAD/bext.git")
+    execute_process(
+      COMMAND ${GIT_EXEC} clone https://github.com/BRL-CAD/bext.git
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+      COMMAND_ERROR_IS_FATAL ANY
+    )
+    message("BRL-CAD bext checkout command: ${GIT_EXEC} -c advice.detachedHead=false checkout ${BEXT_SHA1}")
+    execute_process(
+      COMMAND ${GIT_EXEC} -c advice.detachedHead=false checkout ${BEXT_SHA1}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bext
+      COMMAND_ERROR_IS_FATAL ANY
+    )
+
    # Configure process will need to clean up bext
    if (BRLCAD_BEXT_CLEANUP)
      set(BEXT_SRC_CLEANUP TRUE PARENT_SCOPE)
@@ -436,12 +425,6 @@ function(brlcad_ext_setup)
    message(FATAL_ERROR "Invalid bext directory: ${BRLCAD_EXT_SOURCE_DIR}")
  endif()

-  if(NOT _BRLCAD_REPOSITORY_ROOT STREQUAL "${_BRLCAD_REPOSITORY_DEFAULT_ROOT}/"
-      AND NOT EXISTS "${BRLCAD_EXT_SOURCE_DIR}/CMake/BextGit.cmake")
-    message(FATAL_ERROR
-      "bext sources in ${BRLCAD_EXT_SOURCE_DIR} do not support BEXT_REPOSITORY_ROOT; update bext before building with BRLCAD_REPOSITORY_ROOT=${BRLCAD_REPOSITORY_ROOT}")
-  endif()
-
  # We do allow the user to specify a build dir to be reused, however
  # this is unpredictable and may cause unexpected results depending
  # on what is or isn't rebuilt - use with care.
@@ -480,18 +463,11 @@ function(brlcad_ext_setup)
  endif(BRLCAD_ENABLE_APPLESEED)

  # Define CMake arguments we'll need regardless of mode
-  set(bext_shallow_clone ON)
-  if(_BRLCAD_REPOSITORY_LOCAL)
-    set(bext_shallow_clone OFF)
-  endif()
  set(CMAKE_CMD_ARGS
-    -S "${BRLCAD_EXT_SOURCE_DIR}" -B "${BRLCAD_EXT_BUILD_DIR}"
-    "-DBEXT_REPOSITORY_ROOT:STRING=${_BRLCAD_REPOSITORY_ROOT}"
-    "-DGIT_SHALLOW_CLONE:BOOL=${bext_shallow_clone}"
-    "-DENABLE_ALL=${BEXT_ENABLE_ALL}" "-DUSE_GDAL=${BEXT_USE_GDAL}"
-    "-DUSE_QT=${BEXT_USE_QT}" "-DUSE_TCL=${BEXT_USE_TCL}"
-    "-DUSE_APPLESEED=${BEXT_USE_APPLESEED}" "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-    "-DCMAKE_INSTALL_PREFIX=${BRLCAD_EXT_INSTALL_DIR}"
+    -S ${BRLCAD_EXT_SOURCE_DIR} -B ${BRLCAD_EXT_BUILD_DIR} -DGIT_SHALLOW_CLONE=ON
+    -DENABLE_ALL=${BEXT_ENABLE_ALL} -DUSE_GDAL=${BEXT_USE_GDAL} -DUSE_QT=${BEXT_USE_QT} -DUSE_TCL=${BEXT_USE_TCL}
+    -DUSE_APPLESEED=${BEXT_USE_APPLESEED} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+    -DCMAKE_INSTALL_PREFIX=${BRLCAD_EXT_INSTALL_DIR}
    )
  if(BRLCAD_X11_PROVIDER_RESOLVED STREQUAL "XMIN" AND BRLCAD_XMIN_ROOT)
    list(APPEND CMAKE_CMD_ARGS
@@ -1108,9 +1108,9 @@ function(brlcad_install_strclear_replace stamp_dir strclear source install_file
  endif()
 endfunction()

-function(brlcad_install_binary_postprocess stamp_dir strclear source install_file install_type mode rpath_tool install_rpath build_lib_path rel_rpath verbose)
+function(brlcad_install_binary_postprocess stamp_dir strclear source install_file install_type mode rpath_tool install_rpath build_lib_path rel_rpath use_selective_rpath verbose)
  set(_brlcad_physical_file "$ENV{DESTDIR}${install_file}")
-  set(_brlcad_signature "binary-postprocess|${install_type}|${mode}|${rpath_tool}|${install_rpath}|${build_lib_path}|${rel_rpath}|${strclear}")
+  set(_brlcad_signature "binary-postprocess|${install_type}|${mode}|${rpath_tool}|${install_rpath}|${build_lib_path}|${rel_rpath}|${use_selective_rpath}|${strclear}")
  _brlcad_postprocess_needed(_brlcad_needed "${stamp_dir}" "${source}" "${_brlcad_physical_file}" "${_brlcad_signature}")
  if(NOT _brlcad_needed)
    return()
@@ -1121,41 +1121,32 @@ function(brlcad_install_binary_postprocess stamp_dir strclear source install_fil
    message(FATAL_ERROR "Post-install copy did not create ${_brlcad_physical_file}")
  endif()
  set(_brlcad_result 0)
-  set(_brlcad_rpath_output)
-  set(_brlcad_rpath_error)
  if("${mode}" STREQUAL "RPATH_TOOL")
-    # Install the exact project-defined search order.  A selective update can
-    # leave an existing relative-only RPATH without the canonical install path.
+    set(_brlcad_selective_rpath_args)
+    if(use_selective_rpath)
+      set(_brlcad_selective_rpath_args --set-rpath-if-needed --set-rpath-if-needed-prepend --stale-rpath-prefix "${build_lib_path}")
+    endif()
    execute_process(
-      COMMAND "${rpath_tool}" --set-rpath "${install_rpath}" "${_brlcad_physical_file}"
+      COMMAND "${rpath_tool}" --set-rpath "${install_rpath}" ${_brlcad_selective_rpath_args} "${_brlcad_physical_file}"
      RESULT_VARIABLE _brlcad_result
-      OUTPUT_VARIABLE _brlcad_rpath_output
-      ERROR_VARIABLE _brlcad_rpath_error
    )
  elseif("${mode}" STREQUAL "APPLE")
    execute_process(
      COMMAND install_name_tool -delete_rpath "${build_lib_path}" "${_brlcad_physical_file}"
      RESULT_VARIABLE _brlcad_result
-      OUTPUT_VARIABLE _brlcad_rpath_output
-      ERROR_VARIABLE _brlcad_rpath_error
+      OUTPUT_VARIABLE _brlcad_output
+      ERROR_VARIABLE _brlcad_error
    )
    if(_brlcad_result EQUAL 0)
      execute_process(
        COMMAND install_name_tool -add_rpath "${rel_rpath}" "${_brlcad_physical_file}"
        RESULT_VARIABLE _brlcad_result
-        OUTPUT_VARIABLE _brlcad_rpath_output
-        ERROR_VARIABLE _brlcad_rpath_error
      )
    endif()
  endif()

  if(NOT _brlcad_result EQUAL 0)
-    message(
-      WARNING
-        "Post-install RPATH update failed for ${_brlcad_physical_file}\n"
-        "stdout: ${_brlcad_rpath_output}\n"
-        "stderr: ${_brlcad_rpath_error}"
-    )
+    message(WARNING "Post-install RPATH update failed for ${_brlcad_physical_file}")
    return()
  endif()

@@ -1849,9 +1840,13 @@ endfunction()
      elseif(APPLE)
        set(_brlcad_install_postprocess_mode "APPLE")
      endif(P_RPATH_EXECUTABLE)
+      set(_brlcad_install_use_selective_rpath FALSE)
+      if(P_RPATH_SUPPORTS_SET_IF_NEEDED_PREPEND)
+        set(_brlcad_install_use_selective_rpath TRUE)
+      endif(P_RPATH_SUPPORTS_SET_IF_NEEDED_PREPEND)
      install(
        CODE
-          "include(\"${BRLCAD_EXT_INSTALL_POSTPROCESS_SCRIPT}\")\nbrlcad_install_binary_postprocess(\"${BRLCAD_EXT_INSTALL_POSTPROCESS_STAMP_DIR}\" \"${STRCLEAR_EXECUTABLE}\" \"${CMAKE_BINARY_DIR}/${tf}\" \"\${CMAKE_INSTALL_PREFIX}/${tf}\" \"PROGRAM\" \"${_brlcad_install_postprocess_mode}\" \"${_brlcad_install_postprocess_tool}\" \"${_brlcad_install_postprocess_rpath}\" \"${CMAKE_BINARY_DIR}/${LIB_DIR}\" \"${REL_RPATH}\" \"${BRLCAD_VERBOSE}\")"
+          "include(\"${BRLCAD_EXT_INSTALL_POSTPROCESS_SCRIPT}\")\nbrlcad_install_binary_postprocess(\"${BRLCAD_EXT_INSTALL_POSTPROCESS_STAMP_DIR}\" \"${STRCLEAR_EXECUTABLE}\" \"${CMAKE_BINARY_DIR}/${tf}\" \"\${CMAKE_INSTALL_PREFIX}/${tf}\" \"PROGRAM\" \"${_brlcad_install_postprocess_mode}\" \"${_brlcad_install_postprocess_tool}\" \"${_brlcad_install_postprocess_rpath}\" \"${CMAKE_BINARY_DIR}/${LIB_DIR}\" \"${REL_RPATH}\" \"${_brlcad_install_use_selective_rpath}\" \"${BRLCAD_VERBOSE}\")"
      )
      continue()
    endif("${tf}" IN_LIST ALL_BINARY_FILES)
@@ -2205,11 +2200,7 @@ macro(find_package_opencv)
  set(OpenCV_DIR_TMP "${OpenCV_DIR}")
  set(OpenCV_DIR "${CMAKE_BINARY_DIR}/${LIB_DIR}/cmake/opencv4")
  set(OpenCV_ROOT ${CMAKE_BINARY_DIR})
-  find_package(OpenCV CONFIG COMPONENTS core imgproc imgcodecs highgui)
-  if(OpenCV_FOUND AND OpenCV_VERSION_MAJOR GREATER_EQUAL 5)
-    # OpenCV 5 moved boundingRect from imgproc to geometry.
-    find_package(OpenCV CONFIG COMPONENTS geometry)
-  endif()
+  find_package(OpenCV COMPONENTS core features2d imgproc highgui)
  unset(OpenCV_ROOT)

  # If no bundled copy, see what the system has
@@ -1,108 +0,0 @@
-# Copyright (c) 2026 United States Government as represented by
-# the U.S. Army Research Laboratory.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following
-# disclaimer in the documentation and/or other materials provided
-# with the distribution.
-#
-# 3. The name of the author may not be used to endorse or promote
-# products derived from this software without specific prior written
-# permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
-# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
-# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-include_guard(GLOBAL)
-
-set(_BRLCAD_REPOSITORY_DEFAULT_ROOT "https://github.com/BRL-CAD")
-set(BRLCAD_REPOSITORY_ROOT "${_BRLCAD_REPOSITORY_DEFAULT_ROOT}" CACHE STRING
-  "Repository URL or local mirror directory containing bext and its dependency repositories")
-
-function(brlcad_repository_root out_root out_local)
-  set(root "${BRLCAD_REPOSITORY_ROOT}")
-  set(local FALSE)
-  if(root STREQUAL "")
-    message(FATAL_ERROR "BRLCAD_REPOSITORY_ROOT must be a repository URL or local mirror directory")
-  endif()
-
-  # Match bext's URL handling, but resolve relative paths against BRL-CAD.
-  # Drive paths must be checked before scp-style SSH locations.
-  if(root MATCHES "^file://")
-    set(local TRUE)
-    string(REPLACE "=" "%3D" root "${root}")
-  elseif(root MATCHES "^[A-Za-z]:[/\\\\]" OR
-      NOT (root MATCHES "^[A-Za-z][A-Za-z0-9+.-]*://" OR root MATCHES "^[^/]+:.+"))
-    set(local TRUE)
-    string(REPLACE "\\" "/" root "${root}")
-    if(WIN32 OR NOT root MATCHES "^[A-Za-z]:/")
-      get_filename_component(root "${root}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
-    endif()
-    # Escape literal percent signs first so native paths cannot introduce
-    # URL escapes.  An equals sign also has meaning in Git's -c assignments.
-    string(REPLACE "%" "%25" root "${root}")
-    string(REPLACE " " "%20" root "${root}")
-    string(REPLACE "#" "%23" root "${root}")
-    string(REPLACE "?" "%3F" root "${root}")
-    string(REPLACE "=" "%3D" root "${root}")
-    if(root MATCHES "^[A-Za-z]:/")
-      set(root "file:///${root}")
-    elseif(root MATCHES "^//")
-      set(root "file:${root}")
-    else()
-      set(root "file://${root}")
-    endif()
-  endif()
-
-  if(NOT root MATCHES "^file:///*$")
-    string(REGEX REPLACE "/+$" "" root "${root}")
-    string(APPEND root "/")
-  else()
-    set(root "file:///")
-  endif()
-  set(${out_root} "${root}" PARENT_SCOPE)
-  set(${out_local} "${local}" PARENT_SCOPE)
-endfunction()
-
-function(brlcad_repository_git_command out_command)
-  set(git_command "${GIT_EXEC}")
-  if(WIN32)
-    list(APPEND git_command -c core.longpaths=true)
-  endif()
-  if(_BRLCAD_REPOSITORY_LOCAL)
-    list(APPEND git_command -c protocol.file.allow=always)
-    # This also constrains recursive Git processes and user URL rewrites.
-    list(PREPEND git_command "${CMAKE_COMMAND}" -E env GIT_ALLOW_PROTOCOL=file --)
-  endif()
-  set(${out_command} "${git_command}" PARENT_SCOPE)
-endfunction()
-
-brlcad_repository_root(_BRLCAD_REPOSITORY_ROOT _BRLCAD_REPOSITORY_LOCAL)
-set(_BRLCAD_BEXT_REPOSITORY "${_BRLCAD_REPOSITORY_ROOT}bext.git")
-message(STATUS "BRL-CAD repository root: ${_BRLCAD_REPOSITORY_ROOT}")
-if(_BRLCAD_REPOSITORY_LOCAL)
-  message(STATUS "BRL-CAD Git acquisition: file transport only")
-endif()
-
-# Local Variables:
-# tab-width: 8
-# mode: cmake
-# indent-tabs-mode: t
-# End:
-# ex: shiftwidth=2 tabstop=8
@@ -258,6 +258,7 @@ function(BRLCAD_Summary)
  ext_report("Netpbm" NETPBM_STATUS)
  ext_report("OpenCV" OPENCV_STATUS)
  ext_report("OpenNURBS" OPENNURBS_STATUS)
+  ext_report("OpenQMC" OPENQMC_STATUS REQUIRED_VARS "BRLCAD_ENABLE_QMC")
  ext_report("OSMesa" OSMESA_STATUS)
  ext_report("Portable Network Graphics" PNG_STATUS)

@@ -308,6 +308,10 @@ if(BRLCAD_ENABLE_OPENCL)
  endif(NOT OPENCL_FOUND)
 endif(BRLCAD_ENABLE_OPENCL)

+# Enable quasi-Monte Carlo sampling where supported
+option(BRLCAD_ENABLE_QMC "Enable quasi-Monte Carlo sampling" OFF)
+mark_as_advanced(BRLCAD_ENABLE_QMC)
+
 # Enable features requiring OpenVDB
 option(BRLCAD_ENABLE_OPENVDB "Enable features requiring OpenVDB" OFF)
 mark_as_advanced(BRLCAD_ENABLE_OPENVDB)
@@ -15,7 +15,6 @@ set(
  BRLCAD_Options.cmake
  BRLCAD_Probe_Validation.cmake
  BRLCAD_Regress_Util.cmake
-  BRLCAD_Repository.cmake
  BRLCAD_Summary.cmake
  BRLCAD_Targets.cmake
  BRLCAD_Test_Wrappers.cmake
@@ -95,33 +95,6 @@ add_custom_target(
 )
 set_target_properties(distcheck-source_archives PROPERTIES FOLDER "BRL-CAD Distribution Checking")

-# Dependency paths must survive CMake, build-tool, and shell parsing.  Load
-# their values from a cache file rather than embedding them in command text.
-set(distcheck_dependency_cache "${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp/distcheck_dependencies.cmake")
-set(distcheck_dependency_vars BRLCAD_REPOSITORY_ROOT BRLCAD_EXT_DIR)
-foreach(distcheck_optional_var BRLCAD_EXT_SOURCE_DIR BRLCAD_EXT_PARALLEL)
-  if(DEFINED ${distcheck_optional_var})
-    list(APPEND distcheck_dependency_vars ${distcheck_optional_var})
-  endif()
-endforeach()
-file(WRITE "${distcheck_dependency_cache}" "")
-foreach(distcheck_var IN LISTS distcheck_dependency_vars)
-  set(distcheck_value "${${distcheck_var}}")
-  if(distcheck_var STREQUAL "BRLCAD_REPOSITORY_ROOT")
-    set(distcheck_value "${_BRLCAD_REPOSITORY_ROOT}")
-  endif()
-  set(distcheck_type STRING)
-  if(distcheck_var MATCHES "_DIR$")
-    set(distcheck_type PATH)
-  endif()
-  string(REPLACE "\\" "\\\\" distcheck_value "${distcheck_value}")
-  string(REPLACE "\"" "\\\"" distcheck_value "${distcheck_value}")
-  string(REPLACE "$" "\\$" distcheck_value "${distcheck_value}")
-  file(APPEND "${distcheck_dependency_cache}"
-    "set(${distcheck_var} \"${distcheck_value}\" CACHE ${distcheck_type} \"Inherited dependency setting\" FORCE)\n")
-endforeach()
-distclean("${distcheck_dependency_cache}")
-
 # Utility function for defining individual distcheck targets
 macro(
  create_distcheck
@@ -147,10 +120,7 @@ macro(

    # Need to set these locally so configure_file will pick them up...
    set(TARGET_SUFFIX ${TARGET_SUFFIX})
-    # Keep machine-specific settings out of the options saved for CI above.
-    # The shared cache replaces each variant's unquoted output argument.
-    string(REPLACE "-DBRLCAD_EXT_DIR=${BRLCAD_EXT_DIR}" "" CMAKE_OPTS "${CMAKE_OPTS_IN}")
-    string(APPEND CMAKE_OPTS " -C \"${distcheck_dependency_cache}\"")
+    set(CMAKE_OPTS ${CMAKE_OPTS_IN})

    # For configure_file, need to set these as variables not just input parameters
    set(source_dir "${source_dir}")
@@ -1,9 +1,3 @@
-brlcad (7.46.0-0) unstable; urgency=low
-
-  * update brlcad version
-
- -- Cliff Yapp <cyapp@brlcad.org>  Thu, 07 Oct 2026 20:24:00 +0000
-
 brlcad (7.44.0-0) unstable; urgency=low

  * update brlcad version
@@ -11,7 +11,7 @@
 \f0\i\b\fs72 \cf0 README
 \fs36 \

-\f1\i0\b0\fs28 This is BRL-CAD 7.46.0 for Mac OS X.  Please send any bugs, comments, questions, or suggestions to the project website.\
+\f1\i0\b0\fs28 This is BRL-CAD 7.44.0 for Mac OS X.  Please send any bugs, comments, questions, or suggestions to the project website.\

 \fs22 \

@@ -4,7 +4,7 @@
 \margl1440\margr1440\vieww8020\viewh6280\viewkind0
 \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural

-\f0\fs22 \cf0 This installer will guide you through the installation of BRL-CAD 7.46.0 for Mac OS X and Darwin.\
+\f0\fs22 \cf0 This installer will guide you through the installation of BRL-CAD 7.44.0 for Mac OS X and Darwin.\
 \
 This distribution of BRL-CAD requires approximately 500 MB of available disk space and does not include source code.\
 \
@@ -117,20 +117,6 @@ if(TARGET libged)

 endif(TARGET libged)

-if(TARGET librt AND FUZZER_SUPPORTED)
-  set(RT_EDIT_FUZZ_DIR "${CMAKE_SOURCE_DIR}/src/librt/tests/edit")
-  brlcad_addexec(
-    fuzz_rt_edit_test
-    "${RT_EDIT_FUZZ_DIR}/fuzz.cpp;${RT_EDIT_FUZZ_DIR}/ars.cpp;${RT_EDIT_FUZZ_DIR}/bot.cpp"
-    "libbu;librt;libnmg;libwdb;libbrep"
-    TEST
-  )
-  set_target_properties(fuzz_rt_edit_test PROPERTIES UNITY_BUILD OFF)
-  target_compile_options(fuzz_rt_edit_test PRIVATE ${FUZZER_EXE_COMPILE_OPTIONS})
-  target_link_options(fuzz_rt_edit_test PRIVATE ${FUZZER_LINK_OPTIONS})
-  BRLCAD_ADD_TEST(NAME fuzz_rt_edit_smoke COMMAND fuzz_rt_edit_test -runs=1 -max_total_time=5)
-endif()
-
 cmakefiles(
  CMakeLists.txt
  fuzz_ged.cpp
@@ -79,9 +79,7 @@ endif(NOT EXISTS \"\${GCV_EXEC}\")\n"
  # setup conversion tests
  foreach(in_file ${INPUT_FILES})
    get_filename_component(curr_in_basename ${in_file} NAME_WLE)
-    # Tests in the same directory may run concurrently, so their output paths
-    # must not overlap.
-    set(out_path "${CMAKE_CURRENT_BINARY_DIR}/conv-${TARGET_DIRECTION}-${curr_in_basename}")
+    set(out_path "${CMAKE_CURRENT_BINARY_DIR}/conv-${curr_in_basename}")

    # need to split suffix so we can distinguish from different converters
    if(${fmt}_EXPORTER)
@@ -122,7 +120,7 @@ endif(NOT EXISTS \"\${GCV_EXEC}\")\n"
        )
      endif(${fmt}_GCV_OPTIONS)

-      set(out_distclean ${out_distclean} "${out_path}-${out_fmt}${out_suffix}")
+      set(out_distclean ${out_distclean}} "${out_path}-${out_fmt}${out_suffix}")
      set(expected_output_files "${expected_output_files} \"${out_path}-${out_fmt}${out_suffix}\"")
    endforeach(out_fmt ${${fmt}_CONVERTERS})

@@ -164,8 +162,19 @@ execute_process(

 file(APPEND \"\${LOGFILE}\" \"\${log_msg}\\n\")
 unset(log_msg)
+  "
+    )

-# check output files exist and are a reasonable size
+    set(OUTPUT_FILES ${OUTPUT_FILES} ${out_distclean})
+    unset(expected_output_files)
+    unset(out_distclean)
+  endforeach(in_file ${INPUT_FILES})
+
+  file(
+    APPEND
+    ${cmake_in_path}
+    "
+# check output files exists and are a reasonable size
 foreach(out_file \${ofiles})
  if(NOT EXISTS \"\${out_file}\")
    file(APPEND \"\${LOGFILE}\" \"FAILURE: \${curr_result}, \${out_file} not found.\")
@@ -182,18 +191,13 @@ foreach(out_file \${ofiles})
      file(APPEND \"\${LOGFILE}\" \"FAILURE: \${curr_result} file size is \${file_size} for \${out_file}\\n    Expecting ${EXPECTED_FILE_SIZE} with delta ${FILE_SIZE_DELTA}\")
      message(FATAL_ERROR \"[gcv] Failure while converting ${in_file}, see \${LOGFILE} for more info.\")
    endif(\"\${size_delta}\" GREATER \"${FILE_SIZE_DELTA}\")
-  endif(NOT EXISTS \"\${out_file}\")
+  endif(NOT EXISTS \"\${out_file}\")\n

  # cleanup file from build dir
  file(REMOVE \"\${out_file}\")
 endforeach(out_file \${ofiles})
-  "
-    )
-
-    set(OUTPUT_FILES ${OUTPUT_FILES} ${out_distclean})
-    unset(expected_output_files)
-    unset(out_distclean)
-  endforeach(in_file ${INPUT_FILES})
+    "
+  )

  # assume the fmt is the gcv dependency unless specified
  if(${fmt}_DEPS)
@@ -2,7 +2,7 @@ if(TARGET gcv-assetimport)
  gcv_regress_util("gltf" "tetra-gltf2.0.gltf;tetra-glb2.0.glb" DEPS "gcv;gcv-assetimport" GCV_OPTIONS "--input-format=assetimport")
  gcv_regress_util("glb" "tetra.g" DEPS "gcv;gcv-assetimport" GCV_OPTIONS "--output-format=assetimport" EXPECTED_FILE_SIZE "1476" EXPORTER)
  gcv_regress_util("gltf" "tetra.g" DEPS "gcv;gcv-assetimport" GCV_OPTIONS "--output-format=assetimport" EXPECTED_FILE_SIZE "3356" EXPORTER)
-  distclean("${CMAKE_CURRENT_BINARY_DIR}/conv-regress-g-gltf-tetra.bin")
+  distclean("${CMAKE_CURRENT_BINARY_DIR}/conv-tetra.bin")
 endif(TARGET gcv-assetimport)

 if(TARGET gcv-gltf)
@@ -1,7 +1,7 @@
 if(TARGET gcv-assetimport)
  set(dep_str DEPS "gcv;gcv-obj;gcv-assetimport" CONVERTERS "assetimport")

-  distclean("${CMAKE_CURRENT_BINARY_DIR}/conv-regress-g-obj-tetra-assetimport.mtl") # hard to track companion files
+  distclean("${CMAKE_CURRENT_BINARY_DIR}/conv-tetra-assetimport.mtl") # hard to track companion files
 else()
  set(dep_str "")
 endif(TARGET gcv-assetimport)
@@ -9,7 +9,7 @@ endif(TARGET gcv-assetimport)
 gcv_regress_util("obj" "tetra.obj" ${dep_str})
 gcv_regress_util("obj_unnamed_group" "tetra-unnamed-group.obj" DEPS "gcv;gcv-obj")
 gcv_regress_util("obj" "tetra.g" ${dep_str} EXPORTER)
-distclean("${CMAKE_CURRENT_BINARY_DIR}/conv-regress-g-obj-tetra.mtl")
+distclean("${CMAKE_CURRENT_BINARY_DIR}/conv-tetra.mtl")

 cmakefiles(
  CMakeLists.txt
@@ -23,7 +23,6 @@ set(
  gqa.mass_mix.am.out
  gqa.mass_mix.aw.out
  gqa.mass_mix.u0.out
-  gqa.missing_density.out
  gqa.mged
  gqa.overlaps.plot3
  gqa.sphere_adaptive.out
@@ -67,11 +67,6 @@ run_capture ( ) {
    return $ret
 }

-expect_failure ( ) {
-    "$@"
-    test $? -ne 0
-}
-
 extract_last_number ( ) {
    label="$1"
    file="$2"
@@ -106,19 +101,6 @@ assert_close ( ) {
    fi
 }

-assert_contains ( ) {
-    expected="$1"
-    file="$2"
-    desc="$3"
-
-    if grep -F -q "$expected" "$file" ; then
-	log "PASS: $desc"
-    else
-	log "FAIL: $desc"
-	STATUS="`expr $STATUS + 1`"
-    fi
-}
-
 MGED="`ensearch mged`"
 if test ! -f "$MGED" ; then
    log "Unable to find mged, aborting"
@@ -195,10 +177,6 @@ adjust mass_air.r GIFTmater 2
 g mass_air_only.g mass_air.r
 g mass_air_mix.g mass_solid.r mass_air.r

-in missing_density.s rpp 2 3 0 1 0 1
-r missing_density.r u missing_density.s
-adjust missing_density.r GIFTmater 123
-
 in sphere.s sph 0 0 0 1
 r sphere.r u sphere.s
 adjust sphere.r GIFTmater 5
@@ -265,7 +243,6 @@ run_capture gqa.mass_mix.aw.out $GQABIN -u m,m^3,kg -g 250mm-50mm -Aw gqa.g mass
 run_capture gqa.mass_mix.am.out $GQABIN -u m,m^3,kg -g 250mm-50mm -Am gqa.g mass_air_mix.g
 run_capture gqa.mass_mix.u0.out $GQABIN -u m,m^3,kg -g 250mm-50mm -U 0 -Aw gqa.g mass_air_mix.g
 run_capture gqa.sphere_adaptive.out $GQABIN -u m,m^3,kg -q -Av -g 0.05m gqa.g sphere.r
-run_capture gqa.missing_density.out expect_failure $GQABIN -u m,m^3,kg -g 250mm-50mm -f density_table.txt -Aw gqa.g missing_density.r

 MASS_AIR_AW="`extract_last_number 'Average total weight:' gqa.mass_air.aw.out`"
 MASS_AIR_AM="`extract_last_number 'Average total weight:' gqa.mass_air.am.out`"
@@ -280,7 +257,6 @@ assert_close 1001 "$MASS_MIX_AW" 0.001 "mixed solid+air modeled weight with -Aw"
 assert_close "$MASS_MIX_AW" "$MASS_MIX_AM" 0.001 "-Aw and -Am agree on mixed modeled air"
 assert_close 1000 "$MASS_MIX_U0" 0.001 "-U 0 excludes modeled air from weight"
 assert_close 4.18879 "$SPHERE_VOLUME" 0.01 "adaptive sphere volume refines beyond symmetric first pass"
-assert_contains "Density 123 on region /missing_density.r is not defined in the density table." gqa.missing_density.out "undefined density produces an error"


 if [ $STATUS = 0 ] ; then
@@ -68,7 +68,6 @@ set(
  sca_view.mged
  search_exec.mged
  sed.mged
-  sed_reset.mged
  set_perspective.mged
  setview.mged
  size.mged
@@ -101,7 +100,6 @@ if(TARGET mged)
      continue()
    endif(TNAME STREQUAL "")

-    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${testfile}")
    file(READ "${CMAKE_CURRENT_SOURCE_DIR}/${testfile}" TEST_CONTENTS)
    if(TNAME STREQUAL "search_exec")
      string(CONFIGURE "${TEST_CONTENTS}" TEST_CONTENTS @ONLY)
@@ -128,12 +126,6 @@ if(TARGET mged)
    elseif(TNAME STREQUAL "arb")
      set(TEST_EXPECT "'arb' testing completed")
      set(TEST_SOURCE "${CMAKE_CURRENT_BINARY_DIR}/regress_${testfile}")
-    elseif(TNAME MATCHES "^(extrude|facedef|mirface|permute)$")
-      set(TEST_EXPECT "'${TNAME}' testing completed")
-      set(TEST_SOURCE "${CMAKE_CURRENT_BINARY_DIR}/regress_${testfile}")
-    elseif(TNAME STREQUAL "edgedir")
-      set(TEST_EXPECT "'edarb edgedir' testing completed")
-      set(TEST_SOURCE "${CMAKE_CURRENT_BINARY_DIR}/regress_${testfile}")
    elseif(TNAME STREQUAL "killtree")
      set(TEST_EXPECT "KILL Solid:  killtree_dup.s")
      set(TEST_REJECT "db_lookup(killtree_dup.s) failed")
@@ -146,10 +138,6 @@ if(TARGET mged)
    elseif(TNAME STREQUAL "prim_edit")
      set(TEST_EXPECT "Primitive parameter editing testing completed")
      set(TEST_REJECT "FAIL:")
-    elseif(TNAME STREQUAL "sed_reset")
-      set(TEST_EXPECT "PASS: 'sed_reset' testing completed")
-      set(TEST_REJECT "FAIL:")
-      set(TEST_SOURCE "${CMAKE_CURRENT_BINARY_DIR}/regress_${testfile}")
    elseif(TNAME STREQUAL "overlap_plotting")
      set(TEST_DB "${CMAKE_SOURCE_DIR}/src/libged/tests/ged_tests.g")
      set(TEST_EXPECT "PASS overlap plotting")
@@ -199,7 +187,6 @@ distclean(${mged_outfiles})

 cmakefiles(
  CMakeLists.txt
-  csg_edit.mged
  mged.tcl
  regression_resources.tcl
  search_exec_procs.tcl
@@ -119,35 +119,4 @@ if {![catch {get $invalid_inner}]} {
 }


-# ARBN uses one independent thickness per plane.  Exercise unequal offsets so
-# the test also verifies the plane ordering and inward normal convention.
-set arbn_outer inside_arbn_outer.s
-set arbn_inner inside_arbn_inner.s
-set arbn_thicknesses {1 2 3 4 1.5 0.5}
-in $arbn_outer arbn 6 \
-    1 0 0 10  -1 0 0 0 \
-    0 1 0 10   0 -1 0 0 \
-    0 0 1 10   0 0 -1 0
-if {[catch {inside $arbn_outer $arbn_inner {*}$arbn_thicknesses} result]} {
-    error "inside failed for ARBN: $result"
-}
-set arbn_definition [get $arbn_inner]
-set expected_offsets {9 -2 7 -4 8.5 -0.5}
-for {set plane 0} {$plane < 6} {incr plane} {
-    set equation [lindex $arbn_definition [expr {4 + 2 * $plane}]]
-    set actual_offset [lindex $equation 3]
-    if {abs($actual_offset - [lindex $expected_offsets $plane]) > $plane_tolerance} {
-	error "ARBN inside plane $plane has offset $actual_offset: $arbn_definition"
-    }
-}
-facetize -n inside_arbn_inner_nmg.s $arbn_inner
-
-set invalid_arbn_inner inside_arbn_invalid.s
-if {![catch {inside $arbn_outer $invalid_arbn_inner {*}[lrepeat 6 6]}]} {
-    error "ARBN inside accepted thicknesses that collapse the solid"
-}
-if {![catch {get $invalid_arbn_inner}]} {
-    error "ARBN inside wrote an invalid collapsed solid"
-}
-
 puts "*** 'arb' testing completed ***"
@@ -962,140 +962,8 @@ foreach test [list \
    csg_matrix_mouse_check {*}$test
 }

-puts "--- Repeated graphical object transforms ---"
-proc csg_matrix_repeated_mouse_check {} {
-    global orig_gui transform csg_mouse_dm_pixels csg_mouse_view_size
-    global csg_drag_scale
-    set prim csg_matrix_repeat.s
-    set inner csg_matrix_repeat_inner.c
-    set outer csg_matrix_repeat_outer.c
-    set saved_orig_gui $orig_gui
-    set expected [csg_edit_identity_matrix]
-    set failed [catch {
-        in $prim sph 0 0 0 10
-        comb $inner u $prim
-        comb $outer u $inner
-        set orig_gui 0
-        for {set step 0} {$step < 16} {incr step} {
-            e $outer
-            center 0 0 0
-            size $csg_mouse_view_size
-            setview 0 0 0
-            dm size $csg_mouse_dm_pixels $csg_mouse_dm_pixels
-            _mged_press oill
-            _mged_ill -e -i 1 /$outer/$inner/$prim
-            _mged_matpick 2
-            if {[status state] ne "OBJ EDIT" || $transform ne "e"} {
-                error "step $step did not enter object editing"
-            }
-            set view_before [csg_edit_view_state]
-            if {$step % 2 == 0} {
-                press Rotate
-                dm con r z 100 100
-                set operation [csg_matrix_axis_rotation z 10]
-                set motion {dm motion 140 100}
-            } else {
-                press Scale
-                dm am s 100 100
-                set operation [csg_matrix_scale all $csg_drag_scale]
-                set motion {dm motion 164 100}
-            }
-            set motion_code [catch {uplevel #0 $motion} motion_result]
-            if {$motion_code != 0 && $motion_code != 2} {
-                error "step $step mouse motion failed: $motion_result"
-            }
-            dm idle
-            press accept
-            set expected [csg_matrix_multiply $operation $expected]
-            csg_edit_comb_leaf_matrix_at $inner $prim $expected
-            csg_edit_view_state_at $view_before
-            d $outer
-        }
-    } failure]
-    set orig_gui $saved_orig_gui
-    catch {press reject}
-    catch {Z}
-    foreach object [list $outer $inner $prim] {
-        catch {kill $object}
-    }
-    if {$failed} {
-        puts "  FAIL: repeated object mouse rotations/scales ($failure)"
-    } else {
-        puts "  PASS: repeated object mouse rotations/scales"
-    }
-}
-csg_matrix_repeated_mouse_check
-
 puts "--- All ARB point, edge, and face states ---"

-proc csg_edit_sed_point {attribute} {
-    set serialized [get_sed]
-    set index [lsearch -exact $serialized $attribute]
-    if {$index < 0 || $index + 1 >= [llength $serialized]} {
-        error "get_sed has no $attribute: $serialized"
-    }
-    return [lindex $serialized [expr {$index + 1}]]
-}
-
-proc csg_arb_repeated_mouse_check {} {
-    global orig_gui csg_bv_coord_half_range csg_mouse_dm_pixels
-    global csg_mouse_view_size
-    set source csg_lifecycle_arb5.s
-    set prim csg_arb_repeat.s
-    set saved_orig_gui $orig_gui
-    set expected {}
-    set failed [catch {
-        cp $source $prim
-        e $prim
-        center 0 0 0
-        size $csg_mouse_view_size
-        setview 0 0 0
-        dm size $csg_mouse_dm_pixels $csg_mouse_dm_pixels
-        set orig_gui 0
-        sed $prim
-        press {Move Edges}
-        press {Move Point 5}
-        set original_z [lindex [db get $source V5] 2]
-        for {set step 0} {$step < 64} {incr step} {
-            if {$step > 0 && $step % 8 == 0} {
-                press sedit
-                press {Move Edges}
-                press {Move Point 5}
-            }
-            set mouse_x [expr {150 + 2 * ($step % 5)}]
-            set mouse_y [expr {150 + 2 * (($step * 3) % 5)}]
-            M 1 $mouse_x $mouse_y
-            set expected [list \
-                [expr {$mouse_x / $csg_bv_coord_half_range * $csg_mouse_view_size / 2.0}] \
-                [expr {$mouse_y / $csg_bv_coord_half_range * $csg_mouse_view_size / 2.0}] \
-                $original_z]
-            set actual [csg_edit_sed_point V5]
-            if {[csg_edit_point_distance $actual $expected] > 0.000001} {
-                error "step $step expected V5 $expected, got $actual"
-            }
-        }
-        press accept
-        d $prim
-        if {[csg_edit_point_distance [db get $prim V5] $expected] > 0.000001} {
-            error "accepted V5 differs from the final mouse target"
-        }
-        foreach vertex {V1 V2 V3 V4} {
-            csg_edit_point_matches_source $source $vertex $prim
-        }
-        arb_standard_storage_check arb5 $prim
-    } failure]
-    set orig_gui $saved_orig_gui
-    catch {press reject}
-    catch {d $prim}
-    catch {kill $prim}
-    if {$failed} {
-        puts "  FAIL: repeated ARB5 mouse movement ($failure)"
-    } else {
-        puts "  PASS: repeated ARB5 mouse movement"
-    }
-}
-csg_arb_repeated_mouse_check
-
 # Every ARB menu entry is checked independently.  The variants do not share
 # menu indices, so sampling one edge or face would miss precisely the class of
 # integration failure this test is intended to catch.  Move each selection a
@@ -1454,280 +1322,6 @@ csg_edit_sequence_check csg_lifecycle_dsp.s "Toggle Smooth" {
    {press {Toggle Smooth}}
 } [list csg_edit_scalar_at sm 1]

-puts "--- Specialized mouse editing and menu inventory ---"
-proc csg_edit_prepare_mouse_view {} {
-    global csg_dispatch_view_size
-    center 0 0 0
-    size $csg_dispatch_view_size
-    setview 0 0 0
-}
-array set csg_mouse_covered {}
-proc csg_mouse_case {source menu_items label commands validator} {
-    global csg_mouse_covered
-    csg_edit_sequence_check $source $label $commands $validator
-    set type [lindex [db get $source] 0]
-    if {![info exists csg_mouse_covered($type)]} {
-        set csg_mouse_covered($type) {}
-    }
-    foreach item $menu_items {
-        if {[lsearch -exact $csg_mouse_covered($type) $item] < 0} {
-            lappend csg_mouse_covered($type) $item
-        }
-    }
-}
-proc csg_edit_menu_inventory_check {source ignored} {
-    global csg_mouse_covered
-    if {[catch {
-        Z
-        e $source
-        sed $source
-        set actual [mmenu_get 0]
-        set type [lindex [db get $source] 0]
-        set covered {}
-        if {[info exists csg_mouse_covered($type)]} {
-            set covered $csg_mouse_covered($type)
-        }
-        foreach item $actual {
-            set tested [expr {[lsearch -exact $covered $item] >= 0}]
-            set exempt [expr {[lsearch -exact $ignored $item] >= 0}]
-            if {$tested == $exempt} {
-                error "menu entry '$item' needs exactly one mouse-test or exclusion"
-            }
-        }
-        foreach item [concat $covered $ignored] {
-            if {[lsearch -exact $actual $item] < 0} {
-                error "recorded menu entry '$item' is absent from $actual"
-            }
-        }
-        press reject
-        d $source
-    } failure]} {
-        puts "  FAIL: menu inventory $source ($failure)"
-        catch {press reject}
-        catch {Z}
-    } else {
-        puts "  PASS: menu inventory $source"
-    }
-}
-
-csg_edit_prepare_mouse_view
-set csg_special_mouse_target [list \
-    [expr {512.0 / $csg_bv_coord_half_range * $csg_dispatch_view_size / 2.0}] \
-    [expr {512.0 / $csg_bv_coord_half_range * $csg_dispatch_view_size / 2.0}] 0]
-set csg_special_mouse_scale [expr {1.0 + 2047.0 / ($csg_bv_coord_half_range * 4.0)}]
-set csg_special_mouse_shrink [expr {
-    1.0 / (1.0 + 1024.0 / ($csg_bv_coord_half_range * 4.0))}]
-csg_mouse_case csg_lifecycle_pipe.s {{Move Point}} "mouse select and move point" {
-    {csg_edit_prepare_mouse_view}
-    {press {Select Point}}
-    {p 0 0 0}
-    {press {Move Point}}
-    {M 1 512 512}
-} [list csg_edit_point_at V0 $csg_special_mouse_target]
-in csg_mouse_pipe_topology.s pipe 4 \
-    0 0 0 1 2 3 \
-    0 0 30 1 2 3 \
-    30 40 80 1 2 3 \
-    80 80 100 1 2 3
-csg_mouse_case csg_mouse_pipe_topology.s {{Select Point} {Move Point}} "mouse select point" {
-    {csg_edit_prepare_mouse_view}
-    {press {Select Point}}
-    {M 1 0 0}
-    {press {Move Point}}
-    {M 1 512 512}
-} [list csg_edit_point_at V0 $csg_special_mouse_target]
-csg_mouse_case csg_mouse_pipe_topology.s {{Append Point}} "mouse append point" {
-    {csg_edit_prepare_mouse_view}
-    {press {Append Point}}
-    {M 1 512 512}
-} [list csg_edit_point_at V4 {5 5 0}]
-csg_mouse_case csg_mouse_pipe_topology.s {{Prepend Point}} "mouse prepend point" {
-    {csg_edit_prepare_mouse_view}
-    {press {Prepend Point}}
-    {M 1 512 512}
-} [list csg_edit_point_at V0 {5 5 0}]
-csg_mouse_case csg_mouse_pipe_topology.s {{Split Segment}} "mouse split segment" {
-    {csg_edit_prepare_mouse_view}
-    {press {Select Point}}
-    {p 0 0 0}
-    {press {Split Segment}}
-    {M 1 512 512}
-} [list csg_edit_point_at V1 {5 5 0}]
-foreach {item attribute initial} {
-    {Set Point OD} O0 5
-    {Set Point ID} I0 3
-    {Set Point Bend} R0 6
-} {
-    csg_mouse_case csg_lifecycle_pipe.s [list $item] "mouse $item" [list \
-        {csg_edit_prepare_mouse_view} \
-        {press {Select Point}} {p 0 0 0} [list press $item] \
-        {M 1 0 -1024}] \
-        [list csg_edit_scalar_at $attribute [expr {$initial * $csg_special_mouse_shrink}]]
-}
-foreach {item attributes initial} {
-    {Set Pipe OD} {O0 O1 O2 O3} {5 5 6 6}
-    {Set Pipe ID} {I0 I1 I2 I3} {3 3 2 0}
-    {Set Pipe Bend} {R0 R1 R2 R3} {6 7 10 8}
-} {
-    set expected {}
-    foreach value $initial {
-        lappend expected [expr {$value * $csg_special_mouse_shrink}]
-    }
-    csg_mouse_case csg_lifecycle_pipe.s [list $item] "mouse $item" [list \
-        {csg_edit_prepare_mouse_view} \
-        [list press $item] {M 1 0 -1024}] \
-        [list csg_edit_scalar_values_at $attributes $expected]
-}
-proc csg_edit_bot_vertices_moved {source moved delta prim} {
-    set vertices [db get $source V]
-    for {set index 0} {$index < [llength $vertices]} {incr index} {
-        set expected [lindex $vertices $index]
-        if {[lsearch -exact $moved $index] >= 0} {
-            set translated {}
-            foreach value $expected shift $delta {
-                lappend translated [expr {$value + $shift}]
-            }
-            set expected $translated
-        }
-        csg_edit_list_value_at V $index $expected $prim
-    }
-}
-csg_mouse_case csg_lifecycle_bot.s {{Move Vertex}} "mouse move vertex" {
-    {csg_edit_prepare_mouse_view}
-    {press {Pick Vertex}}
-    {p 0}
-    {press {Move Vertex}}
-    {M 1 512 512}
-} [list csg_edit_bot_vertices_moved csg_lifecycle_bot.s {0} \
-    $csg_special_mouse_target]
-csg_mouse_case csg_lifecycle_bot.s {{Pick Vertex} {Move Vertex}} "mouse pick and move vertex" {
-    {csg_edit_prepare_mouse_view}
-    {press {Pick Vertex}}
-    {M 1 0 0}
-    {press {Move Vertex}}
-    {M 1 512 512}
-} [list csg_edit_bot_vertices_moved csg_lifecycle_bot.s {0} \
-    $csg_special_mouse_target]
-csg_mouse_case csg_lifecycle_bot.s {{Move Edge}} "mouse move edge" {
-    {csg_edit_prepare_mouse_view}
-    {press {Pick Edge}}
-    {p 0 1}
-    {press {Move Edge}}
-    {M 1 1024 512}
-} [list csg_edit_bot_vertices_moved csg_lifecycle_bot.s {0 1} {10 5 0}]
-csg_mouse_case csg_lifecycle_bot.s {{Pick Edge} {Move Edge}} "mouse pick and move edge" {
-    {csg_edit_prepare_mouse_view}
-    {press {Pick Edge}}
-    {M 1 512 512}
-    {press {Move Edge}}
-    {M 1 1024 512}
-} [list csg_edit_bot_vertices_moved csg_lifecycle_bot.s {0 1} {10 5 0}]
-csg_mouse_case csg_lifecycle_bot.s {{Move Triangle}} "mouse move triangle" {
-    {csg_edit_prepare_mouse_view}
-    {press {Pick Triangle}}
-    {p 0 1 2}
-    {press {Move Triangle}}
-    {M 1 512 512}
-} [list csg_edit_bot_vertices_moved csg_lifecycle_bot.s {0 1 2} \
-    $csg_special_mouse_target]
-csg_mouse_case csg_lifecycle_ebm.s {{Extrude Depth}} "mouse extrusion depth" {
-    {csg_edit_prepare_mouse_view}
-    {press {Extrude Depth}}
-    {M 1 0 2047}
-} [list csg_edit_scalar_at H [expr {4.0 * $csg_special_mouse_scale}]]
-csg_mouse_case csg_lifecycle_vol.s {{Threshold (low)}} "mouse low threshold" {
-    {csg_edit_prepare_mouse_view}
-    {press {Threshold (low)}}
-    {p 10}
-    {M 1 0 2047}
-} [list csg_edit_scalar_at lo [expr {int(10.0 * $csg_special_mouse_scale)}]]
-csg_mouse_case csg_lifecycle_vol.s {{Voxel Size (X Y Z)}} "mouse voxel size" {
-    {csg_edit_prepare_mouse_view}
-    {press {Voxel Size (X Y Z)}}
-    {M 1 0 2047}
-} [list csg_edit_point_at size [list \
-    $csg_special_mouse_scale $csg_special_mouse_scale $csg_special_mouse_scale]]
-csg_mouse_case csg_lifecycle_vol.s {{Threshold (hi)}} "mouse high threshold" {
-    {csg_edit_prepare_mouse_view}
-    {press {Threshold (hi)}}
-    {M 1 0 -1024}
-} [list csg_edit_scalar_at hi [expr {int(255.0 * $csg_special_mouse_shrink)}]]
-csg_mouse_case csg_lifecycle_dsp.s {{Set X}} "mouse X scale" {
-    {csg_edit_prepare_mouse_view}
-    {press {Set X}}
-    {M 1 0 2047}
-} [list csg_edit_matrix_component_at stom 0 $csg_special_mouse_scale]
-foreach {item index} {{Set Y} 5 {Set ALT} 10} {
-    csg_mouse_case csg_lifecycle_dsp.s [list $item] "mouse $item" [list \
-        {csg_edit_prepare_mouse_view} \
-        [list press $item] {M 1 0 2047}] \
-        [list csg_edit_matrix_component_at stom $index $csg_special_mouse_scale]
-}
-foreach type {arbn brep} {
-    set source csg_lifecycle_${type}.s
-    csg_edit_sequence_check $source "generic mouse translation" {
-        {csg_edit_prepare_mouse_view}
-        {keypoint 0 0 0}
-        {press sxy}
-        {M 1 512 512}
-    } [list csg_edit_bbox_translated $source $csg_special_mouse_target]
-}
-
-# Every specialized menu entry must be accounted for.  Exclusions are menu
-# headings, non-positional actions/settings, or the BOT triangle picker (tested
-# under Xmin because it needs Tk).  A new entry without a mouse case or
-# explicit exclusion fails here.
-foreach {source ignored} {
-    csg_lifecycle_pipe.s {
-        {PIPE MENU} {Next Point} {Previous Point} {Delete Point}
-    }
-    csg_lifecycle_bot.s {
-        {BOT MENU} {Pick Triangle} {Move Vertex List}
-        {Split Edge} {Split Face} {Fuse Vertices} {Fuse Faces}
-        {Delete Triangle} {Select Mode} {Select Orientation}
-        {Set flags} {Set Face Thickness} {Set Face Mode}
-    }
-    csg_lifecycle_dsp.s {
-        {DSP MENU} Name {Toggle Smooth} {Set Data Source}
-    }
-    csg_lifecycle_ebm.s {
-        {EBM MENU} {File Name} {File Size (W N)}
-    }
-    csg_lifecycle_vol.s {
-        {VOL MENU} {File Name} {File Size (X Y Z)}
-    }
-    csg_lifecycle_arbn.s {}
-    csg_lifecycle_brep.s {}
-} {
-    csg_edit_menu_inventory_check $source $ignored
-}
-
-# A view-space request must remain view-space even when the editor's current
-# coordinate system is object-relative.  This is the fast path underlying the
-# corresponding real mouse drag in the Xmin GUI test.
-set csg_saved_coords [rset var coords]
-set csg_saved_transform [rset var transform]
-if {[catch {
-    Z
-    e csg_lifecycle_bot.s
-    sed csg_lifecycle_bot.s
-    center 0 0 0
-    rset var coords o
-    rset var transform v
-    knob -i -v aX 1
-    if {[csg_edit_point_distance [center] {-1 0 0}] > 0.000001} {
-        error "explicit view knob left center at [center]"
-    }
-} csg_view_override_error]} {
-    puts "  FAIL: view-space translation with object coordinates ($csg_view_override_error)"
-} else {
-    puts "  PASS: view-space translation with object coordinates"
-}
-catch {press reject}
-catch {Z}
-rset var coords $csg_saved_coords
-rset var transform $csg_saved_transform
-
 file delete -force $csg_data_file
 file delete -force $csg_dsp_file

@@ -43,37 +43,4 @@ foreach {arb_type face expected_type} $arb_extrude_cases {
    arb_standard_storage_check $expected_type $prim
 }

-# A one-inch extrusion must extend a face by 25.4 base millimeters through
-# both the direct libged command and MGED's interactive solid editor.
-set inch_in_mm 25.4
-set tolerance 0.001
-foreach mode {direct interactive} {
-    set suffix "_inch_$mode"
-    in_arb8 extrude $suffix
-    set prim "extrude_arb8${suffix}.s"
-    set base_x [lindex [db get $prim V1] 0]
-
-    units in
-    if {$mode eq "direct"} {
-	if {[catch {edarb extrude $prim 1234 1} result]} {
-	    error "inch edarb extrusion failed: $result"
-	}
-    } else {
-	Z
-	e $prim
-	sed $prim
-	if {[catch {extrude 1234 1} result]} {
-	    error "inch MGED extrusion failed: $result"
-	}
-	accept
-	Z
-    }
-    units mm
-
-    set new_x [lindex [db get $prim V5] 0]
-    if {abs($new_x - $base_x - $inch_in_mm) > $tolerance} {
-	error "inch $mode extrusion moved V5 by [expr {$new_x - $base_x}] mm"
-    }
-}
-
 puts "*** 'extrude' testing completed ***"
@@ -31,7 +31,6 @@ in tor_pe.s tor 0 0 0  0 0 1  20 2
 prim_edit_check      tor_pe.s "Set Radius 1" 30 r_a 30 -1
 prim_edit_check      tor_pe.s "Set Radius 2"  5 r_h  5 -1
 prim_edit_mouse_check tor_pe.s "Set Radius 1" r_a 30 -1
-prim_edit_mouse_check tor_pe.s "Set Radius 2" r_h 5 -1
 kill tor_pe.s

 puts "--- ELL (ellipsoid: A, B, C) ---"
@@ -40,8 +39,6 @@ prim_edit_check      ell_pe.s "Set A" 8 A 8 0
 prim_edit_check      ell_pe.s "Set B" 6 B 6 1
 prim_edit_check      ell_pe.s "Set C" 4 C 4 2
 prim_edit_mouse_check ell_pe.s "Set A" A 8 0
-prim_edit_mouse_check ell_pe.s "Set B" B 6 1
-prim_edit_mouse_check ell_pe.s "Set C" C 4 2
 kill ell_pe.s

 puts "--- RPC (right parabolic cylinder: H, r) ---"
@@ -49,7 +46,6 @@ in rpc_pe.s rpc 0 0 0  0 0 10  0 5 0  3
 prim_edit_check      rpc_pe.s "Set H" 20 H 20 2
 prim_edit_check      rpc_pe.s "Set r"  6 r  6 -1
 prim_edit_mouse_check rpc_pe.s "Set H" H 20 2
-prim_edit_mouse_check rpc_pe.s "Set r" r 6 -1
 kill rpc_pe.s

 puts "--- RHC (right hyperbolic cylinder: H, r, c) ---"
@@ -58,8 +54,6 @@ prim_edit_check      rhc_pe.s "Set H" 20 H 20 2
 prim_edit_check      rhc_pe.s "Set r"  6 r  6 -1
 prim_edit_check      rhc_pe.s "Set c"  3 c  3 -1
 prim_edit_mouse_check rhc_pe.s "Set r" r 6 -1
-prim_edit_mouse_check rhc_pe.s "Set H" H 20 2
-prim_edit_mouse_check rhc_pe.s "Set c" c 3 -1
 kill rhc_pe.s

 puts "--- EPA (elliptical paraboloid: H, r_1, r_2) ---"
@@ -68,8 +62,6 @@ prim_edit_check      epa_pe.s "Set H" 20 H   20 2
 prim_edit_check      epa_pe.s "Set A"  8 r_1  8 -1
 prim_edit_check      epa_pe.s "Set B"  4 r_2  4 -1
 prim_edit_mouse_check epa_pe.s "Set H" H 20 2
-prim_edit_mouse_check epa_pe.s "Set A" r_1 8 -1
-prim_edit_mouse_check epa_pe.s "Set B" r_2 4 -1
 kill epa_pe.s

 puts "--- EHY (elliptical hyperboloid: H, r_1, c) ---"
@@ -78,8 +70,6 @@ prim_edit_check      ehy_pe.s "Set H" 20 H   20 2
 prim_edit_check      ehy_pe.s "Set A"  8 r_1  8 -1
 prim_edit_check      ehy_pe.s "Set c"  3 c    3 -1
 prim_edit_mouse_check ehy_pe.s "Set A" r_1 8 -1
-prim_edit_mouse_check ehy_pe.s "Set H" H 20 2
-prim_edit_mouse_check ehy_pe.s "Set c" c 3 -1
 kill ehy_pe.s

 puts "--- PART (particle: H, r_v, r_h) ---"
@@ -88,8 +78,6 @@ prim_edit_check      part_pe.s "Set H" 20 H   20 2
 prim_edit_check      part_pe.s "Set v"  4 r_v  4 -1
 prim_edit_check      part_pe.s "Set h"  3 r_h  3 -1
 prim_edit_mouse_check part_pe.s "Set v" r_v 4 -1
-prim_edit_mouse_check part_pe.s "Set H" H 20 2
-prim_edit_mouse_check part_pe.s "Set h" r_h 3 -1
 kill part_pe.s

 puts "--- TGC (truncated general cone: H, A, B, C, D) ---"
@@ -103,10 +91,6 @@ prim_edit_check      tgc_pe.s "Set B"  3 B   3 1
 prim_edit_check      tgc_pe.s "Set C"  3 C   3 0
 prim_edit_check      tgc_pe.s "Set D"  4 D   4 1
 prim_edit_mouse_check tgc_pe.s "Set H"  H 8 2
-prim_edit_mouse_check tgc_pe.s "Set A"  A 4 0
-prim_edit_mouse_check tgc_pe.s "Set B"  B 3 1
-prim_edit_mouse_check tgc_pe.s "Set C"  C 3 0
-prim_edit_mouse_check tgc_pe.s "Set D"  D 4 1
 kill tgc_pe.s

 puts "--- ETO (elliptical torus: r, C, D) ---"
@@ -116,7 +100,6 @@ prim_edit_check      eto_pe.s "Set r"  8   r   8   -1
 prim_edit_check      eto_pe.s "Set D"  1.5 r_d 1.5 -1
 prim_edit_mouse_check eto_pe.s "Set r"  r   8   -1
 prim_edit_mouse_check eto_pe.s "Set C"  C   5   0
-prim_edit_mouse_check eto_pe.s "Set D"  r_d 1.5 -1
 kill eto_pe.s

 puts "--- HYP (one-sheet hyperboloid: H, A, B, c) ---"
@@ -128,9 +111,6 @@ prim_edit_check      hyp_pe.s "Set A"  2   A   10   1
 prim_edit_check      hyp_pe.s "Set B"  2   b    4   -1
 prim_edit_check      hyp_pe.s "Set c"  0.5 bnr  0.25 -1
 prim_edit_mouse_check hyp_pe.s "Set H"  H  20   2
-prim_edit_mouse_check hyp_pe.s "Set A"  A  10   1
-prim_edit_mouse_check hyp_pe.s "Set B"  b  4    -1
-prim_edit_mouse_check hyp_pe.s "Set c"  bnr 0.25 -1
 kill hyp_pe.s

 puts "--- SUPERELL (superellipsoid: A, B, C) ---"
@@ -139,8 +119,6 @@ prim_edit_check      superell_pe.s "Set A" 5 A 5 0
 prim_edit_check      superell_pe.s "Set B" 4 B 4 1
 prim_edit_check      superell_pe.s "Set C" 3 C 3 2
 prim_edit_mouse_check superell_pe.s "Set A" A 5 0
-prim_edit_mouse_check superell_pe.s "Set B" B 4 1
-prim_edit_mouse_check superell_pe.s "Set C" C 3 2
 kill superell_pe.s

 puts "--- CLINE (cylinder line: H, R, plate thickness) ---"
@@ -151,7 +129,6 @@ prim_edit_check      cline_pe.s "Set R"              4   R 4   -1
 prim_edit_check      cline_pe.s "Set plate thickness" 0.4 T 0.4 -1
 prim_edit_mouse_check cline_pe.s "Set H" H 8   2
 prim_edit_mouse_check cline_pe.s "Set R" R 4   -1
-prim_edit_mouse_check cline_pe.s "Set plate thickness" T 0.4 -1
 kill cline_pe.s

 puts "--- NMG (non-manifold geometry: Pick Edge, Move Edge, Next EU) ---"
@@ -1,64 +0,0 @@
-puts "*** Testing 'sed_reset' command ***"
-
-proc sed_reset_check {primitive edit_commands} {
-    e $primitive
-    sed $primitive
-    if {[status state] ne "SOL EDIT"} {
-	error "$primitive entered [status state], not SOL EDIT"
-    }
-
-    set original [get_sed]
-    foreach command $edit_commands {
-	uplevel #0 $command
-    }
-    if {[get_sed] eq $original} {
-	error "$primitive edit did not change the working geometry"
-    }
-
-    sed_reset
-    if {[status state] ne "SOL EDIT"} {
-	error "$primitive reset entered [status state], not SOL EDIT"
-    }
-    if {[get_sed] ne $original} {
-	error "$primitive reset did not restore the original geometry"
-    }
-
-    press reject
-    if {[status state] ne "VIEWING"} {
-	error "$primitive reject entered [status state], not VIEWING"
-    }
-    d $primitive
-}
-
-if {[catch {
-    in sed_reset_arb8.s arb8 \
-	0 0 0  10 0 0  10 10 0  0 10 0 \
-	0 0 10  10 0 10  10 10 10  0 10 10
-    sed_reset_check sed_reset_arb8.s {
-	{press {Move Faces}}
-	{press {Move Face 1234}}
-	{p 0 0 -1}
-    }
-} failure]} {
-    puts "FAIL: ARB8 face move reset ($failure)"
-    catch {press reject}
-    catch {Z}
-} else {
-    puts "PASS: ARB8 face move reset"
-}
-
-if {[catch {
-    make sed_reset_cline.s cline
-    sed_reset_check sed_reset_cline.s {
-	{press {Move End H}}
-	{p 3 4 12}
-    }
-} failure]} {
-    puts "FAIL: CLINE edit reset ($failure)"
-    catch {press reject}
-    catch {Z}
-} else {
-    puts "PASS: CLINE edit reset"
-}
-
-puts "PASS: 'sed_reset' testing completed"
@@ -93,7 +93,6 @@ if(BRLCAD_X11_PROVIDER_RESOLVED STREQUAL "XMIN" AND
      "PLOT3_ASC_BIN=$<TARGET_FILE:plot3-asc>"
    )
    mged_add_xmin_gui_fixture(help "mged;dm-tkswrast;m35.g")
-    mged_add_xmin_gui_fixture(edit-interaction "mged;dm-tkswrast;m35.g")
    mged_add_xmin_gui_fixture(bot "mged;dm-tkswrast;m35.g")
    mged_add_xmin_gui_fixture(editors "mged;dm-tkswrast;m35.g")
    mged_add_xmin_gui_fixture(query-pattern "mged;dm-tkswrast;m35.g")
@@ -144,18 +143,6 @@ if(BRLCAD_X11_PROVIDER_RESOLVED STREQUAL "XMIN" AND
      )
      brlcad_regression_test(regress-archer-embedded-xmin-gui
        "archer;bwish" STAND_ALONE TEST_DEFINED)
-
-      brlcad_add_gui_test(
-        NAME regress-archer-geometry-xmin-gui
-        TIMEOUT 120
-        ENVIRONMENT ${_gui_smoke_environment}
-          "GUI_TEST_LIBRARY=${_gui_test_library}"
-        COMMAND "${SH_EXEC}" "${_gui_tcl_runner}" archer-geometry
-          $<TARGET_FILE:bwish>
-          "${CMAKE_CURRENT_SOURCE_DIR}/archer_geometry_xmin_gui.tcl"
-      )
-      brlcad_regression_test(regress-archer-geometry-xmin-gui
-        "archer;bwish" STAND_ALONE TEST_DEFINED)
    endif()
  endif()

@@ -213,7 +200,6 @@ cmakefiles(
  archer_action.sh
  archer_smoke.sh
  archer_embedded_xmin_gui.tcl
-  archer_geometry_xmin_gui.tcl
  archer_menu_manifest.txt
  archer_xmin_gui.tcl
  qged_action.sh
@@ -226,19 +212,18 @@ cmakefiles(
  mged/mged_xmin_gui.sh
  mged/xmin_gui_bot.tcl
  mged/xmin_gui_controls.tcl
-  mged/xmin_gui_edit.tcl
-  mged/xmin_gui_edit_interaction.tcl
  mged/xmin_gui_editors.tcl
  mged/xmin_gui_help.tcl
  mged/xmin_gui_lod.tcl
  mged/xmin_gui_overlaps.tcl
-  mged/xmin_gui_pipe_oracle.tcl
  mged/xmin_gui_query_pattern.tcl
  mged/xmin_gui_render_outputs.tcl
  mged/xmin_gui_search_exec.tcl
  mged/xmin_gui_shotvis.tcl
  mged/xmin_gui_test.tcl
  mged/xmin_gui_workflows.tcl
+  mged/xmin_gui_edit.tcl
+  mged/xmin_gui_pipe_oracle.tcl
 )

 # Local Variables:
@@ -1,134 +0,0 @@
-#    A R C H E R _ G E O M E T R Y _ X M I N _ G U I . T C L
-# BRL-CAD
-#
-# Copyright (c) 2026 United States Government as represented by
-# the U.S. Army Research Laboratory.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public License
-# version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this file; see the file named COPYING for more
-# information.
-#
-###
-if {![info exists ::env(GUI_TEST_LIBRARY)]} {
-    puts stderr "GUI_TEST_LIBRARY is required"
-    exit 2
-}
-source $::env(GUI_TEST_LIBRARY)
-set ::env(ARCHER_PREFS_FILE) [file join $::env(GUI_TEST_DIR) .archerrc]
-
-proc archer_geometry_preferences {{geometry ""}} {
-    set channel [open $::env(ARCHER_PREFS_FILE) w]
-    if {$geometry ne ""} {
-	puts $channel [list set mWindowGeometry $geometry]
-    }
-    close $channel
-}
-
-proc archer_geometry_saved {} {
-    set channel [open $::env(ARCHER_PREFS_FILE) r]
-    set contents [read $channel]
-    close $channel
-    if {[regexp -line {^set mWindowGeometry (.+)$} $contents -> geometry]} {
-	return $geometry
-    }
-    return ""
-}
-
-proc archer_geometry_settle {} {
-    # Allow MapNotify and the deferred geometry restore to reach the event loop.
-    set settle_delay_ms 100
-    after $settle_delay_ms [list set ::archer_geometry_settled 1]
-    vwait ::archer_geometry_settled
-    update
-    ::gui::test::require_no_background_errors
-}
-
-if {[catch {
-    package require Archer 1.0
-    ::gui::test::capture_background_errors
-    wm withdraw .
-
-    set saved_geometry 900x650+120+90
-    set startup_geometry 1000x700+20+30
-    set updated_geometry 950x680+60+70
-    set default_geometry 920x660+40+50
-
-    archer_geometry_preferences $saved_geometry
-    Archer .unmapped
-    ::gui::test::require {[wm state .unmapped] eq "withdrawn"} \
-	"startup fixture unexpectedly showed its window"
-    ::itcl::delete object .unmapped
-    archer_geometry_settle
-    ::gui::test::require {[archer_geometry_saved] eq $saved_geometry} \
-	"closing an unmapped Archer replaced its saved geometry"
-
-    archer_geometry_preferences
-    Archer .unmapped_new
-    ::itcl::delete object .unmapped_new
-    archer_geometry_settle
-    ::gui::test::require {[archer_geometry_saved] eq ""} \
-	"closing an unmapped Archer saved an unfinished layout size"
-
-    archer_geometry_preferences $saved_geometry
-    Archer .restore
-    .restore configure -geometry $startup_geometry
-    wm geometry .restore $startup_geometry
-    event generate [.restore component hpane] <Map>
-    archer_geometry_settle
-    ::gui::test::require {[wm geometry .restore] eq $startup_geometry} \
-	"a child Map event restored the main window's geometry prematurely"
-
-    wm deiconify .restore
-    archer_geometry_settle
-    ::gui::test::require {[wm geometry .restore] eq $saved_geometry} \
-	"mapping the main window did not restore its saved geometry"
-
-    wm geometry .restore $updated_geometry
-    event generate [.restore component hpane] <Map>
-    archer_geometry_settle
-    ::gui::test::require {[wm geometry .restore] eq $updated_geometry} \
-	"a later child Map event reset the resized main window"
-    wm withdraw .restore
-    ::itcl::delete object .restore
-    archer_geometry_settle
-    ::gui::test::require {[archer_geometry_saved] eq $updated_geometry} \
-	"closing a previously mapped window did not save its latest geometry"
-
-    archer_geometry_preferences
-    Archer .default
-    wm geometry .default $default_geometry
-    wm deiconify .default
-    archer_geometry_settle
-    ::gui::test::require {[wm geometry .default] eq $default_geometry} \
-	"an empty geometry option reset the window to its layout size"
-    wm withdraw .default
-    ::itcl::delete object .default
-    archer_geometry_settle
-} message options]} {
-    puts stderr $message
-    if {[dict exists $options -errorinfo]} {
-	puts stderr [dict get $options -errorinfo]
-    }
-    puts "FAIL: Archer window geometry regression"
-    exit 1
-}
-
-puts "PASS: Archer window geometry restoration and startup cancellation"
-exit 0
-
-# Local Variables:
-# tab-width: 8
-# mode: Tcl
-# tcl-indent-level: 4
-# indent-tabs-mode: t
-# End:
-# ex: shiftwidth=4 tabstop=8
@@ -50,18 +50,6 @@ proc ::mged::xmin::help::exercise_command_manual {top} {
    ::gui::test::require {
 	[llength $selection] == 1 && [$toc get $selection] eq "rt"
    } "man rt did not select and load the rt manual page"
-
-    event generate $toc <<ListboxSelect>>
-    ::mged::gui::test::settle
-
-    man search
-    set html_view [$browser component browser].htmlview
-    set html_widget [$html_view html]
-    $html_view goto {#hierarchy_performance}
-    ::mged::gui::test::settle
-    ::gui::test::require {[lindex [$html_widget yview] 0] > 0.0} \
-	"manual browser did not follow an in-page hyperlink"
-
    ::gui::test::require {
 	[catch {man xmin_page_that_does_not_exist} message] &&
 	[string first "couldn't find manual page" $message] >= 0
@@ -163,38 +151,10 @@ proc ::mged::xmin::help::exercise_html_manual {top} {
    set mged_browser [file join $::env(GUI_TEST_DIR) missing-browser]
    ::mged::gui::test::invoke $top {Help Manual}
    set fallback $top.man
-    set viewer $fallback.html
    ::gui::test::require {
 	[winfo exists $fallback] && [winfo ismapped $fallback] &&
-	[winfo exists $viewer] && [$viewer title] eq "Table of Contents"
+	[string length [string trim [$fallback.text get 1.0 end]]] > 100
    } "Manual did not load MGED's internal HTML viewer"
-
-    set special_path [file join [pwd] {manual path} {contents#1.html}]
-    ::gui::test::require {
-	[::mged::manual::local_path \
-	    [::mged::manual::file_uri $special_path]] eq \
-	[file normalize $special_path]
-    } "internal Manual viewer did not preserve special path characters"
-
-    set html [$viewer html]
-    set contents [$html text text]
-    ::gui::test::require {
-	[string first "Preface" $contents] >= 0 &&
-	[string first "background-color" $contents] < 0
-    } "internal Manual viewer did not render its table of contents"
-
-    $viewer goto mged.html#csg
-    ::mged::gui::test::settle
-    set contents [$html text text]
-    ::gui::test::require {
-	[$viewer title] eq "Mged User's Manual" &&
-	[string first "Modeling With CSG" $contents] >= 0
-    } "internal Manual viewer did not follow its document links"
-
-    $fallback.f.back invoke
-    ::mged::gui::test::settle
-    ::gui::test::require {[$viewer title] eq "Table of Contents"} \
-	"internal Manual viewer Back button did not restore the prior page"
    destroy $fallback
 }

@@ -53,41 +53,30 @@ endif(BRLCAD_ENABLE_TCL)
 # Archer plugins
 set(
  archer_utility_FILES
-  plugins/Utility/README
  plugins/Utility/attrGroupsDisplayUtilityP.tcl
-  plugins/Utility/attrGroupsDisplayUtilityP/AttrGroupsDisplayUtilityP.tcl
  plugins/Utility/botUtilityP.tcl
-  plugins/Utility/botUtilityP/BotUtilityP.tcl
  plugins/Utility/lodUtilityP.tcl
-  plugins/Utility/lodUtilityP/LODUtilityP.tcl
-)
-set(archer_wizard_FILES
-  plugins/Wizards/humanwizard.tcl
-  plugins/Wizards/humanwizard/HumanWizard.tcl
-  plugins/Wizards/tankwizard.tcl
-  plugins/Wizards/tankwizard/TankWizard.tcl
-  plugins/Wizards/tankwizard/images/tank.png
-  plugins/Wizards/tirewizard.tcl
-  plugins/Wizards/tirewizard/TireWizard.tcl
+  plugins/Utility/README
 )
+set(archer_wizard_FILES plugins/Wizards/humanwizard.tcl plugins/Wizards/tankwizard.tcl plugins/Wizards/tirewizard.tcl)

 if(BRLCAD_ENABLE_TCL)
-  # Archer scans only the plugin category directories for registration scripts.
-  # Keep class definitions in their subdirectories so they are not sourced twice.
-  foreach(plugin_file IN LISTS archer_utility_FILES archer_wizard_FILES)
-    get_filename_component(plugin_dir "${plugin_file}" DIRECTORY)
-    file(RELATIVE_PATH plugin_dir "${CMAKE_CURRENT_SOURCE_DIR}/plugins" "${CMAKE_CURRENT_SOURCE_DIR}/${plugin_dir}")
-    brlcad_adddata("${plugin_file}" "plugins/archer/${plugin_dir}")
-  endforeach()
+  brlcad_adddata(archer_utility_FILES plugins/archer/Utility)
+  brlcad_adddata(archer_wizard_FILES plugins/archer/Wizards)
  brlcad_adddata(plugins/Commands/README plugins/archer/Command)
  brlcad_adddata(plugins/Core/README plugins/archer/Core)
+  brlcad_adddata(plugins/Utility/attrGroupsDisplayUtilityP/AttrGroupsDisplayUtilityP.tcl plugins/archer/Utility/attrGroupsDisplayUtilityP)
+  brlcad_adddata(plugins/Utility/botUtilityP/BotUtilityP.tcl plugins/archer/Utility/botUtilityP)
+  brlcad_adddata(plugins/Utility/lodUtilityP/LODUtilityP.tcl plugins/archer/Utility/lodUtilityP)
+  brlcad_adddata(plugins/Wizards/humanwizard/HumanWizard.tcl plugins/archer/Wizards/humanwizard)
+  brlcad_adddata(plugins/Wizards/tankwizard/TankWizard.tcl plugins/archer/Wizards/tankwizard)
+  brlcad_adddata(plugins/Wizards/tankwizard/images/tank.png plugins/archer/Wizards/tankwizardIA/images)
+  brlcad_adddata(plugins/Wizards/tirewizard/TireWizard.tcl plugins/archer/Wizards/tirewizard)
 endif(BRLCAD_ENABLE_TCL)

 set(
  archer_ignore_files
  CMakeLists.txt
-  plugins/Commands/README
-  plugins/Core/README
  ${archer_utility_FILES}
  ${archer_wizard_FILES}
  ${archer_txt}
@@ -752,7 +752,7 @@ tessellate_part(struct creo_conv_info *cinfo, ProMdl model, struct bu_vls **snam
            }

        /* Check solidity */
-        success = !bg_trimesh_solid((int)vert_tree->curr_vert, (size_t)faces.size() / 3,
+        success = bg_trimesh_solid((int)vert_tree->curr_vert, (size_t)faces.size() / 3,
                                        vert_tree->the_array, &faces[0], NULL);

        /* If it's not solid and we're testing solidity, keep trying... */
@@ -23,20 +23,10 @@
 #include "InformationGatherer.h"
 #include "bu/log.h"

-// flush results, if we have any, then exit
-static void reportAndExit(const std::string &message, const std::string &result = "")
-{
-    if (!result.empty())
-	bu_log("%s%s", result.c_str(), result.back() == '\n' ? "" : "\n");
-
-    bu_exit(BRLCAD_ERROR, "%s", message.c_str());
-}
-
-
 std::string getCmdPath(std::string exeDir, const char* cmd) {
    char buf[MAXPATHLEN] = {0};
    if (!bu_dir(buf, MAXPATHLEN, exeDir.c_str(), cmd, BU_DIR_EXT, NULL))
-	reportAndExit("Couldn't find " + std::string(cmd) + ", aborting.\n");
+        bu_exit(BRLCAD_ERROR, "Couldn't find %s, aborting.\n", cmd);

    return std::string(buf);
 }
@@ -68,13 +58,13 @@ getSurfaceArea(Options* opt, std::map<std::string, std::string> UNUSED(map), std
    bu_process_create(&p, rtarea_av, BU_PROCESS_HIDE_WINDOW | BU_PROCESS_OUT_EQ_ERR);

    if (bu_process_pid(p) <= 0) {
-	reportAndExit("Problem with getSurfaceArea, aborting\n");
+        bu_exit(BRLCAD_ERROR, "Problem with getSurfaceArea, aborting\n");
    }

    char buffer[128];
-    std::string result;
+    std::string result = "";
    int read_cnt = 0;
-    while ((read_cnt = bu_process_read_n(p, BU_PROCESS_STDOUT, sizeof(buffer) - 1, buffer)) > 0) {
+    while ((read_cnt = bu_process_read_n(p, BU_PROCESS_STDOUT, 128-1, buffer)) > 0) {
        /* NOTE: read does not ensure null-termination, thus buffersize-1 */
        buffer[read_cnt] = '\0';
        result += buffer;
@@ -90,7 +80,7 @@ getSurfaceArea(Options* opt, std::map<std::string, std::string> UNUSED(map), std
        try {
            surfArea += stod(result);
        } catch (const std::invalid_argument& ia) {
-	    reportAndExit("Invalid argument for getSurfaceArea. Got (" + std::string(ia.what()) + "), aborting.\n", result);
+            bu_exit(BRLCAD_ERROR, "Invalid argument for getSurfaceArea. Got (%s), aborting.\n", ia.what());
        }
    }
 }
@@ -210,7 +200,7 @@ getVerificationData(struct ged* UNUSED(g), Options* opt, std::map<std::string, s
    struct bu_process* p;
    int read_cnt = 0;
    char buffer[1024] = {0};
-    std::string result;
+    std::string result = "";
    std::string ncpu(std::to_string(opt->getNCPU()));
    std::string dFile(opt->getDensityFile());

@@ -243,23 +233,21 @@ getVerificationData(struct ged* UNUSED(g), Options* opt, std::map<std::string, s
    bu_process_create(&p, const_cast<const char**>(gqa_av_vec.data()), BU_PROCESS_HIDE_WINDOW | BU_PROCESS_OUT_EQ_ERR);

    if (bu_process_pid(p) <= 0) {
-	reportAndExit("Problem in getVerificationData gqa process creation, aborting\n");
+        bu_exit(BRLCAD_ERROR, "Problem in getVerificationData gqa process creation, aborting\n");
    }

-    while ((read_cnt = bu_process_read_n(p, BU_PROCESS_STDOUT, sizeof(buffer) - 1, buffer)) > 0) {
+    result = "";
+    while ((read_cnt = bu_process_read_n(p, BU_PROCESS_STDOUT, 1024-1, buffer)) > 0) {
        buffer[read_cnt] = '\0';
        result += buffer;
    }

-    const int gqa_status = bu_process_wait_n(&p, 0);
-
-    // sanity - we should have clean status code and not the "no density found" message
-    const bool no_density_data = result.find(no_density_msg) != std::string::npos;
-    if (gqa_status != 0 && (!no_density_data || !dFile.empty())) {
-	reportAndExit("Problem collecting gqa volume and mass, aborting\n", result);
+    if (bu_process_wait_n(&p, 0) != 0) {
+        bu_exit(BRLCAD_ERROR, "Problem collecting gqa volume and mass, aborting\n");
    }

-    if (!no_density_data) {
+    // make sure we did not get 'no density file' error message
+    if (result.find(no_density_msg) == std::string::npos) {
        // NOTE: tmp_val is zeroed at each parseLabeledNumber call
        if (parseLabeledNumber(tmp_val, result, volume_label))
            volume += tmp_val;
@@ -275,17 +263,17 @@ getVerificationData(struct ged* UNUSED(g), Options* opt, std::map<std::string, s
    bu_process_create(&p, const_cast<const char**>(gqa_av_vec.data()), BU_PROCESS_HIDE_WINDOW | BU_PROCESS_OUT_EQ_ERR);

    if (bu_process_pid(p) <= 0) {
-	reportAndExit("Problem in getVerificationData gqa process creation, aborting\n");
+        bu_exit(BRLCAD_ERROR, "Problem in getVerificationData gqa process creation, aborting\n");
    }

-    result.clear();
-    while ((read_cnt = bu_process_read_n(p, BU_PROCESS_STDOUT, sizeof(buffer) - 1, buffer)) > 0) {
+    result = "";
+    while ((read_cnt = bu_process_read_n(p, BU_PROCESS_STDOUT, 1024-1, buffer)) > 0) {
        buffer[read_cnt] = '\0';
        result += buffer;
    }

    if (bu_process_wait_n(&p, 0) != 0) {
-	reportAndExit("Problem collecting gqa volume, aborting\n", result);
+        bu_exit(BRLCAD_ERROR, "Problem collecting gqa volume, aborting\n");
    }

    if (parseLabeledNumber(tmp_val, result, volume_label))
@@ -393,7 +381,7 @@ InformationGatherer::getMainComp()
        ged_exec_exists(g, 2, cmd);
        std::string res = bu_vls_addr(g->ged_result_str);
        if (res != "1") {
-	    reportAndExit("Could not find component (" + topcomp + "), aborting.\n");
+            bu_exit(BRLCAD_ERROR, "Could not find component (%s), aborting.\n", topname);
        }

        int entities = getNumEntities(opt->getTopComp());
@@ -34,9 +34,6 @@

 // OpenCV header files
 #include <opencv2/opencv.hpp>
-#if CV_VERSION_MAJOR >= 5
-#include <opencv2/geometry.hpp>
-#endif
 #include <opencv2/core/core.hpp>
 #include "opencv2/highgui/highgui.hpp"

@@ -43,7 +43,6 @@ main(int argc, char *argv[])
    int i, j;
    int db_index;
    int c;
-    int ret;
    const char **av;
    struct ged *gedp;

@@ -104,14 +103,14 @@ main(int argc, char *argv[])
 	bu_exit(1, usage, argv[0]);
    }

-    ret = ged_exec_gqa(gedp, j, av);
+    (void)ged_exec_gqa(gedp, j, av);
    if (bu_vls_strlen(gedp->ged_result_str) > 0)
 	bu_log("%s", bu_vls_addr(gedp->ged_result_str));
    ged_close(gedp);

    bu_free((void *)av, "av");

-    return ret;
+    return 0;
 }


@@ -24,7 +24,6 @@

 #include "common.h"

-#include <algorithm>
 #include <climits>
 #include <cmath>
 #include <cstdio>
@@ -113,10 +113,10 @@ bg_lseg_clip(fastf_t *xp1, fastf_t *yp1, fastf_t *xp2, fastf_t *yp2, fastf_t cli
 int
 bg_ray_vclip(point_t a, point_t b, const fastf_t *min_pt, const fastf_t *max_pt)
 {
-    vect_t diff;
-    double sv;
-    double st;
-    double mindist, maxdist;
+    static vect_t diff;
+    static double sv;
+    static double st;
+    static double mindist, maxdist;
    fastf_t *pt = &a[0];
    fastf_t *dir = &diff[0];
    int i;
@@ -22,7 +22,7 @@
 /** @file libbg/pca.cpp
 *
 * @brief
- * Principal Component Analysis.
+ * Principle Component Analysis.
 *
 */

@@ -74,7 +74,7 @@ bg_pca(point_t *c, vect_t *xa, vect_t *ya, vect_t *za, size_t npnts, const point
    }

    // 3.  Perform SVD
-    Eigen::JacobiSVD<Eigen::MatrixXd> svd(A, Eigen::ComputeFullU);
+    Eigen::JacobiSVD<Eigen::MatrixXd> svd(A, Eigen::ComputeThinU);

    // 4.  Extract the vectors from the U matrix
    vect_t xaxis, yaxis, zaxis;
@@ -2620,50 +2620,20 @@ bg_lseg3_lseg3_parallel(const point_t sg1pt1, const point_t sg1pt2,
 }

 extern "C" int
-bg_plane_pt_nrml(plane_t *p, const point_t pt, const vect_t nrml)
+bg_plane_pt_nrml(plane_t *p, point_t pt, vect_t nrml)
 {
-    vect_t normal;
-    fastf_t normal_length;
-
-    if (!p || !pt || !nrml)
+    if (!p)
 	return -1;
-
-    VMOVE(normal, nrml);
-    normal_length = MAGNITUDE(normal);
-    if (normal_length <= SMALL_FASTF)
-	return -1;
-
-    VSCALE(normal, normal, 1.0 / normal_length);
-    (*p)[X] = normal[X];
-    (*p)[Y] = normal[Y];
-    (*p)[Z] = normal[Z];
-    (*p)[H] = VDOT(normal, pt);
-
+    vect_t unrml;
+    VMOVE(unrml, nrml);
+    VUNITIZE(nrml);
+    (*p)[0] = unrml[0];
+    (*p)[1] = unrml[1];
+    (*p)[2] = unrml[2];
+    (*p)[3] = unrml[0]*pt[0] + unrml[1]*pt[1] + unrml[2]*pt[2];
    return 0;
 }

-static int
-plane_coordinate_frame(point_t origin, vect_t xaxis, vect_t yaxis, const plane_t *p)
-{
-    vect_t normal;
-    fastf_t normal_length;
-
-    VSET(normal, (*p)[X], (*p)[Y], (*p)[Z]);
-    normal_length = MAGNITUDE(normal);
-    if (normal_length <= SMALL_FASTF)
-	return -1;
-
-    VSCALE(normal, normal, 1.0 / normal_length);
-    VSCALE(origin, normal, (*p)[H] / normal_length);
-    bn_vec_perp(xaxis, normal);
-    VUNITIZE(xaxis);
-    VCROSS(yaxis, normal, xaxis);
-    VUNITIZE(yaxis);
-
-    return 0;
-}
-
-
 // Use PCA fit a plane to vertex points
 extern "C" int
 bg_fit_plane(point_t *c, vect_t *n, size_t npnts, point_t *pnts)
@@ -2694,11 +2664,40 @@ bg_plane_closest_pt(fastf_t *u, fastf_t *v, plane_t *p, point_t *pt)
 	return -1;

    point_t origin;
-    vect_t xaxis, yaxis;
+    vect_t xaxis, yaxis, zaxis;
+    VSET(zaxis, (*p)[0], (*p)[1], (*p)[2]);
+    fastf_t x, y, z, d;
+    x = fabs((*p)[0]);
+    y = fabs((*p)[1]);
+    z = fabs((*p)[2]);
+    d = 0.0;
+    if ( y >= x && y >= z ) {
+	d = x;
+	x = y;
+	y = d;
+    } else if ( z >= x && z >= y ) {
+	d = x;
+	x = z;
+	z = d;
+    }
+    if ( x > SMALL_FASTF ) {
+	y /= x;
+	z /= x;
+	d = x*sqrt(1.0 + y*y + z*z);
+    } else if ( x > 0.0 && x < MAX_FASTF ) {
+	d = x;
+    }

-    if (plane_coordinate_frame(origin, xaxis, yaxis, p))
+    if (d < 0 || NEAR_ZERO(d, SMALL_FASTF))
 	return -1;

+    VMOVE(origin, zaxis);
+    VSCALE(origin, origin, 1/d*(*p)[3]);
+    VUNITIZE(zaxis);
+    bn_vec_perp(xaxis, zaxis);
+    VUNITIZE(xaxis);
+    VCROSS(yaxis, zaxis, xaxis);
+    VUNITIZE(yaxis);
    vect_t vc;
    VSUB2(vc, *pt, origin);

@@ -2712,15 +2711,45 @@ bg_plane_closest_pt(fastf_t *u, fastf_t *v, plane_t *p, point_t *pt)
 extern "C" int
 bg_plane_pt_at(point_t *pt, plane_t *p, fastf_t u, fastf_t v)
 {
-    if (!pt || !p)
+    if (!pt)
 	return -1;

    point_t origin;
-    vect_t xaxis, yaxis;
+    vect_t xaxis, yaxis, zaxis;
+    VSET(zaxis, (*p)[0], (*p)[1], (*p)[2]);
+    fastf_t x, y, z, d;
+    x = fabs((*p)[0]);
+    y = fabs((*p)[1]);
+    z = fabs((*p)[2]);
+    d = 0.0;
+    if ( y >= x && y >= z ) {
+	d = x;
+	x = y;
+	y = d;
+    } else if ( z >= x && z >= y ) {
+	d = x;
+	x = z;
+	z = d;
+    }
+    if ( x > SMALL_FASTF ) {
+	y /= x;
+	z /= x;
+	d = x*sqrt(1.0 + y*y + z*z);
+    } else if ( x > 0.0 && x < MAX_FASTF ) {
+	d = x;
+    }

-    if (plane_coordinate_frame(origin, xaxis, yaxis, p))
+    if (d < 0 || NEAR_ZERO(d, SMALL_FASTF))
 	return -1;

+    VMOVE(origin, zaxis);
+    VSCALE(origin, origin, 1/d*(*p)[3]);
+    VUNITIZE(zaxis);
+    bn_vec_perp(xaxis, zaxis);
+    VUNITIZE(xaxis);
+    VCROSS(yaxis, zaxis, xaxis);
+    VUNITIZE(yaxis);
+
    VSCALE(xaxis, xaxis, u);
    VSCALE(yaxis, yaxis, v);
    VADD2(origin, origin, xaxis);
@@ -83,7 +83,7 @@ bg_polygon_view_bbox(point2d_t *bmin, point2d_t *bmax, struct bg_polygon *p, mat
    // contours.  ONLY considering positive contour points.
    for (size_t i = 0; i < p->num_contours; i++) {
 	struct bg_poly_contour *c = &p->contour[i];
-	if ((p->hole && p->hole[i]) || !c->num_points)
+	if (!c->num_points)
 	    continue;
 	for (size_t j = 0; j < c->num_points; j++) {
 	    point_t vpoint;
@@ -143,45 +143,64 @@ bg_3d_polygon_area(fastf_t *area, size_t npts, const point_t *pts)
 int
 bg_3d_polygon_centroid(point_t *cent, size_t npts, const point_t *pts)
 {
-    point_t centroid = VINIT_ZERO;
-    vect_t normal = VINIT_ZERO;
-    vect_t edge0, edge1, cross;
-    fastf_t signed_area = 0.0;
+    size_t i;
+    fastf_t x_0 = 0.0;
+    fastf_t x_1 = 0.0;
+    fastf_t y_0 = 0.0;
+    fastf_t y_1 = 0.0;
+    fastf_t z_0 = 0.0;
+    fastf_t z_1 = 0.0;
+    fastf_t a = 0.0;
+    fastf_t signedArea = 0.0;

    if (!pts || !cent || npts < 3)
 	return 1;
-
-    for (size_t i = 1; i + 1 < npts; i++) {
-	VSUB2(edge0, pts[i], pts[0]);
-	VSUB2(edge1, pts[i + 1], pts[0]);
-	VCROSS(cross, edge0, edge1);
-	VADD2(normal, normal, cross);
+    /* Calculate Centroid projection for face for x-y-plane */
+    for (i = 0; i < npts-1; i++) {
+	x_0 = pts[i][0];
+	y_0 = pts[i][1];
+	x_1 = pts[i+1][0];
+	y_1 = pts[i+1][1];
+	a = x_0 *y_1 - x_1*y_0;
+	signedArea += a;
+	*cent[0] += (x_0 + x_1)*a;
+	*cent[1] += (y_0 + y_1)*a;
    }
-    if (MAGNITUDE(normal) <= SMALL_FASTF)
-	return 1;
-    VUNITIZE(normal);
+    x_0 = pts[i][0];
+    y_0 = pts[i][1];
+    x_1 = pts[0][0];
+    y_1 = pts[0][1];
+    a = x_0 *y_1 - x_1*y_0;
+    signedArea += a;
+    *cent[0] += (x_0 + x_1)*a;
+    *cent[1] += (y_0 + y_1)*a;

-    for (size_t i = 1; i + 1 < npts; i++) {
-	point_t triangle_centroid;
-	fastf_t triangle_area;
+    signedArea *= 0.5;
+    *cent[0] /= (6.0*signedArea);
+    *cent[1] /= (6.0*signedArea);

-	VSUB2(edge0, pts[i], pts[0]);
-	VSUB2(edge1, pts[i + 1], pts[0]);
-	VCROSS(cross, edge0, edge1);
-	triangle_area = VDOT(cross, normal);
-	signed_area += triangle_area;
-	VADD2(triangle_centroid, pts[0], pts[i]);
-	VADD2(triangle_centroid, triangle_centroid, pts[i + 1]);
-	VSCALE(triangle_centroid, triangle_centroid, triangle_area / 3.0);
-	VADD2(centroid, centroid, triangle_centroid);
+    /* calculate Centroid projection for face for x-z-plane */
+
+    signedArea = 0.0;
+    for (i = 0; i < npts-1; i++) {
+	x_0 = pts[i][0];
+	z_0 = pts[i][2];
+	x_1 = pts[i+1][0];
+	z_1 = pts[i+1][2];
+	a = x_0 *z_1 - x_1*z_0;
+	signedArea += a;
+	*cent[2] += (z_0 + z_1)*a;
    }
+    x_0 = pts[i][0];
+    z_0 = pts[i][2];
+    x_1 = pts[0][0];
+    z_1 = pts[0][2];
+    a = x_0 *z_1 - x_1*z_0;
+    signedArea += a;
+    *cent[2] += (z_0 + z_1)*a;

-    if (NEAR_ZERO(signed_area, SMALL_FASTF))
-	return 1;
-
-    VSCALE(centroid, centroid, 1.0 / signed_area);
-    VMOVE(*cent, centroid);
-
+    signedArea *= 0.5;
+    *cent[2] /= (6.0*signedArea);
    return 0;
 }

@@ -244,7 +263,6 @@ bg_3d_polygon_make_pnts_planes(size_t *npts, point_t **pts, size_t neqs, const p


 struct sort_ccw_data {
-    point_t centroid;
    vect_t x_axis;
    vect_t y_axis;
 };
@@ -254,26 +272,20 @@ static int
 sort_ccw_3d(const void *left, const void *right, void *context)
 {
    const struct sort_ccw_data *data = (const struct sort_ccw_data *)context;
-    const point_t *left_point = (const point_t *)left;
-    const point_t *right_point = (const point_t *)right;
-    vect_t left_offset, right_offset;
-    double left_angle, right_angle;
-    double left_radius, right_radius;
-
-    VSUB2(left_offset, *left_point, data->centroid);
-    VSUB2(right_offset, *right_point, data->centroid);
-    left_angle = atan2(VDOT(left_offset, data->y_axis),
-	    VDOT(left_offset, data->x_axis));
-    right_angle = atan2(VDOT(right_offset, data->y_axis),
-	    VDOT(right_offset, data->x_axis));
+    const fastf_t *left_point = (const fastf_t *)left;
+    const fastf_t *right_point = (const fastf_t *)right;
+    double left_angle = atan2(VDOT(left_point, data->y_axis),
+	    VDOT(left_point, data->x_axis));
+    double right_angle = atan2(VDOT(right_point, data->y_axis),
+	    VDOT(right_point, data->x_axis));

    if (left_angle < right_angle)
 	return -1;
    if (left_angle > right_angle)
 	return 1;

-    left_radius = MAGSQ(left_offset);
-    right_radius = MAGSQ(right_offset);
+    double left_radius = MAGSQ(left_point);
+    double right_radius = MAGSQ(right_point);
    if (left_radius < right_radius)
 	return -1;
    if (left_radius > right_radius)
@@ -286,10 +298,11 @@ int
 bg_3d_polygon_sort_ccw(size_t npts, point_t *pts, plane_t cmp)
 {
    size_t i;
+    point_t centroid;
    vect_t normal;
    struct sort_ccw_data data;

-    if (!pts || !cmp || npts < 3)
+    if (!pts || npts < 3)
 	return 1;
    if (MAGNITUDE(cmp) < VDIVIDE_TOL)
 	return 1;
@@ -299,13 +312,21 @@ bg_3d_polygon_sort_ccw(size_t npts, point_t *pts, plane_t cmp)
    bn_vec_ortho(data.x_axis, normal);
    VCROSS(data.y_axis, normal, data.x_axis);

-    VSETALL(data.centroid, 0.0);
+    /* Angular ordering is about the polygon center, not the model origin.
+     * Translate temporarily so the comparator only needs the plane axes. */
+    VSETALL(centroid, 0.0);
    for (i = 0; i < npts; i++)
-	VADD2(data.centroid, data.centroid, pts[i]);
-    VSCALE(data.centroid, data.centroid, 1.0 / (fastf_t)npts);
+	VADD2(centroid, centroid, pts[i]);
+    VSCALE(centroid, centroid, 1.0 / (double)npts);
+
+    for (i = 0; i < npts; i++)
+	VSUB2(pts[i], pts[i], centroid);

    bu_sort(pts, npts, sizeof(point_t), sort_ccw_3d, &data);

+    for (i = 0; i < npts; i++)
+	VADD2(pts[i], pts[i], centroid);
+
    return 0;
 }

@@ -146,7 +146,7 @@ brlcad_add_test(NAME bg_plane_mk_plane_3pts_succeed          COMMAND bg_test pla
 #
 #  A-D are plane equation parameters, and P is the test point.
 brlcad_add_test(NAME bg_plane_pt_project_1  COMMAND bg_test plane_pt 6  0,0,1,1 2,2,1)
-brlcad_add_test(NAME bg_plane_pt_project_2  COMMAND bg_test plane_pt 6  0.737397,0.461098,0.493593,236.3 77.526016919831704,185.674010580054585,189.465070961146)
+brlcad_add_test(NAME bg_plane_pt_project_2  COMMAND bg_test plane_pt 6  0.737397,0.461098,0.493593,236.3 77.526016919831704,185.674010580054585,189.465011325663767)

 # For function #7 (bg_coplanar_pts), the <args> format is as follows:
 #
@@ -310,24 +310,7 @@ brlcad_addexec(bg_line_distance line_distance.c "${BG_TEST_LIBS}" TEST)

 brlcad_add_test(NAME bg_line_distance COMMAND bg_line_distance)

-#  ************ plane coordinate tests ***********
-
-brlcad_addexec(bg_plane_coordinates plane_coordinates.c "${BG_TEST_LIBS}" TEST)
-
-brlcad_add_test(NAME bg_plane_coordinates COMMAND bg_plane_coordinates)
-
-#  ************ pca.c tests ***********
-
-brlcad_addexec(bg_pca pca.c "${BG_TEST_LIBS}" TEST)
-
-brlcad_add_test(NAME bg_pca COMMAND bg_pca)
-
 #  ************ polygon.c tests ***********
-
-brlcad_addexec(bg_polygon polygon.c "${BG_TEST_LIBS}" TEST)
-
-brlcad_add_test(NAME bg_polygon COMMAND bg_polygon)
-
 brlcad_addexec(bg_polygon_triangulate polygon_triangulate.c "${BG_TEST_LIBS}" TEST)

 brlcad_add_test(NAME bg_polygon_triangulate	    COMMAND bg_polygon_triangulate)
@@ -469,10 +452,6 @@ brlcad_addexec(bg_trimesh_area trimesh_area.c "${BG_TEST_LIBS}" TEST)

 #BRLCAD_ADD_TEST(NAME bg_trimesh_area  COMMAND bg_trimesh_area)

-brlcad_addexec(bg_trimesh_solid trimesh_solid.c "${BG_TEST_LIBS}" TEST)
-
-brlcad_add_test(NAME bg_trimesh_solid COMMAND bg_trimesh_solid)
-
 #  ************ trimesh_repair tests ***********

 brlcad_addexec(bg_trimesh_repair trimesh_repair.cpp "${BG_TEST_LIBS}" TEST)
@@ -1,70 +0,0 @@
-/*                           P C A . C
- * BRL-CAD
- *
- * Copyright (c) 2026 United States Government as represented by
- * the U.S. Army Research Laboratory.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * version 2.1 as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- */
-
-#include "common.h"
-
-#include "bn.h"
-#include "bu.h"
-#include "bg.h"
-
-
-static int
-orthonormal_axes(const vect_t xaxis, const vect_t yaxis, const vect_t zaxis)
-{
-    return !NEAR_EQUAL(MAGSQ(xaxis), 1.0, BN_TOL_DIST)
-	|| !NEAR_EQUAL(MAGSQ(yaxis), 1.0, BN_TOL_DIST)
-	|| !NEAR_EQUAL(MAGSQ(zaxis), 1.0, BN_TOL_DIST)
-	|| !NEAR_ZERO(VDOT(xaxis, yaxis), BN_TOL_DIST)
-	|| !NEAR_ZERO(VDOT(xaxis, zaxis), BN_TOL_DIST)
-	|| !NEAR_ZERO(VDOT(yaxis, zaxis), BN_TOL_DIST);
-}
-
-
-int
-main(int argc, char **argv)
-{
-    const point_t one_point[] = {{1.0, 2.0, 3.0}};
-    const point_t two_points[] = {{1.0, 2.0, 3.0}, {5.0, 2.0, 3.0}};
-    const point_t one_center = {1.0, 2.0, 3.0};
-    const point_t two_center = {3.0, 2.0, 3.0};
-    const vect_t xaxis_expected = {1.0, 0.0, 0.0};
-    point_t center;
-    vect_t xaxis, yaxis, zaxis;
-    fastf_t alignment;
-    int failed = 0;
-
-    bu_setprogname(argv[0]);
-    if (argc != 1)
-	return 1;
-
-    if (bg_pca(&center, &xaxis, &yaxis, &zaxis, 1, one_point) != BRLCAD_OK ||
-	!VNEAR_EQUAL(center, one_center, BN_TOL_DIST) ||
-	orthonormal_axes(xaxis, yaxis, zaxis)) {
-	failed = 1;
-    }
-
-    if (bg_pca(&center, &xaxis, &yaxis, &zaxis, 2, two_points) != BRLCAD_OK ||
-	!VNEAR_EQUAL(center, two_center, BN_TOL_DIST) ||
-	orthonormal_axes(xaxis, yaxis, zaxis)) {
-	failed = 1;
-    }
-
-    alignment = VDOT(xaxis, xaxis_expected);
-    if (!NEAR_EQUAL(alignment * alignment, 1.0, BN_TOL_DIST))
-	failed = 1;
-
-    return failed;
-}
@@ -1,69 +0,0 @@
-/*              P L A N E _ C O O R D I N A T E S . C
- * BRL-CAD
- *
- * Copyright (c) 2026 United States Government as represented by
- * the U.S. Army Research Laboratory.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * version 2.1 as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- */
-
-#include "common.h"
-
-#include "bn.h"
-#include "bu.h"
-#include "bg.h"
-
-
-int
-main(int argc, char **argv)
-{
-    const point_t plane_point = {0.0, 0.0, 3.0};
-    const vect_t original_normal = {0.0, 0.0, 2.0};
-    const vect_t expected_normal = {0.0, 0.0, 1.0};
-    vect_t normal;
-    vect_t zero_normal = VINIT_ZERO;
-    plane_t plane;
-    plane_t unnormalized_plane = {0.0, 0.0, 2.0, 6.0};
-    point_t query = {2.0, 2.0, 3.0};
-    point_t off_plane_query = {2.0, 2.0, 5.0};
-    const point_t expected_projection = {2.0, 2.0, 3.0};
-    point_t reconstructed = VINIT_ZERO;
-    fastf_t u, v;
-    int failed = 0;
-
-    bu_setprogname(argv[0]);
-    if (argc != 1)
-	return 1;
-
-    VMOVE(normal, original_normal);
-    if (bg_plane_pt_nrml(&plane, plane_point, normal) ||
-	!VNEAR_EQUAL(plane, expected_normal, BN_TOL_DIST) ||
-	!NEAR_EQUAL(plane[H], 3.0, BN_TOL_DIST) ||
-	!VNEAR_EQUAL(normal, original_normal, BN_TOL_DIST)) {
-	failed = 1;
-    }
-
-    if (bg_plane_pt_nrml(&plane, plane_point, zero_normal) != -1)
-	failed = 1;
-
-    if (bg_plane_closest_pt(&u, &v, &unnormalized_plane, &query) ||
-	bg_plane_pt_at(&reconstructed, &unnormalized_plane, u, v) ||
-	!VNEAR_EQUAL(reconstructed, query, BN_TOL_DIST)) {
-	failed = 1;
-    }
-
-    if (bg_plane_closest_pt(&u, &v, &unnormalized_plane, &off_plane_query) ||
-	bg_plane_pt_at(&reconstructed, &unnormalized_plane, u, v) ||
-	!VNEAR_EQUAL(reconstructed, expected_projection, BN_TOL_DIST)) {
-	failed = 1;
-    }
-
-    return failed;
-}
@@ -1,123 +0,0 @@
-/*                       P O L Y G O N . C
- * BRL-CAD
- *
- * Copyright (c) 2026 United States Government as represented by
- * the U.S. Army Research Laboratory.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * version 2.1 as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- */
-
-#include "common.h"
-
-#include "bn.h"
-#include "bu.h"
-#include "bg.h"
-
-
-static int
-test_view_bbox(void)
-{
-    point_t outer[] = {
-	{0.0, 0.0, 0.0},
-	{2.0, 0.0, 0.0},
-	{2.0, 2.0, 0.0},
-	{0.0, 2.0, 0.0}
-    };
-    point_t hole[] = {
-	{100.0, 100.0, 0.0},
-	{101.0, 100.0, 0.0},
-	{101.0, 101.0, 0.0},
-	{100.0, 101.0, 0.0}
-    };
-    struct bg_poly_contour contours[] = {
-	{4, outer, 0},
-	{4, hole, 0}
-    };
-    int holes[] = {0, 1};
-    struct bg_polygon polygon = BG_POLYGON_NULL;
-    mat_t model2view;
-    point2d_t bmin, bmax;
-
-    polygon.num_contours = 2;
-    polygon.hole = holes;
-    polygon.contour = contours;
-    MAT_IDN(model2view);
-    bg_polygon_view_bbox(&bmin, &bmax, &polygon, model2view);
-
-    return !NEAR_EQUAL(bmin[X], 0.0, BN_TOL_DIST)
-	|| !NEAR_EQUAL(bmin[Y], 0.0, BN_TOL_DIST)
-	|| !NEAR_EQUAL(bmax[X], 2.0, BN_TOL_DIST)
-	|| !NEAR_EQUAL(bmax[Y], 2.0, BN_TOL_DIST);
-}
-
-
-static int
-test_centroid(void)
-{
-    const point_t rectangle[] = {
-	{5.0, 0.0, 0.0},
-	{5.0, 4.0, 0.0},
-	{5.0, 4.0, 2.0},
-	{5.0, 0.0, 2.0}
-    };
-    const point_t expected = {5.0, 2.0, 1.0};
-    point_t output[] = {
-	{11.0, 12.0, 13.0},
-	{0.0, 0.0, 0.0},
-	{17.0, 18.0, 19.0},
-	{23.0, 24.0, 25.0}
-    };
-    const point_t before = {11.0, 12.0, 13.0};
-    const point_t after = {17.0, 18.0, 19.0};
-    const point_t farther_after = {23.0, 24.0, 25.0};
-
-    return bg_3d_polygon_centroid(&output[1], 4, rectangle)
-	|| !VNEAR_EQUAL(output[1], expected, BN_TOL_DIST)
-	|| !VNEAR_EQUAL(output[0], before, BN_TOL_DIST)
-	|| !VNEAR_EQUAL(output[2], after, BN_TOL_DIST)
-	|| !VNEAR_EQUAL(output[3], farther_after, BN_TOL_DIST);
-}
-
-
-static int
-test_ccw_sort(void)
-{
-    point_t points[] = {
-	{10.0, 10.0, 0.0},
-	{10.1, 10.1, 0.0},
-	{10.1, 10.0, 0.0},
-	{10.0, 10.1, 0.0}
-    };
-    plane_t plane = {0.0, 0.0, 1.0, 0.0};
-    vect_t total = VINIT_ZERO;
-    vect_t cross;
-
-    if (bg_3d_polygon_sort_ccw(4, points, plane))
-	return 1;
-
-    for (size_t i = 0; i < 4; i++) {
-	size_t next = i + 1 == 4 ? 0 : i + 1;
-	VCROSS(cross, points[i], points[next]);
-	VADD2(total, total, cross);
-    }
-
-    return total[Z] <= SMALL_FASTF;
-}
-
-
-int
-main(int argc, char **argv)
-{
-    bu_setprogname(argv[0]);
-    if (argc != 1)
-	return 1;
-
-    return test_view_bbox() || test_centroid() || test_ccw_sort();
-}
@@ -24,7 +24,6 @@
 #include <vector>

 #include "vmath.h"
-#include "bu/app.h"
 #include "bu/log.h"
 #include "bu/malloc.h"
 #include "bg/spsr.h"
@@ -88,10 +87,8 @@ accept_candidate(struct bg_3d_spsr_refinement_response *response,
 }

 int
-main(int UNUSED(argc), const char **argv)
+main(void)
 {
-    bu_setprogname(argv[0]);
-
    std::vector<struct bg_3d_spsr_sample> samples = sphere_samples(256);
    struct bg_3d_spsr_adaptive_opts options =
        BG_3D_SPSR_ADAPTIVE_OPTS_DEFAULT;
@@ -1,106 +0,0 @@
-/*                 T R I M E S H _ S O L I D . C
- * BRL-CAD
- *
- * Copyright (c) 2026 United States Government as represented by
- * the U.S. Army Research Laboratory.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * version 2.1 as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- */
-
-#include "common.h"
-
-#include "bu.h"
-#include "bg.h"
-
-
-static int
-test_solid_diagnostics(void)
-{
-    fastf_t vertices[][3] = {
-	{0.0, 0.0, 0.0},
-	{1.0, 0.0, 0.0},
-	{0.0, 1.0, 0.0},
-	{0.0, 0.0, 1.0},
-	{1.0, 1.0, 1.0}
-    };
-    int solid_faces[] = {
-	0, 2, 1,
-	0, 1, 3,
-	0, 3, 2,
-	1, 2, 3
-    };
-    int reversed_faces[] = {
-	0, 1, 2,
-	0, 1, 3,
-	0, 3, 2,
-	1, 2, 3
-    };
-    int mixed_error_faces[] = {
-	0, 1, 2,
-	0, 1, 3,
-	0, 3, 4,
-	1, 2, 3
-    };
-    int *bad_edges = NULL;
-    struct bg_trimesh_solid_errors errors = BG_TRIMESH_SOLID_ERRORS_INIT_NULL;
-    int failed = 0;
-
-    if (bg_trimesh_solid(4, 4, &vertices[0][0], solid_faces, &bad_edges) || bad_edges)
-	failed = 1;
-
-    if (bad_edges) {
-	bu_free(bad_edges, "bad edges");
-	bad_edges = NULL;
-    }
-
-    if (bg_trimesh_solid(4, 4, &vertices[0][0], reversed_faces, &bad_edges) != 1
-	|| !bad_edges) {
-	failed = 1;
-    }
-
-    if (bad_edges)
-	bu_free(bad_edges, "bad edges");
-
-    if (!bg_trimesh_solid2(5, 4, &vertices[0][0], mixed_error_faces, &errors)
-	|| !errors.unmatched.count || !errors.misoriented.count) {
-	failed = 1;
-    }
-    bg_free_trimesh_solid_errors(&errors);
-
-    return failed;
-}
-
-
-static int
-test_free_helpers(void)
-{
-    struct bg_trimesh_edges edges = BG_TRIMESH_EDGES_INIT_NULL;
-    struct bg_trimesh_faces faces = BG_TRIMESH_FACES_INIT_NULL;
-
-    edges.count = 1;
-    edges.edges = (int *)bu_malloc(2 * sizeof(int), "test edges");
-    faces.count = 1;
-    faces.faces = (int *)bu_malloc(sizeof(int), "test faces");
-    bg_free_trimesh_edges(&edges);
-    bg_free_trimesh_faces(&faces);
-
-    return edges.count != 0 || edges.edges || faces.count != 0 || faces.faces;
-}
-
-
-int
-main(int argc, char **argv)
-{
-    bu_setprogname(argv[0]);
-    if (argc != 1)
-	return 1;
-
-    return test_solid_diagnostics() || test_free_helpers();
-}
@@ -88,7 +88,7 @@ intersect_triangle(const point_t origin, const vect_t direction,
 extern "C" {

 int
-bg_isect_tri_ray(const point_t orig, const vect_t dir,
+bg_isect_tri_ray(const point_t orig, const point_t dir,
 		 const point_t vert0, const point_t vert1, const point_t vert2,
 		 point_t *isect)
 {
@@ -285,20 +285,10 @@ bg_trimesh_solid2(int vcnt, int fcnt, fastf_t *v, int *f, struct bg_trimesh_soli

    bad_edge_func = errors ? bg_trimesh_edge_continue : bg_trimesh_edge_exit;

-    unmatched_edges = bg_trimesh_unmatched_edges(num_edges, edge_list, bad_edge_func, NULL);
-    if (!errors && unmatched_edges) {
-	bu_free(edge_list, "edge_list");
-	return 1;
-    }
-
-    misoriented_edges = bg_trimesh_misoriented_edges(num_edges, edge_list, bad_edge_func, NULL);
-    if (!errors && misoriented_edges) {
-	bu_free(edge_list, "edge_list");
-	return 1;
-    }
-
-    excess_edges = bg_trimesh_excess_edges(num_edges, edge_list, bad_edge_func, NULL);
-    if (unmatched_edges || misoriented_edges || excess_edges) {
+    if ((unmatched_edges = bg_trimesh_unmatched_edges(num_edges, edge_list, bad_edge_func, NULL)) ||
+	(misoriented_edges = bg_trimesh_misoriented_edges(num_edges, edge_list, bad_edge_func, NULL)) ||
+	(excess_edges = bg_trimesh_excess_edges(num_edges, edge_list, bad_edge_func, NULL)))
+    {
 	if (!errors) {
 	    bu_free(edge_list, "edge_list");
 	    return 1;
@@ -339,7 +329,6 @@ bg_free_trimesh_edges(struct bg_trimesh_edges *edges)
    if (!edges) return;

    bu_free(edges->edges, "bg trimesh edges");
-    edges->edges = NULL;
    edges->count = 0;
 }

@@ -349,7 +338,6 @@ bg_free_trimesh_faces(struct bg_trimesh_faces *faces)
    if (!faces) return;

    bu_free(faces->faces, "bg trimesh faces");
-    faces->faces = NULL;
    faces->count = 0;
 }

@@ -367,42 +355,34 @@ bg_free_trimesh_solid_errors(struct bg_trimesh_solid_errors *errors)
 int
 bg_trimesh_solid(int vcnt, int fcnt, fastf_t *v, int *f, int **bedges)
 {
-    int not_solid;
+    int bedge_cnt = 0;

    if (bedges) {
-	int copy_count = 0;
-	int edge_count;
+	int copy_cnt = 0;
 	struct bg_trimesh_solid_errors errors = BG_TRIMESH_SOLID_ERRORS_INIT_NULL;

-	*bedges = NULL;
-	not_solid = bg_trimesh_solid2(vcnt, fcnt, v, f, &errors);
-	edge_count = errors.unmatched.count + errors.misoriented.count + errors.excess.count;
-	if (edge_count) {
-	    *bedges = (int *)bu_calloc(edge_count * 2, sizeof(int), "bad edges");
+	bedge_cnt = bg_trimesh_solid2(vcnt, fcnt, v, f, &errors);

-	    if (errors.unmatched.count) {
-		memcpy(*bedges + copy_count, errors.unmatched.edges,
-		       errors.unmatched.count * 2 * sizeof(int));
-		copy_count += errors.unmatched.count * 2;
-	    }
-	    if (errors.misoriented.count) {
-		memcpy(*bedges + copy_count, errors.misoriented.edges,
-		       errors.misoriented.count * 2 * sizeof(int));
-		copy_count += errors.misoriented.count * 2;
-	    }
-	    if (errors.excess.count) {
-		memcpy(*bedges + copy_count, errors.excess.edges,
-		       errors.excess.count * 2 * sizeof(int));
-	    }
-	}
+	*bedges = (int *)bu_calloc(bedge_cnt * 2, sizeof(int), "bad edges");
+
+	if (!errors.unmatched.edges || !errors.unmatched.count)
+	    return 0;
+
+	memcpy(*bedges, errors.unmatched.edges, errors.unmatched.count * 2 * sizeof(int));
+	copy_cnt += errors.unmatched.count * 2;
+
+	memcpy(*bedges + copy_cnt, errors.misoriented.edges, errors.misoriented.count * 2 * sizeof(int));
+	copy_cnt += errors.misoriented.count * 2;
+
+	memcpy(*bedges + copy_cnt, errors.excess.edges, errors.excess.count * 2 * sizeof(int));

 	bg_free_trimesh_solid_errors(&errors);
    } else {
-	not_solid = bg_trimesh_solid2(vcnt, fcnt, v, f, NULL);
+	bedge_cnt = bg_trimesh_solid2(vcnt, fcnt, v, f, NULL);
    }

    /* returns true when not solid */
-    return not_solid ? 1 : 0;
+    return (bedge_cnt > 0) ? 1 : 0;
 }

 int
@@ -662,6 +662,87 @@ bn_vec_perp(vect_t new_vec, const vect_t old_vec)
    VCROSS(new_vec, another_vec, old_vec);
 }

+static int
+bn_lseg3_lseg3_parallel(const point_t sg1pt1, const point_t sg1pt2,
+	const point_t sg2pt1, const point_t sg2pt2,
+	const struct bn_tol *tol)
+{
+    vect_t e_dif[2]    = {{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
+    vect_t e_dif_a[2]  = {{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
+    fastf_t e_rr[2][3] = {{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
+    char e_sc[2][3] = {{0, 0, 0}, {0, 0, 0}};
+    fastf_t dist = tol->dist;
+    fastf_t tmp;
+    int i, j;
+
+    VSUB2(e_dif[0], sg1pt2, sg1pt1);
+    VSUB2(e_dif[1], sg2pt2, sg2pt1);
+
+    for ( i = 0 ; i < 2 ; i++ ) {
+	for ( j = 0 ; j < 3 ; j++ ) {
+	    e_dif_a[i][j] = fabs(e_dif[i][j]);
+	}
+    }
+
+    for ( i = 0 ; i < 2 ; i++ ) {
+	if ((e_dif_a[i][X] < dist) && (e_dif_a[i][Y] > dist)) {
+	    e_sc[i][0] = 1;
+	} else if ((e_dif_a[i][X] > dist) && (e_dif_a[i][Y] < dist)) {
+	    e_sc[i][0] = 2;
+	} else if ((e_dif_a[i][X] < dist) && (e_dif_a[i][Y] < dist)) {
+	    e_sc[i][0] = 3;
+	} else {
+	    e_rr[i][0] = e_dif[i][Y] / e_dif[i][X];
+	    e_sc[i][0] = 0;
+	}
+	if ((e_dif_a[i][X] < dist) && (e_dif_a[i][Z] > dist)) {
+	    e_sc[i][1] = 1;
+	} else if ((e_dif_a[i][X] > dist) && (e_dif_a[i][Z] < dist)) {
+	    e_sc[i][1] = 2;
+	} else if ((e_dif_a[i][X] < dist) && (e_dif_a[i][Z] < dist)) {
+	    e_sc[i][1] = 3;
+	} else {
+	    e_rr[i][1] = e_dif[i][Z] / e_dif[i][X];
+	    e_sc[i][1] = 0;
+	}
+	if ((e_dif_a[i][X] < dist) && (e_dif_a[i][Z] > dist)) {
+	    e_sc[i][1] = 1;
+	} else if ((e_dif_a[i][X] > dist) && (e_dif_a[i][Z] < dist)) {
+	    e_sc[i][1] = 2;
+	} else if ((e_dif_a[i][X] < dist) && (e_dif_a[i][Z] < dist)) {
+	    e_sc[i][1] = 3;
+	} else {
+	    e_rr[i][1] = e_dif[i][Z] / e_dif[i][X];
+	    e_sc[i][1] = 0;
+	}
+	if ((e_dif_a[i][Y] < dist) && (e_dif_a[i][Z] > dist)) {
+	    e_sc[i][2] = 1;
+	} else if ((e_dif_a[i][Y] > dist) && (e_dif_a[i][Z] < dist)) {
+	    e_sc[i][2] = 2;
+	} else if ((e_dif_a[i][Y] < dist) && (e_dif_a[i][Z] < dist)) {
+	    e_sc[i][2] = 3;
+	} else {
+	    e_rr[i][2] = e_dif[i][Z] / e_dif[i][Y];
+	    e_sc[i][2] = 0;
+	}
+    }
+
+    /* loop thru (rise/run) ratios from xy, xz and yz planes */
+    for ( i = 0 ; i < 3 ; i++ ) {
+	if (e_sc[0][i] != e_sc[1][i]) {
+	    return 0;
+	}
+	if (e_sc[0][i] == 0) {
+	    tmp = e_rr[0][i] - e_rr[1][i];
+	    if (fabs(tmp) > dist) {
+		return 0;
+	    }
+	}
+    }
+
+    return 1;
+}
+
 void
 bn_mat_fromto(
    mat_t m,
@@ -672,6 +753,7 @@ bn_mat_fromto(
    vect_t test_to;
    vect_t unit_from, unit_to;
    fastf_t dot;
+    point_t origin = VINIT_ZERO;

    /**
     * The method used here is from Graphics Gems, A. Glassner, ed.
@@ -685,24 +767,18 @@ bn_mat_fromto(
    vect_t N, M;
    vect_t w_prime;		/* image of "to" ("w") in Qt */

-    BN_CK_TOL(tol);
-
    VMOVE(unit_from, from);
    VUNITIZE(unit_from);		/* aka "v" */
    VMOVE(unit_to, to);
    VUNITIZE(unit_to);		/* aka "w" */

-    if (VZERO(unit_from) || VZERO(unit_to)) {
-	MAT_IDN(m);
-	return;
-    }
-
-    /* Same and opposite directions need special handling because their
-     * cross product does not define a rotation axis.
+    /* If from and to are the same or opposite, special handling is
+     * needed, because the cross product isn't defined.  asin(0.00001)
+     * = 0.0005729 degrees (1/2000 degree)
     */
-    dot = VDOT(unit_from, unit_to);
-    if (BN_VECT_ARE_PARALLEL(dot, tol)) {
-	if (dot > 0.0) {
+    if (bn_lseg3_lseg3_parallel(origin, from, origin, to, tol)) {
+	dot = VDOT(from, to);
+	if (dot > SMALL_FASTF) {
 	    MAT_IDN(m);
 	    return;
 	} else {
@@ -736,7 +812,7 @@ bn_mat_fromto(

    /* Verify that it worked */
    MAT4X3VEC(test_to, m, unit_from);
-    if (UNLIKELY(!BN_VECT_ARE_PARALLEL(VDOT(unit_to, test_to), tol))) {
+    if (UNLIKELY(!bn_lseg3_lseg3_parallel(origin, unit_to, origin, test_to, tol))) {
 	dot = VDOT(unit_to, test_to);
 	bu_log("bn_mat_fromto() ERROR!  from (%g, %g, %g) to (%g, %g, %g) went to (%g, %g, %g), dot=%g?\n",
 	       V3ARGS(from), V3ARGS(to), V3ARGS(test_to), dot);
@@ -823,32 +899,16 @@ bn_mat_lookat(mat_t rot, const vect_t dir, int yflip)
    vect_t x;
    vect_t z;
    vect_t t1;
-    vect_t unit_dir;
    fastf_t hypot_xy;
    vect_t xproj;
    vect_t zproj;

-    VMOVE(unit_dir, dir);
-    VUNITIZE(unit_dir);
-    if (VZERO(unit_dir)) {
-	MAT_IDN(rot);
-	return;
-    }
-
    /* First, rotate D around Z axis to match +X axis (azimuth) */
-    hypot_xy = hypot(unit_dir[X], unit_dir[Y]);
-    if (hypot_xy < VDIVIDE_TOL) {
-	if (unit_dir[Z] < 0.0) {
-	    MAT_IDN(rot);
-	} else {
-	    bn_mat_yrot(rot, 0.0, -1.0);
-	}
-	return;
-	}
-    bn_mat_zrot(first, -unit_dir[Y] / hypot_xy, unit_dir[X] / hypot_xy);
+    hypot_xy = hypot(dir[X], dir[Y]);
+    bn_mat_zrot(first, -dir[Y] / hypot_xy, dir[X] / hypot_xy);

    /* Next, rotate D around Y axis to match -Z axis (elevation) */
-    bn_mat_yrot(second, -hypot_xy, -unit_dir[Z]);
+    bn_mat_yrot(second, -hypot_xy, -dir[Z]);
    bn_mat_mul(prod12, second, first);

    /* Produce twist correction, by re-orienting projection of X axis */
@@ -877,7 +937,7 @@ bn_mat_lookat(mat_t rot, const vect_t dir, int yflip)
    }

    /* Check the final results */
-    MAT4X3VEC(t1, rot, unit_dir);
+    MAT4X3VEC(t1, rot, dir);
    if (t1[Z] > -0.98) {
 	bu_log("Error:  bn_mat_lookat final= (%g, %g, %g)\n", V3ARGS(t1));
    }
@@ -1217,10 +1277,10 @@ bn_mat_is_non_unif(const mat_t m)
 void
 bn_wrt_point_direc(mat_t out, const mat_t change, const mat_t in, const point_t point, const vect_t direc, const struct bn_tol *tol)
 {
-    mat_t t1;
-    mat_t pt_to_origin, origin_to_pt;
-    mat_t d_to_zaxis, zaxis_to_d;
-    vect_t zaxis;
+    static mat_t t1;
+    static mat_t pt_to_origin, origin_to_pt;
+    static mat_t d_to_zaxis, zaxis_to_d;
+    static vect_t zaxis;

    /* build "point to origin" matrix */
    MAT_IDN(pt_to_origin);
@@ -1228,7 +1288,7 @@ bn_wrt_point_direc(mat_t out, const mat_t change, const mat_t in, const point_t

    /* build "origin to point" matrix */
    MAT_IDN(origin_to_pt);
-    MAT_DELTAS_VEC(origin_to_pt, point);
+    MAT_DELTAS_VEC_NEG(origin_to_pt, point);

    /* build "direc to zaxis" matrix */
    VSET(zaxis, 0.0, 0.0, 1.0);
@@ -28,11 +28,21 @@

 #include "common.h"

+#include <stdio.h>
+#include <math.h>
+
+#include "bu/interrupt.h"
 #include "bu/malloc.h"
+#include "vmath.h"
 #include "bn/multipoly.h"


 #define FAILSTR "failure in multipoly.c"
+/* the Max and Min macros in vmath.h are destructive and not suited for here, should this be
+ * added somewhere else? */
+#define Max(a, b) (((a) > (b)) ? (a) : (b))
+#define Min(a, b) (((a) > (b)) ? (a) : (b))
+
 /**
 *        bn_multipoly_new
 *
@@ -42,41 +52,25 @@ struct bn_multipoly *
 bn_multipoly_new(int dgrs, int dgrt)
 {
    struct bn_multipoly *newmp;
-    int i;
-
-    if (dgrs <= 0 || dgrt <= 0) {
-	return NULL;
-	}
+    int    i, s, t;

    BU_ALLOC(newmp, struct bn_multipoly);
-    newmp->cf = (double **)bu_calloc(dgrs, sizeof(double *), FAILSTR);
+    newmp->cf = (double **)bu_malloc(dgrs * sizeof(double *), FAILSTR);

    for (i = 0; i < dgrs; i++) {
-	newmp->cf[i] = (double *)bu_calloc(dgrt, sizeof(double), FAILSTR);
+	newmp->cf[i] = (double *)bu_malloc(dgrt * sizeof(double), FAILSTR);
    }

    newmp->dgrs = dgrs;
    newmp->dgrt = dgrt;
+    for (s = 0; s < dgrs; s++) {
+	for (t = 0; t < dgrt; t++) {
+	    newmp->cf[s][t] = 0;
+	}
+    }
    return newmp;
 }

-
-void
-bn_multipoly_free(struct bn_multipoly *poly)
-{
-    int s;
-
-    if (!poly) {
-	return;
-    }
-
-    for (s = 0; s < poly->dgrs; s++) {
-	bu_free(poly->cf[s], "bn_multipoly coefficients");
-    }
-    bu_free(poly->cf, "bn_multipoly coefficient rows");
-    bu_free(poly, "bn_multipoly");
-}
-
 /**
 *        bn_multipoly_grow
 *
@@ -85,35 +79,24 @@ bn_multipoly_free(struct bn_multipoly *poly)
 struct bn_multipoly *
 bn_multipoly_grow(register struct bn_multipoly *P, int dgrs, int dgrt)
 {
-    double **coefficients;
-    int new_dgrs, new_dgrt;
-    int s, t;
-
-    if (!P) {
-	return NULL;
+    int i, j;
+    if (dgrs > P->dgrs) {
+	P->cf = (double **)bu_realloc(P->cf, dgrs * sizeof(double *), FAILSTR);
+	for (i = P->dgrs; i < dgrs; i++) {
+	    P->cf[i] = (double *)bu_malloc(Max(P->dgrt, dgrt) * sizeof(double), FAILSTR);
+	    for (j = 0; j < Max(P->dgrt, dgrt); j++) {
+		P->cf[i][j] = 0;
+	    }
+	}
    }
-
-    new_dgrs = (dgrs > P->dgrs) ? dgrs : P->dgrs;
-    new_dgrt = (dgrt > P->dgrt) ? dgrt : P->dgrt;
-    if (new_dgrs == P->dgrs && new_dgrt == P->dgrt) {
-	return P;
-    }
-
-    coefficients = (double **)bu_calloc(new_dgrs, sizeof(double *), FAILSTR);
-    for (s = 0; s < new_dgrs; s++) {
-	coefficients[s] = (double *)bu_calloc(new_dgrt, sizeof(double), FAILSTR);
-    }
-    for (s = 0; s < P->dgrs; s++) {
-	for (t = 0; t < P->dgrt; t++) {
-	    coefficients[s][t] = P->cf[s][t];
+    if (dgrt > P->dgrt) {
+	for (i = 0; i < P->dgrt; i++) {
+	    P->cf[i] = (double *)bu_realloc(P->cf, dgrt * sizeof(double *), FAILSTR);
+	    for (j = P->dgrt; j < dgrt; j++) {
+		P->cf[i][j] = 0;
+	    }
 	}
-	bu_free(P->cf[s], "bn_multipoly coefficients");
    }
-    bu_free(P->cf, "bn_multipoly coefficient rows");
-
-    P->cf = coefficients;
-    P->dgrs = new_dgrs;
-    P->dgrt = new_dgrt;
    return P;
 }

@@ -125,12 +108,7 @@ bn_multipoly_grow(register struct bn_multipoly *P, int dgrs, int dgrt)
 struct bn_multipoly *
 bn_multipoly_set(register struct bn_multipoly *P, int s, int t, double val)
 {
-    if (!P || s < 0 || t < 0) {
-	return NULL;
-    }
-    if (!bn_multipoly_grow(P, s + 1, t + 1)) {
-	return NULL;
-    }
+    bn_multipoly_grow(P, s + 1, t + 1);
    P->cf[s][t] = val;
    return P;
 }
@@ -141,26 +119,13 @@ bn_multipoly_set(register struct bn_multipoly *P, int s, int t, double val)
 * @brief add two polynomials
 */
 struct bn_multipoly *
-bn_multipoly_add(register const struct bn_multipoly *p1, register const struct bn_multipoly *p2)
+bn_multipoly_add(register struct bn_multipoly *p1, register struct bn_multipoly *p2)
 {
-    struct bn_multipoly *sum;
+    struct bn_multipoly *sum = bn_multipoly_new(Max(p1->dgrs, p2->dgrs), Max(p1->dgrt, p2->dgrs));
    int s, t;
-
-	if (!p1 || !p2 || p1->dgrs <= 0 || p1->dgrt <= 0 ||
-	p2->dgrs <= 0 || p2->dgrt <= 0) {
-	return NULL;
-    }
-
-    sum = bn_multipoly_new((p1->dgrs > p2->dgrs) ? p1->dgrs : p2->dgrs,
-			    (p1->dgrt > p2->dgrt) ? p1->dgrt : p2->dgrt);
    for (s = 0; s < sum->dgrs; s++) {
 	for (t = 0; t < sum->dgrt; t++) {
-	    if (s < p1->dgrs && t < p1->dgrt) {
-		sum->cf[s][t] += p1->cf[s][t];
-	    }
-	    if (s < p2->dgrs && t < p2->dgrt) {
-		sum->cf[s][t] += p2->cf[s][t];
-	    }
+	    sum->cf[s][t] = p1->cf[s][t] + p2->cf[s][t];
 	}
    }
    return sum;
@@ -173,23 +138,15 @@ bn_multipoly_add(register const struct bn_multipoly *p1, register const struct b
 */

 struct bn_multipoly *
-bn_multipoly_mul(register const struct bn_multipoly *p1, register const struct bn_multipoly *p2)
+bn_multipoly_mul(register struct bn_multipoly *p1, register struct bn_multipoly *p2)
 {
-    struct bn_multipoly *product;
-    int s1, s2, t1, t2;
-
-    if (!p1 || !p2 || p1->dgrs <= 0 || p1->dgrt <= 0 ||
-	p2->dgrs <= 0 || p2->dgrt <= 0) {
-	return NULL;
-	}
-
-    product = bn_multipoly_new(p1->dgrs + p2->dgrs - 1,
-				p1->dgrt + p2->dgrt - 1);
+    struct bn_multipoly *product = bn_multipoly_new(p1->dgrs + p2->dgrs, p1->dgrt + p2->dgrt);
+    int s1,s2,t1,t2;
    for (s1 = 0; s1 < p1->dgrs; s1++) {
 	for (t1 = 0; t1 < p1->dgrt; t1++) {
 	    for (s2 = 0; s2 < p2->dgrs; s2++) {
-		for (t2 = 0; t2 < p2->dgrt; t2++) {
-		    product->cf[s1 + s2][t1 + t2] += p1->cf[s1][t1] * p2->cf[s2][t2];
+		for (t2 = 0; t2 < p2->dgrt; p2++) {
+		    product->cf[s1 + s2][t1 + t2] = p1->cf[s1][t1] * p2->cf[s2][t2];
 		}
 	    }
 	}
@@ -28,6 +28,7 @@

 #include "common.h"

+#include <stdlib.h>  /* for abs */
 #include <stdio.h>
 #include <math.h>

@@ -48,24 +49,7 @@ static const struct bn_poly bn_Zero_poly = { BN_POLY_MAGIC, 0, {0.0} };
 struct bn_poly *
 bn_poly_mul(register struct bn_poly *product, register const struct bn_poly *m1, register const struct bn_poly *m2)
 {
-    if (m1->dgr > BN_MAX_POLY_DEGREE ||
-	m2->dgr > BN_MAX_POLY_DEGREE ||
-	m1->dgr > BN_MAX_POLY_DEGREE - m2->dgr) {
-	return BN_POLY_NULL;
-    }
-
-    if (product == m1 || product == m2) {
-	struct bn_poly result;
-
-	if (!bn_poly_mul(&result, m1, m2)) {
-	    return BN_POLY_NULL;
-	}
-	*product = result;
-	return product;
-    }
-
    if (m1->dgr == 1 && m2->dgr == 1) {
-	product->magic = BN_POLY_MAGIC;
 	product->dgr = 2;
 	product->cf[0] = m1->cf[0] * m2->cf[0];
 	product->cf[1] = m1->cf[0] * m2->cf[1] +
@@ -74,7 +58,6 @@ bn_poly_mul(register struct bn_poly *product, register const struct bn_poly *m1,
 	return product;
    }
    if (m1->dgr == 2 && m2->dgr == 2) {
-	product->magic = BN_POLY_MAGIC;
 	product->dgr = 4;
 	product->cf[0] = m1->cf[0] * m2->cf[0];
 	product->cf[1] = m1->cf[0] * m2->cf[1] +
@@ -94,7 +77,12 @@ bn_poly_mul(register struct bn_poly *product, register const struct bn_poly *m1,

 	*product = bn_Zero_poly;

-	product->dgr = m1->dgr + m2->dgr;
+	/* If the degree of the product will be larger than the
+	 * maximum size allowed in "polyno.h", then return a null
+	 * pointer to indicate failure.
+	 */
+	if ((product->dgr = m1->dgr + m2->dgr) > BN_MAX_POLY_DEGREE)
+	    return BN_POLY_NULL;

 	for (ct1=0; ct1 <= m1->dgr; ++ct1) {
 	    for (ct2=0; ct2 <= m2->dgr; ++ct2) {
@@ -122,26 +110,28 @@ bn_poly_scale(register struct bn_poly *eqn, double factor)
 struct bn_poly *
 bn_poly_add(register struct bn_poly *sum, register const struct bn_poly *poly1, register const struct bn_poly *poly2)
 {
-    struct bn_poly result;
+    struct bn_poly tmp;
    register size_t i, offset;

-    offset = (poly1->dgr >= poly2->dgr) ?
-	poly1->dgr - poly2->dgr : poly2->dgr - poly1->dgr;
+    offset = labs((long)poly1->dgr - (long)poly2->dgr);
+
+    tmp = bn_Zero_poly;

    if (poly1->dgr >= poly2->dgr) {
-	result = *poly1;
+	*sum = *poly1;
 	for (i=0; i <= poly2->dgr; ++i) {
-	    result.cf[i+offset] += poly2->cf[i];
+	    tmp.cf[i+offset] = poly2->cf[i];
 	}
    } else {
-	result = *poly2;
+	*sum = *poly2;
 	for (i=0; i <= poly1->dgr; ++i) {
-	    result.cf[i+offset] += poly1->cf[i];
+	    tmp.cf[i+offset] = poly1->cf[i];
 	}
    }

-    result.magic = BN_POLY_MAGIC;
-    *sum = result;
+    for (i=0; i <= sum->dgr; ++i) {
+	sum->cf[i] += tmp.cf[i];
+    }
    return sum;
 }

@@ -149,30 +139,30 @@ bn_poly_add(register struct bn_poly *sum, register const struct bn_poly *poly1,
 struct bn_poly *
 bn_poly_sub(register struct bn_poly *diff, register const struct bn_poly *poly1, register const struct bn_poly *poly2)
 {
-    struct bn_poly result;
+    struct bn_poly tmp;
    register size_t i, offset;

-    offset = (poly1->dgr >= poly2->dgr) ?
-	poly1->dgr - poly2->dgr : poly2->dgr - poly1->dgr;
+    offset = labs((long)poly1->dgr - (long)poly2->dgr);
+
+    *diff = bn_Zero_poly;
+    tmp = bn_Zero_poly;

    if (poly1->dgr >= poly2->dgr) {
-	result = *poly1;
+	*diff = *poly1;
 	for (i=0; i <= poly2->dgr; ++i) {
-	    result.cf[i+offset] -= poly2->cf[i];
+	    tmp.cf[i+offset] = poly2->cf[i];
 	}
    } else {
-	result = bn_Zero_poly;
-	result.dgr = poly2->dgr;
+	diff->dgr = poly2->dgr;
 	for (i=0; i <= poly1->dgr; ++i) {
-	    result.cf[i+offset] = poly1->cf[i];
-	}
-	for (i=0; i <= poly2->dgr; ++i) {
-	    result.cf[i] -= poly2->cf[i];
+	    diff->cf[i+offset] = poly1->cf[i];
 	}
+	tmp = *poly2;
    }

-    result.magic = BN_POLY_MAGIC;
-    *diff = result;
+    for (i=0; i <= diff->dgr; ++i) {
+	diff->cf[i] -= tmp.cf[i];
+    }
    return diff;
 }

@@ -187,20 +177,12 @@ bn_poly_synthetic_division(struct bn_poly *quo, struct bn_poly *rem, const struc
    *rem = bn_Zero_poly; /* struct copy */

    if (dvsor->dgr > dvdend->dgr) {
-	*rem = *dvdend;
-	*quo = bn_Zero_poly;
-	return;
+	quo->dgr = -1;
+    } else {
+	quo->dgr = dvdend->dgr - dvsor->dgr;
    }
-
-    if (dvsor->dgr == 0) {
-	for (n=0; n <= quo->dgr; ++n) {
-	    quo->cf[n] /= dvsor->cf[0];
-	}
-	return;
-    }
-
-    quo->dgr = dvdend->dgr - dvsor->dgr;
-    rem->dgr = dvsor->dgr - 1;
+    if ((rem->dgr = dvsor->dgr - 1) > dvdend->dgr)
+	rem->dgr = dvdend->dgr;

    for (n=0; n <= quo->dgr; ++n) {
 	quo->cf[n] /= dvsor->cf[0];
@@ -218,11 +200,10 @@ bn_poly_synthetic_division(struct bn_poly *quo, struct bn_poly *rem, const struc
 int
 bn_poly_quadratic_roots(register struct bn_complex *roots, register const struct bn_poly *quadrat)
 {
-    struct bn_poly monic;
    fastf_t discrim, denom, rad;
    const fastf_t small = SMALL_FASTF;

-    if (ZERO(quadrat->cf[0]) && fpclassify(quadrat->cf[0]) == FP_ZERO) {
+    if (NEAR_ZERO(quadrat->cf[0], small)) {
 	/* root = -cf[2] / cf[1] */
 	if (NEAR_ZERO(quadrat->cf[1], small)) {
 	    /* No solution.  Now what? */
@@ -235,12 +216,6 @@ bn_poly_quadratic_roots(register struct bn_complex *roots, register const struct
 	return 1;	/* OK - repeated root */
    }

-    if (!NEAR_EQUAL(quadrat->cf[0], 1.0, small)) {
-	monic = *quadrat;
-	bn_poly_scale(&monic, 1.0 / monic.cf[0]);
-	quadrat = &monic;
-	}
-
    discrim = quadrat->cf[1]*quadrat->cf[1] - 4.0* quadrat->cf[0]*quadrat->cf[2];
    denom = 0.5 / quadrat->cf[0];

@@ -289,7 +264,7 @@ bn_poly_cubic_roots(register struct bn_complex *roots, register const struct bn_
    fastf_t a, b, c1, c1_3rd, delta;
    register int i;

-    if (ZERO(eqn->cf[0]) && fpclassify(eqn->cf[0]) == FP_ZERO) return 0;
+    if (ZERO(eqn->cf[0])) return 0;

    /* Cardano's formula below is expressed for a monic polynomial. */
    if (!NEAR_EQUAL(eqn->cf[0], 1.0, SMALL_FASTF)) {
@@ -383,7 +358,7 @@ bn_poly_quartic_roots(register struct bn_complex *roots, register const struct b

 #define Max3(a, b, c) ((c)>((a)>(b)?(a):(b)) ? (c) : ((a)>(b)?(a):(b)))

-    if (ZERO(eqn->cf[0]) && fpclassify(eqn->cf[0]) == FP_ZERO) return 0;
+    if (ZERO(eqn->cf[0])) return 0;

    /* Ferrari's formula below is expressed for a monic polynomial. */
    if (!NEAR_EQUAL(eqn->cf[0], 1.0, SMALL_FASTF)) {
@@ -174,14 +174,7 @@ quat_double(quat_t qout, const quat_t q1, const quat_t q2)
 void
 quat_bisect(quat_t qout, const quat_t q1, const quat_t q2)
 {
-    quat_t qsum;
-
-    QADD2(qsum, q1, q2);
-    if (QMAGSQ(qsum) < VDIVIDE_TOL * VDIVIDE_TOL) {
-	quat_slerp(qout, q1, q2, 0.5);
-	return;
-    }
-    QMOVE(qout, qsum);
+    QADD2( qout, q1, q2 );
    QUNITIZE( qout );
 }

@@ -309,12 +302,9 @@ quat_log(quat_t out, const quat_t in)
    fastf_t	theta;
    fastf_t	scale;

-    scale = MAGNITUDE(in);
-    if (scale > VDIVIDE_TOL) {
+    if ( (scale = MAGNITUDE(in)) > VDIVIDE_TOL )  {
 	theta = atan2( scale, in[W] );
 	scale = theta/scale;
-    } else {
-	scale = 0.0;
    }

    VSCALE( out, in, scale );
@@ -33,22 +33,6 @@ vect_close_or_neg(const vect_t a, const vect_t b, double tol)
 }


-static int
-lookat_is_valid(const vect_t direction)
-{
-    vect_t expected = {0.0, 0.0, -1.0};
-    vect_t output = VINIT_ZERO;
-    mat_t matrix = MAT_INIT_ZERO;
-
-    bn_mat_lookat(matrix, direction, 0);
-    MAT4X3VEC(output, matrix, direction);
-    VUNITIZE(output);
-
-    return finite_vec(output) && vect_close(output, expected, 1.0e-12)
-	&& orthonormal_rotation(matrix, 1.0e-12);
-}
-
-
 static int
 test_mat_basic(void)
 {
@@ -815,13 +799,6 @@ test_mat_orientation(void)
    int failures = 0;
    const char *test = "mat_orientation";
    struct bn_tol tol = BN_TOL_INIT_TOL;
-    struct bn_tol angular_tol = BN_TOL_INIT_TOL;
-    static const vect_t lookat_directions[] = {
-	{0.0, 0.0, -1.0},
-	{0.0, 0.0, 1.0},
-	{0.0, 0.0, -5.0},
-	{0.0, 0.0, 5.0}
-    };
    vect_t input = {1.0, 2.0, 3.0};
    vect_t perp = VINIT_ZERO;
    vect_t expected_perp = {0.0, 0.0, 1.0};
@@ -829,14 +806,9 @@ test_mat_orientation(void)
    vect_t to = {0.0, 1.0, 0.0};
    vect_t opposite = {-1.0, 0.0, 0.0};
    vect_t dir = {1.0, 1.0, -2.0};
-    vect_t near_from = {1.0, 0.0, 0.0};
-    vect_t near_to = {1.0, 0.1, 0.0};
-    vect_t near_to_unit = VINIT_ZERO;
-    vect_t zero_dir = VINIT_ZERO;
    vect_t out = VINIT_ZERO;
    hvect_t homogeneous = HINIT_ZERO;
    mat_t m = MAT_INIT_ZERO;
-    size_t i;

    if (!HZERO(homogeneous)) {
 	report_failure(test, "HZERO failed for a zero homogeneous vector");
@@ -872,18 +844,6 @@ test_mat_orientation(void)
 	failures++;
    }

-    angular_tol.dist = 1.0;
-    angular_tol.dist_sq = 1.0;
-    bn_mat_fromto(m, near_from, near_to, &angular_tol);
-    MAT4X3VEC(out, m, near_from);
-    VUNITIZE(out);
-    VMOVE(near_to_unit, near_to);
-    VUNITIZE(near_to_unit);
-    if (VDOT(out, near_to_unit) < 1.0 - 1.0e-12 || !orthonormal_rotation(m, 1.0e-12)) {
-	report_failure(test, "bn_mat_fromto used distance tolerance for angular classification");
-	failures++;
-    }
-
    VUNITIZE(dir);
    bn_mat_lookat(m, dir, 0);
    MAT4X3VEC(out, m, dir);
@@ -894,19 +854,6 @@ test_mat_orientation(void)
 	failures++;
    }

-    for (i = 0; i < sizeof(lookat_directions) / sizeof(lookat_directions[0]); i++) {
-	if (!lookat_is_valid(lookat_directions[i])) {
-	    report_failure(test, "bn_mat_lookat failed for an axial direction");
-	    failures++;
-	}
-    }
-
-    bn_mat_lookat(m, zero_dir, 0);
-    if (!mat_close(m, bn_mat_identity, 0.0)) {
-	report_failure(test, "bn_mat_lookat did not return identity for a zero direction");
-	failures++;
-    }
-
    return failures;
 }

@@ -917,7 +864,6 @@ test_mat_transform(void)
    int failures = 0;
    const char *test = "mat_transform";
    const double legacy_tol = BN_TOL_DIST;
-    struct bn_tol tol = BN_TOL_INIT_TOL;
    static const struct {
 	double sinv;
 	double cosv;
@@ -973,14 +919,8 @@ test_mat_transform(void)
    point_t p = {2.0, 2.0, 3.0};
    point_t axis_point = {1.0, 2.0, 10.0};
    point_t expected = {1.0, 3.0, 3.0};
-    point_t pivot = {1.0, 2.0, 3.0};
-    point_t pivot_offset = {2.0, 2.0, 3.0};
-    point_t pivot_expected = {1.0, 3.0, 3.0};
    point_t out = VINIT_ZERO;
-    vect_t pivot_direction = {0.0, 0.0, 1.0};
    mat_t m = MAT_INIT_ZERO;
-    mat_t change = MAT_INIT_ZERO;
-    mat_t input = MAT_INIT_ZERO;
    int i;

    bn_mat_arb_rot(m, anchor, axis, M_PI_2);
@@ -996,20 +936,6 @@ test_mat_transform(void)
 	failures++;
    }

-    bn_mat_zrot(change, 1.0, 0.0);
-    MAT_IDN(input);
-    bn_wrt_point_direc(m, change, input, pivot, pivot_direction, &tol);
-    MAT4X3PNT(out, m, pivot);
-    if (!vect_close(out, pivot, 1.0e-12)) {
-	report_failure(test, "bn_wrt_point_direc moved its pivot point");
-	failures++;
-    }
-    MAT4X3PNT(out, m, pivot_offset);
-    if (!vect_close(out, pivot_expected, 1.0e-12)) {
-	report_failure(test, "bn_wrt_point_direc did not rotate around its pivot point");
-	failures++;
-    }
-
    MAT_IDN(m);
    if (bn_mat_is_non_unif(m) != 0) {
 	report_failure(test, "bn_mat_is_non_unif misclassified the identity matrix");
@@ -199,153 +199,6 @@ test_poly_ops(void)
 }


-static int
-test_poly_edge_cases(void)
-{
-    int failures = 0;
-    const char *test = "poly_edge_cases";
-    const double linear_coeffs[] = {1.0, -1.0};
-    const double quadratic_coeffs[] = {1.0, 0.0, -4.0};
-    const double aliased_sum_coeffs[] = {1.0, 1.0, -5.0};
-    const double aliased_difference_coeffs[] = {-1.0, 1.0, 3.0};
-    const double aliased_product_coeffs[] = {1.0, -1.0, -4.0, 4.0};
-    const double dividend_coeffs[] = {1.0, -3.0, 2.0};
-    const double constant_divisor_coeffs[] = {2.0};
-    const double constant_quotient_coeffs[] = {0.5, -1.5, 1.0};
-    const double higher_divisor_coeffs[] = {1.0, 0.0, 1.0};
-    const double degree_six_coeffs[] = {1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
-    const double untouched_product_coeffs[] = {42.0};
-    const double zero_coeffs[] = {0.0};
-    const double scaled_quadratic_coeffs[] = {1.0e-12, -5.0e-12, 6.0e-12};
-    const double scaled_cubic_coeffs[] = {1.0e-12, -6.0e-12, 11.0e-12, -6.0e-12};
-    const double scaled_quartic_coeffs[] = {1.0e-12, 0.0, -10.0e-12, 0.0, 9.0e-12};
-    bn_poly_t linear = poly_from_coeffs(1, linear_coeffs);
-    bn_poly_t quadratic = poly_from_coeffs(2, quadratic_coeffs);
-    bn_poly_t dividend = poly_from_coeffs(2, dividend_coeffs);
-    bn_poly_t constant_divisor = poly_from_coeffs(0, constant_divisor_coeffs);
-    bn_poly_t higher_divisor = poly_from_coeffs(2, higher_divisor_coeffs);
-    bn_poly_t degree_six = poly_from_coeffs(6, degree_six_coeffs);
-    bn_poly_t rejected_product = poly_from_coeffs(0, untouched_product_coeffs);
-    bn_poly_t quotient = BN_POLY_INIT_ZERO;
-    bn_poly_t remainder = BN_POLY_INIT_ZERO;
-    bn_poly_t scaled_quadratic = poly_from_coeffs(2, scaled_quadratic_coeffs);
-    bn_poly_t scaled_cubic = poly_from_coeffs(3, scaled_cubic_coeffs);
-    bn_poly_t scaled_quartic = poly_from_coeffs(4, scaled_quartic_coeffs);
-    bn_complex_t roots[4];
-
-    if (!bn_poly_add(&linear, &linear, &quadratic) ||
-	!poly_close(&linear, 2, aliased_sum_coeffs, 0.0)) {
-	report_failure(test, "bn_poly_add did not support output aliasing a lower-degree input");
-	failures++;
-    }
-
-    linear = poly_from_coeffs(1, linear_coeffs);
-    if (!bn_poly_sub(&linear, &linear, &quadratic) ||
-	!poly_close(&linear, 2, aliased_difference_coeffs, 0.0)) {
-	report_failure(test, "bn_poly_sub did not support output aliasing a lower-degree input");
-	failures++;
-    }
-
-    linear = poly_from_coeffs(1, linear_coeffs);
-    if (!bn_poly_mul(&linear, &linear, &quadratic) ||
-	!poly_close(&linear, 3, aliased_product_coeffs, 0.0)) {
-	report_failure(test, "bn_poly_mul did not support output aliasing an input");
-	failures++;
-    }
-
-    if (bn_poly_mul(&rejected_product, &degree_six, &quadratic) ||
-	!poly_close(&rejected_product, 0, untouched_product_coeffs, 0.0)) {
-	report_failure(test, "bn_poly_mul modified its output after a degree-limit failure");
-	failures++;
-    }
-
-    linear = poly_from_coeffs(1, linear_coeffs);
-    bn_poly_synthetic_division(&quotient, &remainder, &dividend, &constant_divisor);
-    if (!poly_close(&quotient, 2, constant_quotient_coeffs, 0.0) ||
-	!poly_close(&remainder, 0, zero_coeffs, 0.0)) {
-	report_failure(test, "bn_poly_synthetic_division failed for a constant divisor");
-	failures++;
-    }
-
-    bn_poly_synthetic_division(&quotient, &remainder, &linear, &higher_divisor);
-    if (!poly_close(&quotient, 0, zero_coeffs, 0.0) ||
-	!poly_close(&remainder, 1, linear_coeffs, 0.0)) {
-	report_failure(test, "bn_poly_synthetic_division mishandled a higher-degree divisor");
-	failures++;
-    }
-
-    if (!bn_poly_quadratic_roots(roots, &scaled_quadratic) ||
-	!has_real_root(roots, 2, 2.0, 1.0e-10) ||
-	!has_real_root(roots, 2, 3.0, 1.0e-10)) {
-	report_failure(test, "bn_poly_quadratic_roots rejected a scaled quadratic");
-	failures++;
-    }
-
-    if (!bn_poly_cubic_roots(roots, &scaled_cubic) ||
-	!has_real_root(roots, 3, 1.0, 1.0e-10) ||
-	!has_real_root(roots, 3, 2.0, 1.0e-10) ||
-	!has_real_root(roots, 3, 3.0, 1.0e-10)) {
-	report_failure(test, "bn_poly_cubic_roots rejected a scaled cubic");
-	failures++;
-    }
-
-    if (!bn_poly_quartic_roots(roots, &scaled_quartic) ||
-	!has_real_root(roots, 4, -3.0, 1.0e-8) ||
-	!has_real_root(roots, 4, -1.0, 1.0e-8) ||
-	!has_real_root(roots, 4, 1.0, 1.0e-8) ||
-	!has_real_root(roots, 4, 3.0, 1.0e-8)) {
-	report_failure(test, "bn_poly_quartic_roots rejected a scaled quartic");
-	failures++;
-    }
-
-    return failures;
-}
-
-
-static int
-test_multipoly_ops(void)
-{
-    int failures = 0;
-    const char *test = "multipoly_ops";
-    struct bn_multipoly *p1 = bn_multipoly_new(1, 1);
-    struct bn_multipoly *p2 = bn_multipoly_new(3, 2);
-    struct bn_multipoly *sum;
-    struct bn_multipoly *product;
-
-    if (!p1 || !p2 || !bn_multipoly_set(p1, 1, 2, 3.0) ||
-	!bn_multipoly_set(p2, 0, 0, 2.0) ||
-	!bn_multipoly_set(p2, 2, 1, 5.0)) {
-	report_failure(test, "could not construct bivariate polynomial operands");
-	bn_multipoly_free(p1);
-	bn_multipoly_free(p2);
-	return failures + 1;
-    }
-
-    sum = bn_multipoly_add(p1, p2);
-    product = bn_multipoly_mul(p1, p2);
-    if (!sum || sum->dgrs != 3 || sum->dgrt != 3 ||
-	!scalar_close(sum->cf[0][0], 2.0, 0.0) ||
-	!scalar_close(sum->cf[1][2], 3.0, 0.0) ||
-	!scalar_close(sum->cf[2][1], 5.0, 0.0)) {
-	report_failure(test, "bn_multipoly_add did not preserve differently sized operands");
-	failures++;
-    }
-
-    if (!product || product->dgrs != 4 || product->dgrt != 4 ||
-	!scalar_close(product->cf[1][2], 6.0, 0.0) ||
-	!scalar_close(product->cf[3][3], 15.0, 0.0)) {
-	report_failure(test, "bn_multipoly_mul did not accumulate coefficient products");
-	failures++;
-    }
-
-    bn_multipoly_free(product);
-    bn_multipoly_free(sum);
-    bn_multipoly_free(p2);
-    bn_multipoly_free(p1);
-    return failures;
-}
-
-
 static int
 test_poly_legacy(void)
 {
@@ -700,8 +553,6 @@ test_poly_roots(void)

 static const struct bn_api_case poly_cases[] = {
    {"ops", test_poly_ops},
-    {"edge", test_poly_edge_cases},
-    {"multipoly", test_multipoly_ops},
    {"legacy", test_poly_legacy},
    {"roots", test_poly_roots},
    {NULL, NULL}
@@ -244,12 +244,6 @@ test_qmath_interp(void)
 	failures++;
    }

-    quat_bisect(out, qid, qanti);
-    if (!quat_is_unit_finite(out, 1.0e-12)) {
-	report_failure(test, "quat_bisect antipodal branch failed to return a finite unit quaternion");
-	failures++;
-    }
-
    quat_double(exact, qdouble_same_in, qdouble_same_in);
    if (!hvect_close(exact, qdouble_same_expected, 1.0e-3)) {
 	report_failure(test, "quat_double legacy same-input case failed");
@@ -332,8 +326,6 @@ test_qmath_logexp(void)
    quat_t v = {0.2, -0.1, 0.3, 0.0};
    quat_t q = HINIT_ZERO;
    quat_t out = HINIT_ZERO;
-    quat_t qidentity = {0.0, 0.0, 0.0, 1.0};
-    quat_t qzero = HINIT_ZERO;
    quat_t qin = {0.3, 0.4, 0.1, 0.85};
    int i;

@@ -355,12 +347,6 @@ test_qmath_logexp(void)
 	failures++;
    }

-    quat_log(out, qidentity);
-    if (!hvect_close(out, qzero, 0.0)) {
-	report_failure(test, "quat_log did not map identity to the zero quaternion");
-	failures++;
-    }
-
    for (i = 0; i < (int)(sizeof(exp_cases) / sizeof(exp_cases[0])); i++) {
 	quat_exp(q, exp_cases[i].in);
 	if (!hvect_close(q, exp_cases[i].expected, 1.0e-3)) {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Clifford Yapp	aa96b975c9	Support using OpenQMC for Cauchy/Crofton sampling instead of PRNG	2026-09-18 09:59:52 -04:00
Clifford Yapp	5434e46ff0	facetize: add source-guided adaptive SPSR Fixed-size point dumps make Poisson reconstruction unreliable as a last-resort facetization method. They can miss thin partitions while oversampling surfaces that are already well resolved, and an arbitrary point count does not show whether source characterization is complete. Seed reconstruction with stabilized Crofton samples. Retain paired entry and exit normals, partition thickness, and ray identities so thin geometry contributes explicit local information instead of unrelated points. Add a bounded adaptive libbg driver around the existing upstream Poisson solver. Each solve reports residual, density, normal, and surface-variation hints to a caller callback. Facetize responds with exact source rays and validates partitions, endpoints, chord length, area, volume, and closed-manifold topology before accepting a result. Bound refinement by time, point, pass, and convergence limits. Relax only chord and thin-partition thresholds when the source BoT is already known to be non-manifold. Deprecate the fixed-array API, remove the intermediate point-sampling path, adapt pnts callers, and add focused coverage. The vendored SPSR implementation remains unchanged. Use configured method priority for perturbation variants so an MDC-only run never invokes NMG. Report finalization progress and retry counts while the fallback hierarchy is evaluated.	2026-09-18 09:59:52 -04:00
Clifford Yapp	2c1dd12033	libanalyze: replace marching cubes with adaptive MDC The legacy marching-cubes polygonizer sampled a uniform grid and could miss thin or high-aspect features, merge undersampled tunnels, and emit surfaces whose shared-edge winding was inconsistent. Increasing the global resolution made those failures prohibitively expensive rather than addressing their local causes. Add a ray-driven manifold dual contouring API built on an adaptive octree. Cache exact signs and Hermite edge crossings from librt partitions, place feature-preserving vertices with bounded QEF solves, and refine locally for thin walls, multiple crossings, interior surfaces, and ambiguous topology. Build faces from shared crossings with deterministic winding and require closed manifold output. Back analyze_polygonize with the new implementation, expose MDC as a facetize method, and remove the obsolete polygonizer code, licensing, continuation sampler, and CM default. Keep NMG available when polygon preservation is more important and it can successfully process the input. Document the Ju, Schaefer, and Warren algorithmic basis and the bottom-up Euler-characteristic escalation path. Add coverage for thin walls, tunnels, overlapping CSG, toroidal cases, winding, resource limits, and the compatibility polygonalize entry point.	2026-09-18 09:59:52 -04:00
Clifford Yapp	ac31dd518e	facetize: retire the legacy pipeline and harden region results The compatibility implementation duplicated command behavior and retained unreliable paths that had been superseded by the planned worker pipeline. Keeping both implementations made option handling and failure behavior needlessly difficult to reason about. Remove the old facetize sources and MGED registration so all command modes use the maintained orchestrator. Preserve implicitly selected region roots in the output database and keep region retries scoped to validated perturbation inputs. Tighten source and result validation, reject empty preparation results, and suppress expected import or preparation diagnostics only inside a scoped log hook. Keep routine details out of the terminal summary and write complete detail logs when concise reporting is not possible. Extend regression and validation coverage for implicit roots, tolerated failures, and malformed or unsupported inputs.	2026-09-18 09:59:52 -04:00
Clifford Yapp	45e477240a	facetize: separate orchestration and isolate NMG evaluation The command implementation mixed option handling, mode selection, database setup, scheduling, and result publication. NMG Boolean work also ran in the parent process, allowing known NMG failures to terminate the overall conversion. Introduce an explicit planning and orchestration layer so each command mode follows one visible execution path. Replace positional worker arguments with typed request and result messages that are validated before they can alter the working database. Move NMG Boolean evaluation into the supervised subprocess framework. Transfer trees and BoTs through the existing transaction protocol, report failures without killing the parent, and reject primitives that do not provide the required tessellation callback. Update facetize regression and worker-protocol coverage for the new boundaries and failure semantics.	2026-09-18 09:59:52 -04:00
Clifford Yapp	b3ad69b490	facetize: add supervised parallel primitive workers Primitive tessellation previously paid process and database setup costs per object and left the parent with limited visibility into work that timed out or died. Large models consequently spent substantial time outside the tessellation algorithms themselves. Add long-lived supervised workers and a bounded scheduler for independent objects. Divide CPUs between worker processes and each worker internal parallelism, reuse opened databases, and retain cache state across requests. Make result publication transactional. A WRITE_STARTED acknowledgment closes the READY and PROCEED race, while the parent detects timeouts and abnormal exits, restarts workers, and records only completed object results. Reuse temporary result databases without leaking state between requests. Add process and database-transfer helpers together with worker, recovery, and validation tests. Document the parallel job control and its resource behavior.	2026-09-18 09:59:52 -04:00
Clifford Yapp	2ad973e7d3	librt: make Crofton sampling deterministic and reusable Retain ordinary Monte Carlo chord sampling while making its stream explicit and portable. Draw independent sphere endpoints from a fixed-seed mt19937_64 generator so every setup is reproducible without changing the estimator's statistical convergence model. Convert the generator's high 53 bits explicitly to avoid library- specific real-number conversions. Consume four values per ray so ray offsets reproduce disjoint continuations of the same stream. Reuse a bounded C++ worker pool and stop only after windowed area estimates remain stable. This avoids repeated thread construction while retaining the existing stopping criteria. Add optional collection of ray identifiers, paired entry and exit hit points, normals, and partition thickness. This gives reconstruction callers structured source evidence while preserving lightweight area and volume estimation. Link librt to the thread target and extend the Crofton tests to verify that offset calls exactly reproduce the uninterrupted stream.	2026-09-18 09:59:52 -04:00
Clifford Yapp	572cc3afa2	libbu: support resource-aware worker processes Large subprocess pools need to divide machine resources without allowing each worker internal parallelism to consume every CPU. Add a process-local limit to bu_avail_cpus() and bu_parallel(), with atomic updates and coverage for applying and removing the limit. Make BU_MEM_AVAIL count FreeBSD reclaimable inactive and cache queues in addition to immediately free pages. This prevents idle systems from appearing memory-starved to resource-aware algorithms and adds native sysctl checks for the reported values. Rename the private process.h to process_private.h. This prevents the source header from shadowing the MSVC CRT header used by std::thread, which otherwise leaves _beginthreadex undeclared.	2026-09-18 09:59:52 -04:00