Files
MeltMind/artifacts/phase1-ml-survey-2026-11-17/shape-mesh-fulltext-extractions.md
T

21 KiB
Raw Blame History

Undermind full-text extraction receipt

These are tool-produced paper readings, not independent experimental reproductions. Exact-version caveats and corrections in the lane map take precedence over overbroad summary sentences here.

[Par19]:

Audit verdict

DeepSDF is a candidate for learning a compact, continuous shape representation from a class of geometries—not a demonstrated model for predicting injection-molding physics. The paper evaluates reconstruction, completion from partial geometry, and latent-space interpolation. It does not train or evaluate predictions of fill time, pressure, temperature, velocity, or other physical fields.

Data scale and splits

  • Independent geometries: the paper uses ShapeNet object meshes, not injection-molding parts. It does not report the exact number of training or test geometries, or the sizes of the train/test splits for its principal ShapeNet experiments. It reports a 100-car set for a truncation-distance study (Supplementary Sec. D.2), 500 chairs for a network-depth/memorization experiment (Sec. D.1), and 85 plane completions for a noisy-input experiment (Sec. B). These are specific experiments, not evidence of a documented few-hundred-geometry train/test split.
  • Per-geometry samples: Sec. 5 says it samples 500,000 spatial points per mesh. Supplementary Sec. F gives more detail on surface-weighted sampling. Supplementary Sec. G says batches use 16,384 SDF samples per shape.
  • Trajectories, frames, and nodes: none are reported. The data are static shape meshes and sampled spatial locations with SDF values; there are no physical trajectories, time frames, or simulation-node counts.
  • Split evidence: the paper describes held-out test shapes and refers to benchmark splits (including Dai et al.’s split for completion), but the supplied paper text does not give exact split counts. It also says representation/completion experiments use different ShapeNet versions (Supplementary Sec. I.1.1–I.1.2).

So the paper supplies some experiments at the scale of 100 or 500 shapes, but does not establish few-hundred-geometry generalization for injection-molding parts. In particular, the 500-chair experiment is described as memorizing SDFs, not as a held-out generalization test.

What the model learns—and what test-time fitting uses

DeepSDF’s decoder takes a latent shape code and a 3D query point and outputs an approximate signed distance (Sec. 4.2, Eq. 5). Training fits SDF samples and regularizes each shape code (Eq. 9); test-time code estimation minimizes the SDF-data loss plus the code prior (Eq. 10).

For unseen-shape reconstruction, the fitting evidence is geometry expressed as SDF samples. For completion, the paper derives SDF constraints from partial depth observations—points offset on either side of observed surfaces, plus free-space constraints (Sec. 6.3). Thus, the test-time latent optimization is not an encoder-only prediction from a compact descriptor: it explicitly fits the code to the supplied geometric observations.

There is no target physical solution in these fitting objectives, so the described procedure does not leak a physical field. But it also provides no evidence that a code fitted from geometry alone predicts a physical solution. The paper’s claims concern geometry: reconstruction, completion, normals, and interpolation—not segmentation, part correspondence, or supervised physical-field prediction.

Practical fit and limitations for the proposed use

  • Topology and extraction: DeepSDF is continuous and does not impose a fixed mesh topology; the paper explicitly targets complex topologies and closed surfaces (Sec. 1; Table 1). A mesh can be extracted with Marching Cubes; the paper used a (512^3) grid for quantitative mesh evaluations (Supplementary Sec. I.1.1). The representation itself is not a remeshed volume mesh, and the paper does not evaluate preserving mesh-to-mesh node correspondence.
  • Input assumptions and remeshing: training starts from complete meshes and derives oriented surface samples and SDF labels (Sec. 5; Supplementary Sec. F). Meshes that were not sufficiently watertight were problematic: Supplementary Sec. F says meshes with more than 2% double-sided triangles were discarded. Completion observations must be in the canonical shape frame (Sec. 6.3); the conclusion notes that handling arbitrary pose requires additional SE(3) optimization. The paper does not specify an injection-part CAD remeshing workflow or assess sensitivity to CAD tessellation.
  • Thin sections and junctions: there is no dedicated evaluation of wall thickness, thin features, ribs, gates, weld lines, or junction geometry. Since the learned target is sampled SDF, the authors emphasize aggressive near-surface sampling (Sec. 5; Supplementary Sec. F), but report no thickness-specific accuracy or guarantee that narrow gaps/walls will be retained. These are therefore validation requirements for a molding application, not demonstrated capabilities or demonstrated failures.
  • Compute and code: Supplementary Sec. G reports training on 8 Nvidia GPUs for approximately 8 hours and 1,000 epochs. The paper reports 9.72 s for DeepSDF inference in Table 1; its conclusion explains that completion takes longer because it requires explicit latent-code optimization. The parsed paper text does not identify an official code repository or provide a code URL, so code availability cannot be confirmed from this paper.

