SHAPE Software: Multi-Domain Shape Modeling

• SHAPE software is a family of computational tools that treats geometric form as a primary object, spanning medical imaging, PDE optimization, astrophysics, morphometrics, and design.
• In medical imaging, systems like ShapeKit employ rule-based, morphological post-processing to correct segmentation errors and achieve measurable improvements in accuracy.
• For PDE-constrained optimization, astrophysical reconstruction, and design synthesis, these tools integrate domain-specific knowledge, adjoint methods, and shape grammars to tackle complex, non-unique problems.

Across the literature represented here, “SHAPE software” denotes several distinct but related classes of software centered on shape information: shape-aware post-processing for medical segmentation, PDE-constrained shape optimization environments, interactive morpho-kinematical reconstruction in astrophysics, contour-based morphometrics and descriptor extraction, and programmable systems for rule-based or learned shape generation. What unifies these systems is not a single codebase or methodology, but the use of shape as a primary computational object—whether as an anatomical constraint, a design variable, a 3D structural hypothesis, a contour descriptor, or an executable program (Liu et al., 30 Jun 2025, Blauth, 2023, Steffen et al., 2010, Wu et al., 2024, Jones et al., 2020).

1. Terminological scope and software families

In the present research usage, the term spans multiple software families rather than a single canonical package. A concise way to organize the landscape is by the role played by shape in computation.

Domain	Representative software	Core role of shape
Medical imaging	ShapeKit	Post-processing and shape regularization of segmentation masks
PDE-constrained optimization	cashocs, Fireshape, Morpho, SC-SR1	Shape as an optimization variable or trust-region geometry
Astronomy	SHAPE, PyCross, LEADER	3D morpho-kinematical modeling or population-level shape inference
Image-based shape analysis	ElliShape, 2D descriptor suite, OpenCapsule	Contour extraction, descriptor computation, inverse fitting from images
Shape grammars and program synthesis	Shape Machine system, ShapeAssembly	Rule-based or learned generation of structured shapes

This diversity has practical consequences. In medical imaging, shape software may be inserted after inference as a reusable software layer that repairs anatomical masks. In numerical optimization, it may mean a framework that automates adjoint derivation, shape derivative computation, and optimization algorithms. In astrophysics, it may denote an interactive environment that reconstructs 3D morphology and velocity fields from images and spectra. In morphometrics, it may mean software that normalizes elliptic Fourier descriptors or computes validated 2D shape descriptors. In design and graphics, it may mean executable shape grammars or a domain-specific language for 3D assembly (Liu et al., 30 Jun 2025, Blauth, 2023, Steffen et al., 2010, Wu et al., 2024, Jones et al., 2020).

A common misconception is that SHAPE software refers only to PDE-based shape optimization. The literature here suggests a broader classification: some systems optimize geometry under PDE constraints, some correct implausible masks, some infer latent 3D structure from observables, and some treat shape itself as a programmable representation (Blauth, 2023, Liu et al., 30 Jun 2025, Steffen et al., 2010, Jones et al., 2020).

2. Shape-aware post-processing in medical imaging

In medical imaging, ShapeKit is a shape-focused, model-agnostic post-processing toolkit for whole-body CT segmentation. It operates on 3D binary or multi-label masks produced by any segmentation model, including nnU-Net, VISTA3D, MONAI models, and proprietary clinical systems, and targets a wide range of thoracic, abdominal, retroperitoneal, pelvic, and skeletal structures (Liu et al., 30 Jun 2025).

The software is motivated by a specific failure mode of strong deep segmentation models: even when overlap metrics are high, masks can retain speckle artifacts, false positives leaking into neighboring tissues, fragmented organs that should be continuous, redundant or duplicated branches, and left–right laterality errors. ShapeKit codifies these defects as a five-part taxonomy—artifacts, false positives, redundant structures, fragmented structures, and left–right errors—and applies deterministic corrections through rule-based, morphological, and topological operations rather than retraining or fine-tuning a network (Liu et al., 30 Jun 2025).

Its core functions include removal of small connected components, suppression of non-dominant components, false-positive reassignment between adjacent organs, merging of fragmented structures, and left–right separation and validation using spatial heuristics and the liver as a right-sided landmark. Organ-specific logic, such as retaining only two largest components for lungs or kidneys and one for liver or pancreas, is configured via a configuration file, so the toolkit remains extensible across datasets (Liu et al., 30 Jun 2025).

The typical workflow is explicitly downstream of inference: raw model output is converted to per-organ masks, a configurable sequence of NumPy/SciPy operations is applied, and the refined segmentation is returned with the same label schema so that it drops back into existing pipelines for quantification, visualization, or export. This design is central to ShapeKit’s identity as a post-processing, shape-regularization toolkit rather than a segmentation network (Liu et al., 30 Jun 2025).

