acceptodds
Under review as a conference paper at ICLR 2027

Spend Bits Where the Pattern Bends: Corner-Based Coding of Sewing-Pattern Boundaries

Abstract

Learned models increasingly read and write sewing patterns, and every panel passes through them as a coded boundary that pattern software must accept back. Current boundary codes cut the panel into equal pieces and give each the same number of bits. A straight seam then costs as much as an armhole, and the corner between them gets rounded off. We observe that most of the error sits in a few short curves, and that the corners and straight seams that make up most of a panel are charged like curves. To this end, we propose CornerMCQ, a boundary code that spends bits only where the boundary bends and needs no neural network. Specifically, it stores the detected corners on a vertex grid, gives the straight runsbetween them no curve bits, and describes each remaining curve relative to its chord with a few small codebooks fitted once. On a public corpus and a private industrial archive, CornerMCQ is more accurate than Bézier fitting, PCA, and a learned vector quantizer at equal bits and several times more accurate than the same codebooks on equal pieces; on the public corpus, with fewer bits than the equal-piece code, three panels in four stay within two millimetres of the reference boundary everywhere, against one panel in a hundred.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
sewing patterns, boundary code, corners, straight seams, curves, vertex grid, codebooks, Bézier fitting, learned vector quantizer

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_uevtOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents CornerMCQ, a geometry-adaptive coding scheme for sewing-pattern boundaries. It explicitly preserves detected corners, represents straight segments using endpoints, and encodes curved segments with residual K-means codebooks in chord-normalized coordinates. Experiments on GarmentCodeData and a private industrial dataset demonstrate substantial rate–distortion improvements over fixed-support coding and PCA. Under matched partitions and bit budgets, CornerMCQ also consistently outperforms Bézier fitting, PCA with scalar quantization, and learned residual VQ-VAE. Additional experiments evaluate cross-domain transfer and CAD file round-trip compatibility.

Critical strengths
  1. The paper provides extensive comparisons across two datasets, multiple bit budgets, and controlled coding alternatives. The matched-partition experiments, ablations, and statistical analyses convincingly demonstrate the benefits of geometry-adaptive bit allocation.

  2. CornerMCQ achieves competitive reconstruction accuracy with compact codebooks and low computational overhead. The CAD round-trip validation and cross-domain transfer experiments strengthen its practical relevance.

Critical weaknesses
  1. The approach primarily combines established corner detection, adaptive contour segmentation, and residual vector quantization. Although effective, the conceptual contribution is incremental. More importantly, direct comparisons with competitive classical rate–distortion-optimized contour coders are missing, making it difficult to assess the improvement over existing adaptive shape-coding methods.

  2. Reconstruction errors are evaluated against cleaned, 512-sample boundaries rather than the original CAD geometry. The common rendering can also alter explicitly preserved corners, while native-geometry auditing is reported only on validation data. Furthermore, the representation excludes important manufacturing entities, and robustness to real digitization noise remains unverified. These limitations weaken the broader claims of manufacturing readiness.

Questions for authors
  1. How does CornerMCQ compare with classical rate–distortion-optimized vertex-based or spline-based contour coders under matched bit budgets?

  2. Can the authors quantify reconstruction errors relative to the original CAD boundaries and provide native-decoding CAD audits on the held-out test sets?

  3. Can the authors clarify the exact bitstream cost when refined vertices exceed the nominal 12-bit coordinate range, and how traversal direction and boundary phase are handled in standalone decoding?

2 comments
AuthorsOpenReview ↗

Response to Reviewer uevt (1/2)

Thank you for the precise questions and for your positive assessment of the controlled comparisons. Unless stated otherwise, new analyses use the validation splits. Full tables are in Appendix K.

Contribution. Corner detection, adaptive segmentation and residual vector quantization exist individually, and we claim none of them as new. The contribution is a bit allocation designed for sewing-pattern boundaries and a controlled evaluation in which the same-partition controls change only the curve coder and the ablations only the partition. The seam-pairing test in our reply to Reviewer rnrp shows that the effect of this allocation carries over to a downstream task.