Numeric evidence, with scope

The most directly relevant small-set numeric evidence is the 100-car truncation-distance experiment (Supplementary Sec. D.2), which measures surface reconstruction accuracy—not generalization to a new application. For held-out ShapeNet reconstruction, Table 3 reports DeepSDF mean Chamfer values of 0.204 (chair), 0.143 (plane), 0.553 (table), 0.832 (lamp), and 0.132 (sofa), with lower being better. Those are benchmark shape metrics, not physical-field errors or injection-part results.

Table 1 summarizes representation types and reported model size/inference time; Tables 3–4 give unseen-shape reconstruction and completion comparisons, respectively.

[REGION: page=6, bbox=70,60,290,913]

Table 1 compares the benchmarked representations, including DeepSDF’s continuous SDF with no discretization, its reported model size of 0.0074 GB, and its 9.72 s inference time. It helps distinguish the paper’s representation and runtime claims from any claim about physical prediction.

[REGION: page=7, bbox=446,60,762,490]

Table 3 reports held-out ShapeNet reconstruction metrics for chairs, planes, tables, lamps, and sofas. It supports a geometry-reconstruction comparison only; it does not report injection-molding parts or physical-field accuracy.

[REGION: page=7, bbox=447,484,676,906]

Table 4 compares completion from partial range scans against 3D-EPN for chair, plane, and sofa shapes. The task is geometric completion from observed surfaces, not prediction of a simulated physical solution.

Bottom line: the paper supports testing DeepSDF as a compact geometry prior or reconstruction/completion representation. It does not support treating it as a supervised physical-field surrogate, and it does not provide the exact dataset split counts needed to claim validated few-hundred-part generalization.


[Pfa20]:

Audit summary

MESHGRAPHNETS is a supervised simulator for dynamics on an already-meshed domain—not a shape-reconstruction, segmentation, or correspondence model. For injection molding, it could be relevant only as a candidate for predicting physical fields after a suitable mesh and the required physical state are supplied. The paper does not test injection molding, fill-time prediction, or learning from only a few hundred independent part geometries.

What the paper’s data counts do—and do not—establish

Each dataset contains 1,000 training, 100 validation, and 100 test trajectories; trajectories have 250–600 time steps (Appendix A.1). These are counts of trajectories, not counts of independent geometries. The paper does not report how many distinct geometries are represented in those splits, whether geometry identities are disjoint across splits, or a split specifically designed to measure generalization to unseen part geometries. Table 1 reports average mesh-node counts, not geometry counts.

Dataset Steps/trajectory Average nodes
FLAGSIMPLE 400 1,579
FLAGDYNAMIC 250 2,767
SPHEREDYNAMIC 500 1,373
DEFORMINGPLATE 400 1,271
CYLINDERFLOW 600 1,885
AIRFOIL 600 5,233

The authors do show a shape generalization example: a model trained on simple rectangular cloth is tested on fish-shaped flags and a windsock, with results described as visually similar to ground truth (Section 5). The paper does not give the number of distinct test shapes or a small-data study over geometry counts. Thus this is evidence of a qualitative example, not evidence that a model trained on a few hundred geometries will generalize to unseen molding parts.

The quantitative metrics are for physical rollout prediction, not shape reconstruction, segmentation, or correspondence. For example, Table 1 reports AIRFOIL RMSE of 314 × 10⁻³ for one-step prediction, 582 × 10⁻³ for 50-step rollout, and 11,529 × 10⁻³ for full-trajectory rollout. These results cannot be read as geometry accuracy or fill-time accuracy. The paper’s rollout RMSE is computed on position for Lagrangian systems and momentum for Eulerian systems (Appendix A.5.2).

The appendix’s scaling analysis reports 50-step rollout errors across different node counts and new cloth shapes; the authors say there is no systematic error trend with node count in FLAGDYNAMIC, while errors on new shapes are slightly higher but comparable. This remains a cloth-dynamics result, not an unseen-part reconstruction or molding result.

Table 1 gives per-dataset trajectory lengths, average nodes, physical-prediction RMSEs, and inference timings; its metrics are useful for understanding the scale of the simulation experiments, but are not geometry-task scores.
[REGION: page=7, bbox=691,155,943,845]

Appendix A.1’s dataset table lists the six simulated domains, their mesh types, trajectory lengths, and (where applicable) world-edge radii. The adjacent encoding table shows that the models consume mesh and physical-state features.
[REGION: page=13, bbox=607,155,779,845]