The reported empirical effect is substantial. The paper describes consistent >8% improvements in segmentation performance in some organs and >10% DSC in a large benchmark, with organ-wise examples such as gall bladder 71.7 → 79.7 on Dataset A and 68.1 → 76.9 on Dataset B, and pancreas 79.3 → 84.5 on Dataset A and 73.5 → 79.0 on Dataset B. The same paper contrasts these gains with the observation that architectural modifications in strong baselines typically yield <3% DSC improvement, supporting the claim that shape-focused post-processing can outperform architecture tinkering, especially in out-of-distribution settings (Liu et al., 30 Jun 2025).

3. PDE-constrained shape optimization and shape-changing solvers

A second major meaning of SHAPE software is software for PDE-constrained optimization, where the geometry or domain is itself the design variable. In this setting, the canonical formulation is of the form

$$\min_{\Omega,\alpha} J(u,\Omega,\alpha) \quad \text{s.t.} \quad A(u,\Omega,\alpha)=0,$$

with the “design” represented by a shape, a control field, or a topology variable (Blauth, 2023).

cashocs is a general-purpose, adjoint-based software system for PDE-constrained shape and optimal control problems. It is tightly integrated with FEniCS and PETSc/MPI, automates adjoint derivation and shape derivative computation, and exposes unified APIs such as ShapeOptimizationProblem, OptimalControlProblem, and TopologyOptimizationProblem. Version 2.0 adds a framework for space mapping, topology optimization via a level-set approach, support for parallelism via MPI, and handling of additional state constraints. It also supports custom scalar products for shape gradients and a p-Laplace gradient smoothing approach (Blauth, 2023). The earlier cashocs paper emphasizes continuous adjoint discretization, mesh-independent behavior, and remeshing via Gmsh, while also making clear that topology changes were not the central focus of that initial release (Blauth, 2020).

Fireshape occupies a related but distinct niche. It is an open-source and automated shape optimization toolbox for Firedrake, based on the moving mesh method and integrated with UFL, pyadjoint, PETSc, and ROL. Its design goal is to let users solve challenging PDE-constrained shape optimization problems with minimal manual shape calculus. The paper demonstrates 3D Navier–Stokes pipe design and 2D linear elasticity compliance minimization, while explicitly stating that topology optimization is beyond its scope; this is an important contrast with cashocs version 2.0, which does include topology optimization via level sets (Paganini et al., 2020).

Morpho extends the optimization-centered meaning of SHAPE software toward soft matter and shapeshifting materials. It is an open-source programmable environment for shape optimization and shapeshifting problems, built around explicit meshes, attached scalar or tensor fields, and variational functionals over domains and boundaries. Its examples include swelling hydrogels, complex fluids that form aspherical droplets, and soap films and membranes. The environment is positioned as general-purpose and programmable, with mesh-aware regularization and optimization over both geometry and fields (Joshi et al., 2022).

At a lower algorithmic layer, SC-SR1 provides a more specialized interpretation of SHAPE: not software for optimizing a physical shape, but software for shape-changing trust-region subproblems. It is a MATLAB implementation of the symmetric rank-one method that solves trust-region subproblems using two shape-changing norms adapted to a limited-memory SR1 matrix. Those norms allow the trust-region subproblem to decompose into two separate problems; with one norm the resulting subproblems have closed-form solutions, and with the other one subproblem has a closed-form solution while the other is easily solvable using the L-SR1 structure. The software is specifically designed to remain accurate even in the hard case (Brust et al., 2016).

These systems also delimit one another. A recurring misconception is that all optimization-oriented SHAPE software handles both smooth shape changes and topology changes. The literature here is explicit: Fireshape focuses on moving-mesh shape optimization and does not straightforwardly support topology changes, while cashocs version 2.0 explicitly extends to topology optimization via a level-set approach (Paganini et al., 2020, Blauth, 2023).

4. Astronomical reconstruction, rendering, and statistical shape inference

In astrophysics, SHAPE refers first to an interactive 3D morpho-kinematical modeling and visualization tool designed specifically for gaseous astronomical objects. It is used to reconstruct and explore the three-dimensional structure and velocity fields of nebulae, nova shells, jets, and related systems from observed images and spectra. The software combines meshes, modifiers, particles or voxels, and parameterized velocity fields, then renders synthetic observables in the same forms as telescope data: narrow-band images, position–velocity diagrams, channel maps, and line profiles (Steffen et al., 2010).