Classical rate–distortion coders (Q1). As you asked, we implemented two classical coders under the same ledger as CornerMCQ: a 96-bit frame, an 8-bit count and the 12-bit vertex grid, with real bitstreams written and decoded. The vertex-based coder follows Schuster and Katsaggelos (1998): it chooses polygon vertices by dynamic programming on distortion plus λ times rate, from three start vertices; trying every start vertex on 100 panels per dataset lowered its rate by only 0.1–0.6%. The spline-based coder keeps our refined corners as breakpoints. By the same Lagrangian criterion, it chooses further breakpoints, the number of control points per piece and, optionally, non-uniform knots. The only tuned setting, the distortion norm, was chosen on GarmentCode training panels.

We compare, on validation, the bits each coder needs to reach the curve distance of a CornerMCQ operating point. Up to about 410 bits per panel, the classical coders need about 4–12% more bits than CornerMCQ: 7.0% and 3.7% more on GarmentCode at Corner L=3 and Coarse L=2, and 5.6%, 12.2% and 9.2% more in the industrial archive at Corner L=3 and the two Coarse points. At the two points at 437 and 428 bits (GarmentCode Coarse L=3, industrial Mid L=3) the margin is below 1%, which we read as roughly on par. From about 500 bits on, the spline coder is better: it needs 6% fewer bits at GarmentCode Mid L=3 (516 bits) and 32–33% fewer at Fine on both datasets. These spline numbers come from a reduced search: 7 candidate breakpoints per corner-to-corner run, no knot refinement, and no joint optimization of control-point positions. The full search took about 17 minutes per panel and could favor the spline coder further.

These margins use the frame that contains every vertex (Q3), under which the 12-bit ledger is exact; the spline coder uses the same frame. With the released frame and the same 12-bit ledger, each margin differs by less than 0.4 points; charging that frame's 13-bit upper bound instead lowers each margin by 3–5 points (Appendix K).

Errors against the original geometry (Q2, first part). We measured errors against the original geometry on both validation sets; our reply to Reviewer Xe9K gives the details. On GarmentCode the original is the line, spline and arc edges of the specification files. In the industrial archive it is the stored vertex polyline without arc bulges, so this is not a comparison with the full CAD geometry. On validation, the 512-sample reference lies 0.004 and 0.002 mm from the original on average, and 0.59 and 0.40 mm from the original corners on average per panel. CornerMCQ's corner error is below the reference's at all 20 operating points of each dataset. The ranking of methods by mean error does not change, and CornerMCQ has the lowest error against the original in all 16 same-partition cells on both datasets.

The common rendering and corners. The common 512-position rendering does move away from the transmitted corners: on validation it lies 0.49 mm (GarmentCode) and 0.33 mm (industrial) from a vertex on average. This rendering serves only Chamfer, polygon validity and the main CAD audit, so that every codec is written the same way. The curve distance and the worst point are measured on each codec's own decode, which for CornerMCQ contains every transmitted vertex. The native-polyline audit writes that decode, and both parsers return every vertex exactly, at four operating points on all validation panels of both datasets.

Digitization noise. We added simulations of correlated digitization errors: a smooth displacement along the boundary plus corner offsets. There the released encoder's rate rises 8–32% (GarmentCode) and 3–15% (industrial) above clean, against 14–111% and 25–372% under i.i.d. jitter of the same σ. Both are simulations; our reply to Reviewer Xe9K has the details.

Manufacturing entities. CornerMCQ codes one closed boundary per panel; notches, drill holes, seam allowances, grain lines and inter-panel relations are outside its scope (Section 6). Notches lie on the boundary and could be added as positions along it. The revised Section 6 states that the code is a boundary representation, not a complete manufacturing file, and we do not claim manufacturing readiness.

AuthorsOpenReview ↗

Response to Reviewer uevt (2/2)

