---
title: Polygon Sequence Tracer (PST)
url: https://www.emergentmind.com/topics/polygon-sequence-tracer-pst
type: topic
---

# Polygon Sequence Tracer (PST)

Polygon Sequence Tracer (PST) most specifically denotes the polygon-refinement and vertex-tracing stage introduced in HoliTracer for large-size remote sensing imagery, where a reconstructed polygon contour is processed as an ordered sequence, iteratively corrected by offset regression, and reduced to explicit vertices by learned classification [2507.16251]. In a broader and less standardized sense, the same phrase has also been used as a conceptual description for polygon-tracking-through-time in multi-object tracking, for sequential polygon generation in referring image segmentation, and for attribute transport across polygon mesh sequences, while the acronym “PST” is also used in unrelated areas such as 4D self-duality [2111.01606; 2302.07387; 1406.6786; 1401.7834]. The term therefore names both a concrete module and a wider sequence-centric view of polygonal computation.

## 1. Terminology and scope

The literature presents several distinct uses of the label “PST,” and these uses are not interchangeable. In HoliTracer, PST is an explicit module name. In PolyTrack, it is a conceptual description of the method’s polygon-tracking behavior rather than the paper’s formal algorithmic name. In PolyFormer and in the mesh-sequence UVW-transfer method, the designation is interpretive rather than canonical. By contrast, PSTV and the Pasti–Sorokin–Tonin formalism are separate acronym expansions with different problem settings.

| Source context | Meaning of PST | Status in source |
|---|---|---|
| HoliTracer [2507.16251] | final vectorization stage that refines a reconstructed polygon and predicts vertices | explicit module name |
| PolyTrack [2111.01606] | polygon-tracking-through-time pipeline using center detection, polygons, and temporal offsets | conceptual description; the paper uses **PolyTrack** |
| PolyFormer [2302.07387] | sequential polygon generation for referring image segmentation | PST-style interpretation |
| Mesh-sequence UVW transfer [1406.6786] | tracing texture coordinates through polygon mesh sequences | precursor or specialized variant |
| PSTV [2401.08242] | Polygonal Sequence-driven Triangulation Validator | different algorithm and acronym expansion |
| 4D self-duality [1401.7834] | Pasti–Sorokin–Tonin formalism | unrelated acronym usage |

This distribution of meanings indicates that “Polygon Sequence Tracer” is best treated as a domain-specific descriptor rather than a universally standardized algorithm name. In the remote-sensing literature, however, the HoliTracer module gives the term a concrete and technically specific instantiation.

## 2. Sequence-centric polygon processing as a recurring formulation

Several papers instantiate a common computational pattern in which polygonal structure is not treated as a static output but as a sequence that must be generated, propagated, or refined. PolyTrack detects object centers with heatmaps, predicts a coarse polygon with a fixed number of vertices, and traces object identities across consecutive frames by learned center offsets and a Kalman-filtered motion model [2111.01606]. PolyFormer formulates referring image segmentation as sequence-to-sequence polygon generation, where a Transformer decoder autoregressively emits box corners, polygon vertices, separator tokens, and an end token [2302.07387]. The mesh-sequence UVW-transfer method backtraces each vertex with its motion vector, projects to the closest location on the previous mesh, and transfers UVWs even when topology changes [1406.6786]. HoliTracer’s PST instead begins from a reconstructed polygon and performs iterative point correction followed by vertex selection [2507.16251].

This suggests a shared abstraction: polygonal data are represented as ordered states whose temporal or autoregressive dependencies are part of the model rather than an afterthought. The exact state varies by task. In tracking, it is an object center plus polygon support; in referring segmentation, it is a tokenized vertex sequence; in mesh processing, it is a transported surface attribute; in large-size remote sensing vectorization, it is a regularized contour that still requires geometric correction and dominant-vertex extraction.

The same abstraction also exposes the major design choices. One may transport geometry through time by motion vectors and nearest-surface projection, as in mesh sequences; predict temporal offsets between framewise object centers, as in MOTS; or decode vertices autoregressively from multimodal context, as in RIS. HoliTracer’s PST occupies a different point in this design space: it assumes a polygon already exists and concentrates on local refinement and vertex discrimination.

## 3. PST in HoliTracer: architecture and algorithm