The epistemic model is different from that of automated inversion. SHAPE was explicitly developed for cases where fully automatic 3D reconstruction methods fail because they rely on strong assumptions such as perfect symmetry or homologous expansion. Instead, SHAPE allows the astronomer to supply prior physical knowledge by interactively defining structural elements, velocity fields, and emissivity distributions, and then iteratively comparing synthetic outputs to observations. The paper also stresses a central limitation: models are not unique, and optimization cannot eliminate degeneracy; user expertise and external constraints remain necessary (Steffen et al., 2010).

PyCross extends this astrophysical SHAPE ecosystem by connecting SHAPE geometry to photoionization modeling. PyCross is a pseudo 3D modelling application that generates photoionisation models of optically thin nebulae created using the SHAPE software. It reads a SHAPE-derived slice, uses Cloudy via PyCloudy to compute ionisation structure and emissivities along each ray, and then reconstructs pseudo-3D ionisation and emission maps for axisymmetric nebulae. The resulting workflow is deliberately GUI-driven and designed to avoid the steep learning curve of scripting directly in Cloudy or PyCloudy (Fitzgerald et al., 2020).

A different astronomical use of “shape software” appears in LEADER, which is not a detailed 3D modeling package but a statistical population-level inference tool. LEADER computes joint distributions of asteroid shape elongation $p$ and spin latitude $\beta$ from scarce survey photometry by constructing a cumulative distribution function of brightness variations and inverting it with analytical basis functions and a constrained linear inverse problem. The paper explicitly distinguishes this from object-by-object inversion: LEADER yields population distributions rather than individual detailed shapes, and synthetic simulations are treated as necessary before a database can be used reliably (Nortunen et al., 2017).

Taken together, these astronomical systems illustrate three distinct roles for shape software: interactive 3D hypothesis construction, physically motivated rendering and ionisation modeling, and statistical inference of shape populations from sparse observations (Steffen et al., 2010, Fitzgerald et al., 2020, Nortunen et al., 2017).

5. Contour-based morphometrics, descriptor software, and inverse mechanical fitting

Another major class of SHAPE software treats contours or silhouettes as the primary data structure. ElliShape is a recent example built around elliptic Fourier analysis. The paper reformulates EFD computation for digital contours and introduces true EFD normalization, designed to remain invariant under all basic contour transformations. The associated software is described as user-friendly and combines efficient EFD computation with an interactive contour/outline extraction workflow that uses automatic contour generation together with manual correction and refinement. Compared with existing software, ElliShape is reported to produce reliable reconstructed shapes and normalized EFD values across different contours and transformations, while also improving visualization and processing of complex digital images (Wu et al., 2024).

The theoretical object computed by such software is the elliptic Fourier descriptor of a closed contour,

$$x(t) = A_0 + \sum_{n=1}^{N} \left(A_n \cos nt + B_n \sin nt\right), \qquad y(t) = C_0 + \sum_{n=1}^{N} \left(C_n \cos nt + D_n \sin nt\right),$$

with normalization intended to remove translation, scaling, rotation, starting-point, reversal, and reflection ambiguities. ElliShape’s contribution is precisely that earlier normalization procedures, including those used in SHAPE, Momocs, and MASS, do not yield a unique normalized descriptor under all basic transformations (Wu et al., 2024).

A related but distinct software tradition appears in the general-purpose software suite of seven validated off-the-shelf 2D shape descriptors developed for object-based image analysis and GEOBIA. That suite emphasizes a compact, physically interpretable dictionary of descriptors—such as convexity, fuzzy rule-based rectangularity, roundness sensitive to holes, multiscale straightness of boundaries, morphological multiscale characteristic, elongatedness sensitive to holes, and combined simple connectivity—together with a QA4EO-oriented validation strategy based on inter-feature dependence and causality assessment rather than classification accuracy alone (Baraldi et al., 2017).

OpenCapsule extends contour-based processing into inverse mechanics. It is a C/C++ software package for shape analysis of deflated elastic capsules in a pendant geometry. Given experimental images, a reference undeformed shape, density difference, and capillary diameter, it fits numerically generated axisymmetric shell-theory shapes to digitized contours in order to infer elastic moduli. For nonlinear Hookean elasticity, it determines Young’s surface modulus or area compression modulus together with Poisson’s ratio; for Mooney–Rivlin and neo-Hookean elasticity, it determines the corresponding Rivlin parameters. If wrinkling wavelengths are measured, the software also infers bending modulus and shell thickness (Hegemann et al., 2017).

These packages show that image-based SHAPE software is not limited to descriptive morphometrics. It may normalize descriptors for comparative analysis, validate a dictionary of interpretable geometric features, or solve an inverse problem that maps shape directly to constitutive parameters (Wu et al., 2024, Baraldi et al., 2017, Hegemann et al., 2017).