Held-out audit (Q2, second part). Following your request, we used each held-out test split for one additional audit, with the frozen encoders and released models. The plan was fixed before this access, and every outcome is reported. It measures the error against the original geometry and reruns the native-decode CAD readback. The same code first reproduced every validation number exactly. On the test splits, the reference's worst point lies within 1 mm of an original corner in 99.9% (GarmentCode) and 99.4% (industrial) of panels. CornerMCQ's mean corner error is below the reference's at all 20 operating points of each dataset, and in all 16 same-partition cells it has the lowest error against the original and the lowest corner error. At Coarse L=2 its curve distance to the original is 0.119 mm (GarmentCode) and 0.179 mm (industrial). At the four native-audit operating points, both parsers read every test panel back with 0.0 mm vertex discrepancy. Every statement that the plan fixed in advance keeps its direction, although some counts change; Appendix K lists all of them.

Bits outside the 12-bit range (Q3). All published rates charge 12 bits per vertex coordinate (Eq. 3). A refined corner can lie just outside the sample bounding box, and its index is sent unclipped. On validation this concerns 10.6% of the Coarse vertices on GarmentCode and 17.8% in the industrial archive, by at most 20 and 9 grid steps. A fixed-length field that holds every index needs 13 bits, which adds 2S bits per panel (Appendix B). At held-out Coarse L=2 the rate becomes 416 instead of 397 bits on GarmentCode and 334 instead of 322 in the industrial archive, still below 480. The same-partition controls reuse these vertices and receive the same 2S bits, so their comparisons with CornerMCQ do not change (unlike the classical comparison above).

A frame that contains every vertex. Taking the frame as the bounding box of the samples and all transmitted vertices keeps every index within 12 bits at no extra bit; we tested it on validation. The stream syntax and the decoder are unchanged, since the frame is read from the stream. On both validation sets every index then falls in [0, 4095], every bitstream has exactly the length of the 12-bit ledger, an independent decoder recovers every field (vertices within 7.4e-5 mm), and the grid step grows by at most 0.4%. The mean curve distance changes by −1.33% to +0.002% against the reference and falls against the original geometry. The held-out numbers in the paper use the released frame, so the 13-bit figures above apply to them.

Traversal direction and phase (Q3). The stream has no direction bit and no start index. Records follow the traversal of the input and start at its first corner, and the last segment closes on the first. A standalone decoder needs only the stream and the codebooks. It returns the closed polyline in the record order of the stream, starting at the first transmitted corner; the stream carries no canonical orientation. The decoder reads the frame as float32. The paper decoded with the encoder's float64 frame; on validation the difference moves vertices by at most 8.5e-5 mm (GarmentCode) and 6.0e-5 mm (industrial) and changes no comparison. On validation, a reversed input leaves the rate essentially unchanged but raises the Coarse L=3 curve distance by 6% (GarmentCode) and 20% (industrial). The chord frame is right-handed, and the codebooks were fitted on one handedness. A clockwise rule applied before encoding gives reversed and unreversed inputs the same curve distance, and changes the GarmentCode Coarse L=3 curve distance by a factor of 1.03; the released encoder does not apply it (Appendix K). With at least two detected corners, the partition does not depend on the start sample, except on two industrial panels with exactly tied turning angles. Panels with fewer than two corners use a fallback that does depend on it: none on GarmentCode and 14 of 1,623 industrial validation panels. Under a random cyclic shift, the vertex set and bit count stay the same for all 4,704 GarmentCode panel–partition pairs and for 6,428 of 6,492 industrial pairs. The 512-position rendering starts at the reference's first sample, which is not transmitted and is the same for every codec. The curve distance does not depend on this start.

Revisions. Appendix K adds the classical-coder comparison, the original-geometry analysis of both datasets, the multi-seed and correlated-noise results and the held-out audit. Appendices B and K describe the frame that contains every vertex. We removed the clause in Section 5.1 that attributed the high-rate error floor to the partition and the reference sampling. The revised description of the industrial archive states that about 37% of its validation boundaries are stored on the sew-line layer.

Thank you again; these questions made the evaluation more complete, and we are happy to clarify anything further.

Reviewer_rnrpOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper presents a method that try to compress the size of the sewing pattern used for garment making. The core idea is to only focus on only bending location.

Critical strengths
  • I think the goal of making sewing pattern more compactful could be an important topic if the potentail impact on downstream tasks and applications is clearly described..