Figure A.3 plots cloth rollout RMSE against node count for FLAGDYNAMIC and new cloth shapes. It supports the paper’s limited claim about scaling and shape transfer in that domain, not generalization to molding parts.
(REGION: page=18, label: Figure A.3]

Representation, outputs, and test-time inputs

The state is a mesh graph: nodes, mesh edges, reference mesh-space coordinates, and domain-specific dynamical quantities (Section 3). The network predicts next-step dynamics; depending on the domain these are accelerations, velocities, or changes in momentum/density. Pressure or stress can be auxiliary outputs (Sections 3.1 and 4; Appendix A.1).

This is not a point-cloud/image-to-mesh pipeline: the simulation mesh and its connectivity are provided. Nor does the paper describe a test-time per-part latent-code fitting procedure. Inference is amortized Encode–Process–Decode prediction on the input mesh and current state, iterated during rollout. Training is supervised using simulator-derived next-step targets (Section 3.3; Appendix A.2.1). The paper does not use a future target physical solution as a test-time fitting input; but it also does not demonstrate prediction from geometry alone. For fluid examples, the current physical fields (e.g. momentum and, for AIRFOIL, density) are part of the input.

Accordingly, the paper provides no method or results for shape reconstruction, part segmentation, or establishing correspondence between independent CAD parts. Mesh nodes serve as the simulation discretization, not as a learned cross-part correspondence.

Remeshing and topology

The paper’s adaptive remeshing learns a sizing field and applies a generic local remesher. For triangular meshes, the remesher splits, collapses, and flips edges (Section 3.2; Appendix A.3). Thus the mesh node count and connectivity can change during a rollout. In dynamically meshed cloth datasets, there is no one-to-one node correspondence between steps; the authors use barycentric interpolation in mesh space to transfer history and targets (Appendix A.1).

That is not evidence that the method handles arbitrary part-topology changes, discovers topology from geometry, or manages molding-specific junctions. The demonstrated remeshing is local adaptation of an existing triangular mesh under a predicted sizing field; the paper says other mesh types may require different remeshers (Section 3.2).

Geometry and molding-specific caveats

The experiments include 3D triangular cloth surfaces, a 3D tetrahedral hyperelastic plate, and 2D triangular fluid meshes (Sections 4 and Appendix A.1). The tetrahedral plate shows that the framework is not limited to surface meshes, but the paper does not describe converting observed part surfaces into volumes, inferring wall thickness, or modeling thin-wall thickness variation. It also does not evaluate ribs, bosses, branching/junction regions, or flow-front behavior in an injection mold. Those are untested requirements, not capabilities established by the paper.

In particular, do not infer fill-time performance from AIRFOIL or CYLINDERFLOW: those are aerodynamic/incompressible-flow benchmarks, not injection-molding fill simulations, and the paper reports no fill-time results.

Code and compute

The paper gives the official code location as deepmind-research/meshgraphnets (Section 4). Models were trained on a single V100 GPU for 10 million training steps (Appendix A.2.1). The paper reports substantially faster inference than its reference solvers, but these are solver-specific simulation timings, not evidence about the cost or data requirements of geometry reconstruction or molding deployment (Table 1; Appendix A.5.1).

Bottom line: this is a plausible starting point for mesh-based, simulator-supervised physical-field prediction when the mesh and required state are available. The paper does not establish it as a representation for reconstructing, segmenting, or matching unseen injection-molding parts, nor does it provide evidence for strong performance from only a few hundred independent geometries.


[Sha20]:

Audit verdict

DiffusionNet is a plausible surface-geometry feature/label network, but this paper does not establish it as a predictor of injection-molding physics or as a method validated on a few hundred unseen parts. Its experiments are on classification, segmentation, and shape correspondence—not supervised prediction of fill time, pressure, temperature, or another physical field. The paper reports no fill-time results.

What the paper actually tests—and how much data