In HoliTracer, PST is the third component of a three-stage pipeline comprising Context Attention Net (CAN), Mask Contour Reformer (MCR), and Polygon Sequence Tracer (PST). CAN produces the semantic segmentation mask on large-size remote sensing imagery through a multi-scale image pyramid and local-to-global attention; MCR converts the mask into a reconstructed polygon contour \(R = [r_1, r_2, \dots, r_n]\); PST then refines that contour into the final vector result by offset regression and vertex classification [2507.16251]. The motivation is explicit: contours extracted from masks are dense, noisy, and irregular, with too many boundary points and no compact organization into a high-quality polygon.

PST receives the reconstructed polygon \(R\) and processes it “as a sequence.” For each polygon point \(r_i=(x_i,y_i)\), it samples encoder features around that coordinate, yielding a feature vector \(\mathbf{z}_i\). The feature and coordinate are concatenated as \([\mathbf{z}_i, x_i, y_i]\) and passed to a transformer-based offset regressor. The regressor predicts an offset correction
\[
\hat{o}_i = (\Delta x_i, \Delta y_i),
\qquad
r'_i = r_i + \hat{o}_i .
\]
The refinement is iterative and is described as being inspired by DeepSnake:
\[
R^{(k)} = R^{(k-1)} + \hat{O}^{(k)},
\qquad
\hat{O}^{(k)} = [\hat{o}_1^{(k)}, \hat{o}_2^{(k)}, \dots, \hat{o}_n^{(k)}] .
\]

After correction, PST computes angle features at each point using neighboring points at distances \(s=1,2,3\) with periodic boundary conditions for closed polygons:
\[
\theta_i^{(s)} =
\arccos\left(
\frac{\vec{v}_{i-s,i} \cdot \vec{v}_{i,i+s}}
{\|\vec{v}_{i-s,i}\| \, \|\vec{v}_{i,i+s}\|}
\right),
\qquad s=1,2,3,
\]
with
\[
\vec{v}_{i-s,i} = r'_i - r'_{i-s},
\qquad
\vec{v}_{i,i+s} = r'_{i+s} - r'_i .
\]
These angular cues are central because the method explicitly assumes that smaller angles indicate a higher likelihood of vertices. PST then concatenates corrected coordinates, image features, and the angle features into \([\mathbf{z}'_i, r'_i, \theta_i^{(1)}, \theta_i^{(2)}, \theta_i^{(3)}]\), and a transformer-based vertex predictor outputs \(\hat{p}_i \in [0,1]\), the probability that point \(i\) is a vertex.

The module is designed to function within a holistic large-image pipeline rather than a patch-stitching workflow. The paper states that HoliTracer avoids patch-based vectorization at inference, so PST receives polygons derived from globally contextual masks rather than patch-fragmented masks. The same PST mechanism is applied per polygon sequence after contour reconstruction, allowing use across buildings, water bodies, and roads.

## 4. Objectives, geometric priors, and empirical evidence