Critical weaknesses
  • One of my biggest concern is that, it is unclear what exactly the motivation is. The main observation, where we should focus more on bending part instead of straightline part makes sense. But then why and when this brings troubles? It is not clearly stated. Existing sewing patterns are encoded in vector form which only requires to store control points. Therefore, I am not that sure why the compression is required. I see there might be suitable situation or scenario requires this kind of compression, but I think the paper fail to describe and motivate readers.
  • Although it is my personal view, but I think there is a huge chunk of writing are generated by LLM which is very difficult to follow.
    • e.g., many subsection titles reads LLM-ish.
    • the section content also contain a lot of LLM-ish texts without manual revision..
  • In the abstract, the authors mentioned "needs no neural network". I wonder why we in the first place need to discuss whether a neural network is needed or not? Did the author referring to compression using networks?
  • I think it is important to show the visual of the reconstruction instead of only providing quantitative tables. The reason is that it is also important to evaluate the sewing pattern reconstruction visually and check how the reconstruction quality affect the downstream tasks.
Questions for authors

Please check "Critical Weakness".

4 comments
AuthorsOpenReview ↗

Response to Reviewer rnrp (1/2)

Thank you for the review, and for noting that making sewing patterns more compact could be an important topic if its downstream impact is clearly described. We first state the claim, then answer each point in the order of the review.

The claim. CornerMCQ keeps a panel boundary, and its corners in particular, more accurately than fixed-rate codes while using fewer bits, because it sends the corners explicitly and spends bits only on curves. The two fixed-rate baselines in the paper spend 480 bits per panel: fixed-support codebooks, which apply the same kind of residual codebooks to equal-length pieces of the boundary, and PCA of the whole boundary. On held-out GarmentCode panels, at the Coarse partition with two codewords per curve, CornerMCQ uses 397 bits, 17% fewer, and its error is 5.6 and 6.5 times lower than these two codes. Its mean corner error is 0.16 mm, against 5–8 mm for them (validation, Appendix K). On the industrial archive it uses 322 bits, a third fewer, with 3.9 and 4.5 times lower error. Downstream, it keeps seam edges almost as well as the uncompressed boundary, while the 480-bit codes lose most of them (point 3).

  1. Why compress, and why not a parametric representation? The exchange files we work with do not come with one. Parametric specifications, such as GarmentCode's, describe a panel with about two dozen numbers, but in the industrial exchange files of our archive each boundary is a polyline with a median of 58 vertices, most of which barely turn, so a curve arrives as a long chain of short, nearly collinear segments. Turning such a polyline back into a parametric form is itself a way to code it, and our comparisons include such fits. At equal bits, CornerMCQ is more accurate than Bézier fitting at every rate point on both datasets, and classical spline rate–distortion coders need up to about 12% more bits at low rates (our reply to Reviewer uevt gives the full comparison, including higher rates). Simplifying the polyline between the same corners with Douglas–Peucker needs more bits as well: CornerMCQ uses 9–32% fewer for the same error. The paper therefore asks how a small bit budget should be spent on such a boundary, comparing representations at equal bits, as is standard in shape coding (Section 2).

  2. When do corners cause trouble? When the code does not send them. Uniformly spaced points put their error at the corners: even the 512-point reference used in the paper, only 0.004 mm from the original on average, has its worst point within 1 mm of an original corner in 99.7% and 99.1% of panels. Each part of the design addresses this (Section 5.2): with the same coder, a uniform partition raises the error 3 to 13 times on validation, and coding straight runs as curves costs about 20% more bits for almost no gain. The ASTM D6673 exchange format marks corner points apart from curve points, and an importer can pass splines through the curve points. In a proxy import that does this, missing corner flags rounded about half of the corners and bent nearly all straight edges; with the flags, no corner was rounded and few edges bent.

AuthorsOpenReview ↗

Response to Reviewer rnrp (2/2)

  1. Downstream effect: seam-edge recovery. A garment is assembled by stitching pairs of panel edges, as in GarmentCode. Berthouzoz et al. (SIGGRAPH 2013) extract seam edges from sewing-pattern contours by splitting them at sharp turns, using a 25° threshold. Following this principle, we split every decoded boundary at corners found by a turning-angle rule of the same kind and checked whether both edges of each ground-truth seam came back exactly (endpoints within 5 mm, no extra split). We used two such rules, each at 20 and 35 degrees, on GarmentCode validation (1,176 panels). The seams are given, not predicted, so the test isolates what the boundary code preserves.