Task and evidence Geometry count, resolution, and split stated in the paper What the result supports
SHREC-11 classification (Sec. 5.1, Table 1) 30 categories × 20 shapes = 600 shapes; train on 10 per class (= 300 training shapes), with random training splits and results averaged over 10 trials. Per-shape node counts are not reported here. Small-training-set classification: 99.7% accuracy with HKS on original models; 99.5% on simplified models. This is not evidence of physical-field prediction or generalization to new part families.
RNA segmentation (Sec. 5.2, Table 2) 640 meshes, about 15k vertices each; random 80/20 train/test split (= 512/128 meshes). Point-cloud version uses 4,096 sampled points. Segmentation accuracy: 91.5% on meshes with xyz input; 85.0% on point clouds with xyz input. This is supervised labeling, not a continuous physical field.
FAUST correspondence under remeshing (Sec. 5.4, Table 5) Train on 80 standard registered meshes; evaluate on remeshed/sampled test shapes. The section does not separately give the test-set geometry count or per-shape node counts for these variants. Correspondence remains comparatively stable under remeshing/resampling; the metric is normalized geodesic correspondence error, not physical-prediction error.
Functional correspondence (Sec. 5.3, Table 4; Fig. 9) Tests include SCAPE and FAUST, including training on one dataset and testing on the other; geometry counts are not stated in this section. Evidence for learned correspondence features and cross-dataset matching—not prediction of molding outcomes on unseen parts.

No trajectory, time-frame, or time-varying field dataset is described: the paper gives no trajectory count, frame count, or physical-solution node/frame counts. The vertex counts above are mesh or point-cloud input sizes, not counts of measured physical-field labels.

The paper’s strongest directly relevant small-data result is therefore the 300-shape SHREC training set, but it is a shape-category classification benchmark. It does not establish sample efficiency for supervised physical-field prediction.

Model, inputs, compute, and inference

The method diffuses per-vertex feature channels over a surface using a learned diffusion time, adds spatial-gradient features, and applies pointwise MLPs (Secs. 3–4; Fig. 7). Inputs used in the experiments are xyz coordinates or heat-kernel signatures (HKS) (Sec. 4.1). The paper gives the official code URL as github.com/nmwsharp/diffusion-net (Sec. 5).

There is no test-time latent fitting procedure in the paper: it does not optimize a latent code against a target physical solution. Inference uses the trained network and geometric operators assembled for the input shape (Laplacian, mass, and gradient matrices; Sec. 5.5). The tested targets are labels or correspondence-related outputs, not a measured physical solution that could leak into test-time fitting.

For compute, the authors report a 24 GB Titan RTX GPU and dual Xeon 5120 2.2 GHz CPUs (Sec. 5.6). On the RNA meshes, they report 38 ms per input for training evaluation and 2.2 GB GPU memory; preprocessing takes 5.4 s per input on CPU (Sec. 5.6). Table 6 reports, for an 184k-vertex input, 379 ms training evaluation and 154 ms inference with spectral acceleration.

Remeshing, topology, and molding-relevant representation gaps

  • Remeshing: The FAUST correspondence experiment trains on registered template meshes and evaluates on isotropically remeshed, variable-density, quadric-simplified, and sampled-point-cloud versions. Table 5 reports DiffusionNet errors of 0.33, 0.68, 0.62, 0.82, and 2.59, respectively, on the original, isotropic, dense, quadric-simplified, and point-cloud variants. These values are ×100 normalized geodesic distance/diameter; they are correspondence errors, not physical-field errors. The authors also caution that transfer between representations still incurs a small performance drop (Sec. 6).
  • Topology/connectivity: The paper explicitly says the method is not automatically robust to topological errors or outliers. Diffusion cannot communicate between disconnected surface components, which can produce nonsensical outputs (Sec. 6; Fig. 12). Thus, robustness to remeshing should not be read as robustness to arbitrary topology changes or changed physical connectivity.
  • Surface versus volume: The experiments are surface-based. The method’s stated operators are a surface Laplacian, mass matrix, and spatial gradients (Secs. 3 and 5.5). The paper mentions volumetric meshes as a possible future adaptation (Sec. 6), but does not test one.
  • Thickness and junctions: The paper does not model part thickness, through-thickness fields, mold cavities, gates, weld/junction physics, or surface-to-volume transfer. Those capabilities—and performance on such cases—are not established here.

Relevant graphic locations: Table 1 gives the SHREC classification comparison, including the 99.7% HKS result; it matters as the paper’s clearest few-hundred-training-example result, but is classification rather than physical prediction.
[REGION: page=7, bbox=379,499,654,936]

Table 2 compares RNA segmentation accuracy on meshes and point clouds; it shows the 640-mesh task and the reported segmentation metrics.
[REGION: page=8, bbox=79,62,345,505]

Table 5 reports correspondence error across the five FAUST discretizations; it is the paper’s direct quantitative remeshing/resampling evidence, not a physical-field test.
[REGION: page=10, bbox=280,63,559,503]

Table 6 reports preprocessing, training, and inference times at 752, 10k, and 184k vertices; it is relevant to the method’s computational scale, not its physical-prediction accuracy.
[REGION: page=11, bbox=476,63,895,501]

Region format: page is 1-indexed; bbox=top,left,bottom,right, normalized 0-1000 from top-left.