PST is trained with three losses: an offset regression loss, a vertex-classification loss, and an angle penalty. Offset supervision is defined by
\[
o_i = g'_i - r_i,
\]
where \(g'_i\) is the aligned ground-truth point corresponding to \(r_i\). The offset loss is Smooth \(L1\):
\[
\mathcal{L}_{\text{off}} = \sum_i
\begin{cases}
0.5(\hat{o}_i-o_i)^2, & \text{if } |\hat{o}_i-o_i|<1,\\
|\hat{o}_i-o_i|-0.5, & \text{otherwise}.
\end{cases}
\]
Vertex prediction uses binary cross-entropy,
\[
\mathcal{L}_{\text{vert}} =
-\sum_i
\left[
c_i \log(\hat{p}_i) + (1-c_i)\log(1-\hat{p}_i)
\right],
\]
and the angle term encourages small \(\theta_i^{(1)}\) for true vertices and sufficiently large \(\theta_i^{(1)}\) for non-vertices:
\[
\mathcal{L}_{\text{angle}} = \sum_i
\begin{cases}
\max(0,\theta_i^{(1)}-\theta_{\text{threshold}}), & \text{if } c_i=1,\\
\max(0,\theta_{\text{threshold}}-\theta_i^{(1)}), & \text{if } c_i=0.
\end{cases}
\]
The total objective is
\[
\mathcal{L} =
\lambda_1 \mathcal{L}_{\text{off}} +
\lambda_2 \mathcal{L}_{\text{vert}} +
\lambda_3 \mathcal{L}_{\text{angle}},
\]
and the paper states that all loss hyperparameters are set to \(1\) [2507.16251].

The decoding strategy is direct. The method does not describe beam search or graph optimization; instead, output is obtained from iterative offset regression followed by pointwise vertex probabilities. The angle threshold is an important control variable. The reported ablation on WHU-building shows that removing angle features and angle loss yields PoLiS \(3.91\) and CIoU \(78.27\); using angle features only gives PoLiS \(3.82\) and CIoU \(79.66\); angle loss with thresholds \(90\), \(135\), and \(180\) gives \((3.72,78.27)\), \((3.63,82.30)\), and \((3.72,81.28)\), respectively, so the best setting is \(\theta_{\text{threshold}} = 135^\circ\) [2507.16251].

The contribution of PST is isolated by several ablations. On WHU-building, baseline contour extraction using TC89-KCOS gives PoLiS \(3.83\), CIoU \(18.47\), AP \(58.75\), and IoU \(91.55\); baseline \(+\) DP gives PoLiS \(4.02\), CIoU \(60.32\), and AP \(58.42\); baseline \(+\) PST gives PoLiS \(3.63\), CIoU \(82.30\), AP \(61.07\), and IoU \(91.60\). A separate comparison shows HRNet \(+\) DP at PoLiS \(6.10\) and CIoU \(50.01\), HRNet \(+\) PST at \(5.91\) and \(61.51\), CAN \(+\) DP at \(4.02\) and \(60.32\), and CAN \(+\) PST at \(3.63\) and \(82.30\). These experiments indicate that PST materially improves vector quality over both raw contours and Douglas–Peucker simplification, and that the gain is not tied exclusively to CAN [2507.16251].

Implementation details further delimit the method. The encoder backbone is Swin-L with Skysense weights; PST uses segmentation-encoder features with frozen weights during PST training; the optimizer is Adam with learning rate \(1\times 10^{-2}\); the framework is PyTorch; and the reported hardware is four NVIDIA A100 GPUs. HoliTracer also specifies MCR simplification tolerance \(\epsilon = 5\), interpolation distance \(l = 25\) for buildings and \(l = 50\) for water bodies and roads, and multi-scale pyramid scales \(\{1,3,6\}\) for buildings and \(\{1,5,10\}\) for water bodies and roads [2507.16251].

## 5. Related sequence-based polygon methods

**PolyTrack.** PolyTrack is a multi-object tracking and segmentation method that deliberately occupies a middle ground between bounding-box tracking and full mask-based tracking. Objects are detected by center heatmaps, where the paper uses elliptical Gaussians during training and defines the center not as the center of the bounding box but as the center of gravity of the polygon. Rough segmentation is represented by a bounding polygon with \(32\) vertices. The polygon is obtained by taking the instance bounding box, drawing rays at regular angular intervals toward the object center, and keeping the first intersection of each ray with the segmentation mask; the network then regresses the vertices as offsets from the object center. For tracking, the method takes the current image \(I(t)\), the previous image \(I(t-1)\), and a previous-frame heatmap \(H(t-1)\), and predicts a tracking offset with target
\[
(x_{\text{off}}, y_{\text{off}}) = (x_{t-1}, y_{t-1}) - (x_t, y_t).
\]
Inference associates detections to tracklets by greedy matching, creates new IDs for unmatched detections, freezes unmatched tracks, and terminates them after a maximum age of \(32\) frames. An Unscented Kalman Filter is added to reduce ID switches by propagating state with position, velocity, and acceleration. The method is evaluated on MOTS and KITTIMOTS, and the paper concludes that it is a promising speed/accuracy compromise rather than a state-of-the-art dense-mask winner; it works better for cars than for pedestrians, and standard MOTS metrics remain unfavorable to coarse polygons because they reward fine masks [2111.01606].

**PolyFormer.** PolyFormer reformulates referring image segmentation as sequential polygon generation. A target object is represented by one or more polygons whose vertices are ordered clockwise, with the starting vertex chosen as the one closest to the top-left image corner. A target sequence contains \(\langle BOS\rangle\), two coordinate tokens for bounding-box corners, polygon vertices, optional \(\langle SEP\rangle\) tokens between polygons, and \(\langle EOS\rangle\). The architecture combines a Swin Transformer image encoder, a BERT text encoder, a multimodal Transformer encoder, and a regression-based Transformer decoder. At each decoding step, a class head predicts whether the next token is \(\langle COO\rangle\), \(\langle SEP\rangle\), or \(\langle EOS\rangle\), while a coordinate head predicts continuous \((x,y)\) coordinates by regression rather than coordinate quantization. The model uses a \(64\times 64\) coordinate embedding codebook with bilinear interpolation, polygon augmentation, AdamW, polynomial learning-rate decay, pretraining on REC for \(20\) epochs, and fine-tuning for \(100\) epochs on RIS and REC. On validation sets, PolyFormer-L reaches \(76.94\) mIoU on RefCOCO, \(72.15\) on RefCOCO+, and \(71.15\) on RefCOCOg, with absolute improvements of \(+2.48\), \(+5.40\), and \(+4.52\), and it achieves competitive \(61.5\) \(\mathcal{J}\mathcal{F}\) on Ref-DAVIS17 without video fine-tuning. The paper therefore supplies a strong example of polygon tracing as autoregressive geometric sequence modeling rather than dense-mask prediction [2302.07387].

**Texture-coordinate propagation on polygon mesh sequences.** The 2014 mesh-sequence method generates temporally coherent 3D texture coordinates for arbitrary polygon mesh sequences with changing topology. For mesh \(M_i\) and vertex \(j\), it backtraces a position
\[
p = VPos_{M_i,j} - VVel_{M_i,j},
\]
finds
\[
L = \text{ClosestLocationOn}(M_{i-1}, p),
\]
and sets
\[
VTex_{M_i,j} = VTex(L).
\]
Locations on a mesh are represented by barycentric coordinates on a triangle, so UVWs are interpolated continuously from the previous mesh. The method does not require one-to-one vertex correspondence, and it was implemented in the commercial plugins emPolygonizer and emTopolizer for meshed implicit surfaces, cached mesh sequences, simulation outputs, Marching Cubes-based pipelines, and particle or smoothed-particle hydrodynamics-style meshing workflows. The paper recommends \(32\)-bit float UVWs because half-floats accumulate too much error over long sequences, notes that some jitter and temporal drift may occur, and suggests a BFECC-style backward-forward correction as a possible improvement. In the present context, it is best regarded as a specialized predecessor for tracing surface attributes through polygon sequences [1406.6786].

## 6. Misconceptions, adjacent methods, and limitations

A recurrent misconception is that “PST” denotes one unique algorithm across fields. The sources do not support that interpretation. In PolyTrack, PST is not presented as a separate distinct algorithm but as the polygon-tracing behavior embodied by PolyTrack. In 4D self-duality, PST refers instead to the Pasti–Sorokin–Tonin formalism, where a generalized PST action is unified with an auxiliary tensor field \(V_{mn}\); the salient structural point is that the PST gauge transformations do not act on \(V_{mn}\), which preserves the gauge symmetry structure while allowing \(O(2)\)-invariant nonlinear interactions [2111.01606; 1401.7834].

A second source of confusion is the presence of adjacent methods whose names also invoke polygonal sequences or tracing. PSTV, the Polygonal Sequence-driven Triangulation Validator, is an a posteriori verification algorithm for 2D triangulations. It incrementally constructs a polygonal sequence, uses an edge map for \(O(1)\) adjacency lookup after \(O(n_t)\) preprocessing, checks local validity by orientation and intersection tests, verifies the Delaunay property with incircle predicates, and uses floating-point filters with exact rational fallback in less than \(0.1\%\) of many computations. Its function is validation and local correction by edge flipping, not polygon refinement or polygon generation [2401.08242]. Likewise, the gridhopping method for extracting polygons from signed distance bounds has been described as PST-style in interpretation, but the paper itself names the method gridhopping. It combines sphere tracing and Marching Cubes, achieves \(O(N^2 \log N)\) complexity for a polygonization grid with \(N^3\) cells, and produces exactly the same meshes as enumeration or continuation when the same local polygonizer is used [2111.05778].

Within polygon-tracing applications proper, the limitations are domain-specific. HoliTracer indicates that if the angle threshold is too low or too high, PST retains too few or too many vertices; semantic metrics can slightly decrease even when vector quality improves; roads remain challenging; and errors in upstream segmentation or contour reconstruction can propagate into the final vector output. PolyTrack identifies a different mismatch: standard MOTS metrics such as MOTSA and sMOTSA favor fine masks, so a method that intentionally predicts coarse polygons is not intended to beat dense-mask MOTS methods on fine-grained segmentation accuracy. These limitations do not invalidate polygon sequence tracing; rather, they define the trade-off under which it is selected: compact geometric structure, sequential dependence, and lower representation cost in exchange for coarser boundary detail or stronger dependence on upstream geometric regularization [2507.16251].

Source: https://www.emergentmind.com/topics/polygon-sequence-tracer-pst