Boundary usedBits per panelSeams mis-splitCorners recovered
Uncompressed 512-point reference–6–20%80–95%
CornerMCQ, Coarse L=2406 on average7–21%79–95%
Fixed-support codebooks48080–96%22–38%
Whole-boundary PCA48097–100%13–17%

Ranges span the four settings. Seams: the 1,326 seams whose four endpoints are corners, 348 of which join two panels. Corners: all 9,806 corner endpoints. With fewer bits on average, CornerMCQ stays within 1.5 points of the uncompressed boundary, while the 480-bit codes miss most corners and add thousands of false corners inside edges. The margin, fixed in advance at 10 points, was at least 27 points in every setting and with other codebook seeds. Figure 15 (Appendix K) shows an illustrative case, chosen by a fixed rule: on a front panel, the fixed-support code merges the side, armhole and shoulder into one smooth edge and loses a short seam at the top of the armhole, while CornerMCQ, with fewer bits on both panels (450 and 286, against 480 each), cuts it correctly.

  1. Return to pattern software. Files written from every audited codec read back unchanged through both tested parsers (Section 5.4), and CornerMCQ's own decode returns every transmitted vertex exactly, on validation and on both test splits.

  2. Visual results. The paper shows reconstructions in Figure 1(b, c), and in Figure 7 (Appendix E) on three held-out panels chosen by a fixed rule. The revision adds full-panel comparisons on GarmentCode (Figure 14, Appendix K): the median, 90th-percentile and worst panels, next to the fixed-support code and the same-partition controls. On the median panel, CornerMCQ has about twenty times lower mean curve distance with fewer bits.

  3. "Needs no neural network." The phrase referred to the comparison with learned quantizers such as VQ-VAE, which the tokenizers cited in Section 2 use. What we tested is that, with the partition and the bits per curve matched, CornerMCQ's K-means codebooks are more accurate than a tuned learned residual VQ-VAE at every held-out point. The revision removes the phrase, and the abstract names the comparison directly.

  4. Writing. We rewrote the introduction, which now states the problem as the number of bits a boundary needs for a given accuracy, and revised the wording of the method, results and limitations sections to make them easier to follow. All colon-style section titles were rewritten as plain titles; for example, "Corner-adaptive partition: vertices where the boundary bends" is now "Corner-adaptive partitioning", and "CAD return contract: write, parse, remeasure" is now "CAD return audit".

We thank you for pushing us to state the motivation and the downstream effect more clearly, and we would be glad to clarify anything further.

AuthorsOpenReview ↗

Further downstream evidence: seam lengths and cutting

Section 5.4 shows that a decoded boundary can be written to a DXF pattern file and read back unchanged. Two of the steps that follow are sewing the panels along their seam edges and cutting them from fabric. Point 3 tested whether the seam edges come back; here we test their lengths and the cutting.

Seam lengths. Each seam edge must keep its length to be sewn as designed. On the 4,472 curved edges between corners of the industrial validation panels, the decoded edge length misses a tolerance of max(1 mm, 0.5% of the length) on 7.3% of the edges for CornerMCQ, against 4.7% for the uncompressed reference, 13.5% for same-partition Bézier, 37.5% for Douglas–Peucker with the same corners and bits, and 61.9% and 86.9% for the two 480-bit codes. Douglas–Peucker replaces arcs by chords, so it shortens curved edges.

Cutting. We nested the decodes of each method on the fabric with the open-source nester sparrow (Gardeyn et al., 2025), placed each panel's true outline where its decode was placed, and measured how wide a gap between pieces is needed so that no two cut pieces overlap (Appendix K, Table 33).

Boundary given to the nesterGarmentCode, 301 markersIndustrial, 53 markers
CornerMCQ, Coarse L=21.2 mm3.1 mm
Same corners, Douglas–Peucker8.4 mm18.2 mm
Same partition, Bézier4.2 mm11.4 mm
Fixed-support codebooks, 480 bits6.7 mm21.9 mm
Whole-boundary PCA, 480 bits10.5 mm18.4 mm