6. Rule-based and learned shape programming

A final major usage of SHAPE software arises in design systems where shapes are generated or edited through executable rules or programs. In architectural computing, the Durand case study built on Shape Machine shows how a shape grammar can be implemented inside Rhino 7 using DrawScript+, the Turing-complete programming layer of Shape Machine. The system is structured around modules such as Room Marker, Room Builder, and Detailer, and explicitly interprets software engineering notions such as encapsulation, abstraction, inheritance, and polymorphism in a shape-grammar context. The result is a modular generator for Durand’s plates that can operate directly on CAD geometry (Agarwal, 2024).

The central idea is that a shape grammar is not merely a static set of rules but an executable architecture. In the Durand system, layout generation, marking, room construction, and detailing are separated into reusable blocks; optional modules such as corridors and domes can be switched by control-flow mechanisms like JUMP instructions. The paper presents this as a practical example of SHAPE software embedded inside mainstream CAD, not as an abstract formalism detached from production workflows (Agarwal, 2024).

ShapeAssembly pushes this programming view into learned 3D synthesis. It introduces a domain-specific “assembly-language” for 3D shape structures in which programs construct shapes by declaring cuboid part proxies and attaching them to one another in hierarchical and symmetrical fashion. The software stack includes a differentiable interpreter, an extraction pipeline from PartNet structures, and a hierarchical sequence VAE that learns to write new ShapeAssembly programs. The resulting outputs are more plausible and physically valid than those of competing structure-synthesis models, and the same framework can be used to infer and fit programs to point clouds (Jones et al., 2020).

A plausible implication is that these systems shift SHAPE software from analysis toward representation engineering. In Shape Machine, the operative unit is a rule block over CAD geometry; in ShapeAssembly, it is a learned program with explicit part declarations, attachments, reflection, and translation macros. Both treat shape as executable structure rather than only as geometry or a numerical state (Agarwal, 2024, Jones et al., 2020).

7. Common themes, limits, and research directions

Despite their disciplinary differences, these SHAPE software systems share several recurrent design principles. First, shape is made explicit rather than incidental: anatomical plausibility in ShapeKit, geometric transformations in cashocs and Fireshape, explicit meshes and fields in Morpho, morpho-kinematical structures in SHAPE, normalized contours in ElliShape, and cuboid programs in ShapeAssembly all encode shape as a first-class computational object (Liu et al., 30 Jun 2025, Blauth, 2023, Joshi et al., 2022, Steffen et al., 2010, Wu et al., 2024, Jones et al., 2020).

Second, many systems insert domain knowledge where purely data-driven or generic methods are insufficient. ShapeKit uses organ adjacency and laterality rules; SHAPE uses astronomer-supplied physical intuition; cashocs and Fireshape rely on adjoint calculus and user-defined PDE forms; OpenCapsule embeds shell theory; the GEOBIA descriptor suite emphasizes physically meaningful features; Shape Machine and ShapeAssembly encode explicit structural rules (Liu et al., 30 Jun 2025, Steffen et al., 2010, Blauth, 2023, Hegemann et al., 2017, Baraldi et al., 2017, Agarwal, 2024).

Third, limitations are domain-specific but structurally similar. Rule-based systems may oversimplify variation: ShapeKit can fail on highly complex structures such as the colon, and OpenCapsule assumes axisymmetry. Moving-mesh shape optimization does not straightforwardly accommodate topology changes, while cashocs requires users to provide topological derivatives for topology optimization. Astrophysical SHAPE models remain non-unique and depend on user expertise. ElliShape improves normalization and contour extraction, but its significance is precisely that earlier software struggled with reliable invariance and robust image processing (Liu et al., 30 Jun 2025, Hegemann et al., 2017, Paganini et al., 2020, Blauth, 2023, Steffen et al., 2010, Wu et al., 2024).

Future directions are correspondingly diverse. ShapeKit points toward learned shape priors, uncertainty-aware corrections, and deeper integration of shape-aware constraints into segmentation training. cashocs identifies further development of constrained and topology-aware PDE optimization with MPI-enabled workflows. Morpho points toward broader discretizations, richer optimization methods, active and non-equilibrium dynamics, and GPU acceleration. ShapeAssembly points toward more expressive primitives, richer program constraints, and tighter coupling between structure and surface generation (Liu et al., 30 Jun 2025, Blauth, 2023, Joshi et al., 2022, Jones et al., 2020).

Understood in this broader sense, SHAPE software is best described not as a single application domain but as a family of research software systems in which geometric form is itself the locus of computation, inference, correction, or generation.