The gap shown suffices for 95% of the markers. The three paired comparisons pass on both datasets. The abstract and Section 5.4 of the revised PDF now summarize the cutting result, and Appendix K.15 gives both tests in full.

Dear Reviewer rnrp,

Thank you for pointing us to the downstream side of the problem. Our team has visited garment factories to see how garments are made, and nesting the pieces on the fabric before cutting is one of the steps where material use matters most. Your comment reminded us of this step, and our follow-up added a nesting check: in 95% of the markers, the true pieces placed where the CornerMCQ decodes were nested need a gap of 1.19 mm on GarmentCode and 3.08 mm on industrial markers to avoid overlap, against 4.19 and 11.4 mm for Bézier on the same partition and 8.41 and 18.2 mm for Douglas–Peucker on the same corners (Section 5.4 and Appendix K.15).

The discussion period closes on November 18. We would appreciate knowing whether this and our earlier responses address your concerns, and we would welcome any further suggestions to improve the work.

Reviewer_Xe9KOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes CornerMCQ, a lightweight, corner-aware coding method for sewing-pattern boundaries that allocates bits according to local geometric complexity. The method first identifies and preserves salient corners, represents straight segments using their endpoints without additional curve bits, and encodes curved segments using multi-stage residual K-means codebooks in a normalized chord coordinate system. Unlike neural-network-based quantizers, the proposed method requires only a small set of codebooks fitted to a training corpus.

The authors evaluate CornerMCQ on the public GarmentCodeData dataset and a private industrial pattern archive. The experiments compare the proposed representation against fixed-support quantization, PCA, Bézier fitting, and a learned residual VQ-VAE under controlled bit budgets. The results demonstrate substantial improvements in rate–distortion performance, with additional ablations separating the effects of adaptive partitioning and curve coding. The paper also evaluates CAD file readback to investigate whether the reconstructed boundaries can be exported and parsed without introducing additional errors.

Critical strengths

1. A simple and effective geometry-aware coding strategy.

The paper presents a well-motivated approach to allocating coding capacity according to the geometric complexity of sewing-pattern boundaries. Explicitly preserving corners, assigning no additional curve bits to straight segments, and representing curved segments in normalized chord coordinates form a coherent and computationally lightweight framework. Although the individual techniques build on established contour coding and residual quantization methods, their integration is particularly suitable for structured sewing-pattern boundaries.

2. Strong rate–distortion results with carefully controlled comparisons.

The experiments demonstrate substantial improvements over fixed-support quantization and global PCA-based representations on both public and industrial datasets. More importantly, the same-partition comparisons against Bézier fitting, PCA with scalar quantization, and a learned residual VQ-VAE help isolate the contribution of the proposed curve coder. The partition ablations further demonstrate the importance of geometry-adaptive bit allocation. Reporting multiple distortion metrics, several operating points, and statistical comparisons strengthens the empirical evaluation.

Critical weaknesses

1. Sensitivity to noisy input boundaries.

CornerMCQ relies on accurate corner detection and straight-segment classification. Although Appendix K provides synthetic-noise experiments, the coding rate increases substantially under small perturbations, particularly for industrial patterns. The proposed threshold adjustment only partially mitigates this issue, and robustness to real-world digitization noise remains unverified.

2. Limited validation against original CAD geometry.

Reconstruction accuracy is measured against cleaned, 512-point resampled boundaries rather than the original CAD contours. Although the CAD readback and native-polyline audits are comprehensive, they do not quantify geometric errors introduced by preprocessing. This limits the evidence for preserving fine manufacturing-relevant details.

Questions for authors

1. How can CornerMCQ maintain stable coding rates under realistic digitization noise?

Appendix K shows that noise can substantially increase the coding rate. Could the authors discuss whether noise-aware corner detection or adaptive thresholds could improve robustness without sacrificing reconstruction accuracy?

1 comment
AuthorsOpenReview ↗

Response to Reviewer Xe9K

Thank you for the careful review, for recognizing the controlled comparisons, and for the concrete question on noise. Unless stated otherwise, the new analyses use the validation splits of both datasets, and the held-out numbers in the paper are unchanged. Full tables are in Appendix K of the revised PDF.

Noise: what we tested. Following your suggestion, we added two noise-aware variants to the released encoder. The first sets the straightness tolerance from a noise level estimated on each boundary, so it needs no knowledge of σ. The second also smooths the boundary before corner detection and the straightness test, and still codes the unsmoothed input samples. Their parameters were chosen on GarmentCode training panels only.

Pointwise jitter. With i.i.d. Gaussian jitter (five noise seeds, σ up to 0.5 mm), the second variant keeps the rate within 3% of the clean rate at Corner L=2 and at both Coarse points. For comparison, at σ = 0.5 mm the released encoder spends 95–122% more bits than on clean input at these points on GarmentCode and 339–410% in the industrial archive, where the threshold rule 0.3 + 4σ no longer helps. At Coarse L=2 and σ = 0.2 mm, for example, the variant codes GarmentCode panels with 409 bits at a mean curve distance of 0.241 mm, and the released encoder with 500 bits at 0.195 mm (406 bits and 0.124 mm without noise). At Fine, the widened tolerance codes gentle curves as straight runs, which brings the rate 3–27% below clean while the error rises.

Correlated errors. Independent jitter has no correlation between samples; we also tested strongly correlated errors, a smooth displacement along the boundary (5 mm smoothing kernel, correlation length about 10 mm), plus a 0.3 mm offset at each corner. At Coarse L=2 and L=3 (three seeds, σ = 0.1–0.5 mm), the released encoder's rate rises 8–32% above clean on GarmentCode and 3–15% in the industrial archive, against 14–111% and 25–372% under i.i.d. jitter of the same σ. The number of corners stays about the same; the extra bits come from straight runs that now bend slightly. The corner offset alone changes the rate by at most 0.1%. The noise-aware variants barely help here: their noise estimate responds to variation from one sample to the next and sees only 4–9% of the true σ, so the second variant returns the same result as the first. Since the released encoder's rate rises far less under these errors, the variants matter mainly for independent jitter. Both noise models are simulations.

Original geometry. Following your comment, we have now measured errors against the original geometry on both validation sets. On GarmentCode the original is the line, spline and arc edges of the public specification files. In the industrial archive it is the stored vertex polyline of each boundary. The dataset reader for the archive does not keep arc bulges, so this comparison is relative to that polyline, not to the full CAD geometry.

On average, the 512-sample reference lies 0.004 mm (GarmentCode) and 0.002 mm (industrial) from the original. At the original corners it lies 0.59 and 0.40 mm away on average per panel. The reference's worst point is within 1 mm of an original corner in 99.7% and 99.1% of panels, against 1.0% and 1.4% for a random point on the boundary.

CornerMCQ transmits explicit corner vertices, and its corner error is below the reference's at all 20 operating points of each dataset (0.10–0.30 mm on GarmentCode, 0.05–0.27 mm on the industrial archive). In the industrial archive about three quarters of the original corners are closer to CornerMCQ's decode than to the reference. Measuring against the original geometry changes no ranking by mean error, in any rate cell where several methods compete (17 on GarmentCode, 20 in the industrial archive). In all 16 same-partition cells, CornerMCQ has the lowest error against the original and the lowest corner error. The one-time audit on the test splits, described in our reply to Reviewer uevt, gives the same picture: CornerMCQ's mean corner error stays below the reference's at all 20 operating points of each dataset.

About 37% of the industrial validation boundaries are stored on the sew-line layer of the exchange format, not the cut-line layer. On the cut-line and sew-line layers separately, the ranking by mean error is unchanged, and CornerMCQ has the lowest error against the original and the lowest corner error in all 16 same-partition cells.

Revisions. Appendix K now reports the original-geometry analysis of both datasets and the multi-seed and correlated-noise results. The revised description of the industrial archive states that about 37% of its validation boundaries are stored on the sew-line layer.

We thank you again for these questions, which led to analyses that strengthen the paper, and we would be glad to clarify anything further.

Comments on the paper

3 comments
AuthorsOpenReview ↗

Summary of revisions and new evidence

We thank all three reviewers. The method and the frozen held-out results are unchanged. The new analyses are in Appendix K of the revised PDF and use the validation splits unless stated otherwise; the main text changes are listed at the end. Below, each group gives what we added and what it shows.

  1. Classical coding (Reviewer uevt). We implemented a vertex-based and a B-spline rate–distortion coder under the same bit ledger, with real bitstreams, and a Douglas–Peucker coder on the same corners. Up to about 410 bits per panel the classical coders need 4–12% more bits than CornerMCQ for the same error; near 430 bits they are roughly on par; from about 500 bits on, the spline coder needs fewer bits. For the same error, CornerMCQ needs 9–32% fewer bits than Douglas–Peucker. Sections 2 and 5.1 and the Limitations now state where each coder is better.

  2. Original geometry and the held-out audit (Reviewers Xe9K and uevt). Measured against the original geometry of both datasets, the ranking of methods by mean error does not change, and CornerMCQ's corner error is below that of the 512-sample reference at all 20 operating points of each dataset. A one-time further audit of both test splits, with the frozen encoders and a plan fixed in advance, keeps the direction of every statement that the plan fixed, and the native decode reads back from the CAD file with 0.0 mm discrepancy. A frame that contains every transmitted vertex makes the 12-bit ledger exact, and a separate decoder recovers every field from the stream; the held-out numbers keep the released frame and its 13-bit account (Appendix B).

  3. Digitization noise (Reviewer Xe9K). We added jitter over five noise seeds, correlated displacements, and two noise-aware encoder variants. Under jitter, one variant keeps the rate within 3% of the clean rate at the Coarse points, at some cost in accuracy; correlated errors raise the rate far less than jitter of the same size. Both noise models are simulations.

  4. Motivation and downstream effect (Reviewer rnrp). In industrial exchange files a boundary is a polyline with a median of 58 vertices, so curves arrive as chains of short segments; the introduction now states this. Pattern processing splits a boundary into seam edges at its corners (Berthouzoz et al., SIGGRAPH 2013). On GarmentCode validation, with ground-truth seams and two corner rules at two thresholds each, CornerMCQ at Coarse L=2 uses fewer bits on average and mis-splits about as many seams as the uncompressed boundary (7–21% against 6–20%), while the two 480-bit codes mis-split 80–96% and 97–100%. Figure 7 shows an illustrative case, chosen by a fixed rule. In a simulated import that follows the corner flags of ASTM D6673, about half of the corners are rounded when the flags are missing and none when they are kept; this test concerns the flags, not our codebooks. Figure 6 adds whole-panel reconstructions to Figures 1(b, c) and 5.

  5. Presentation (Reviewer rnrp). We rewrote the introduction to state the motivation and the downstream role of corners, replaced the colon-style section titles, removed the phrase "needs no neural network", and revised the method, results and limitations sections for readability. Section 4 now states that about 37% of the industrial validation boundaries are stored on the sew-line layer, and Section 5.1 no longer attributes the high-rate error floor to the partition and the reference sampling.

The replies to each reviewer give the details. We would be glad to answer any further questions.

AuthorsOpenReview ↗

A readability pass over the revised paper

We have uploaded a revised PDF in which, in addition to the changes listed in our summary, we made a further pass over the whole paper for readability. The abstract and the introduction now begin with how 2D panels are sewn into a 3D garment along seam edges cut at the corners, and only then introduce the method. Terms are used the same way throughout, each headline number names its operating point and data split, and long sentences were split. The method, the experiments and every number are unchanged, and the section, table and figure numbers cited in our replies still apply. We hope this makes the paper easier to read.

AuthorsOpenReview ↗

Revision note

We uploaded a revised PDF. The appendix now has ten more figures, which illustrate the code and plot results from its tables, and Appendix K is split into subsections K.1–K.15. Figure numbers from Figure 3 on have shifted; the figures cited in our replies are now Figure 7 for the former Figure 5, Figure 14 for the former Figure 6, and Figure 15 for the former Figure 7. The method, the experiments, and every number are unchanged.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.