CrossGen: Learning and Generating Cross Fields for Quad Meshing

Several methods utilize optimization to create cross fields. Mixed-Integer Quadrangulation (MIQ) (Bommes et al., 2009) initializes the cross field by aligning it with one edge of a triangular patch and subsequently applies a mixed integer optimization to ensure consistency of the cross fields across adjacent patches. While this method effectively preserves local consistency of the cross field, it fails to ensure global consistency across the entire 3D model. Power Fields (Knöppel et al., 2013) and PolyVectors (Diamanti et al., 2014) introduce convex smoothness energies for generating smooth N-RoSy fields. Power Fields (Knöppel et al., 2013) achieves global optimality through a convex formulation, but relies on a nonlinear transformation that can introduce additional singularities and geometric distortion. Instant Meshes (IM) (Jakob et al., 2015) and its variants (Huang et al., 2018; Pietroni et al., 2021) employ extrinsic energy to guide cross field optimization, enabling the generation of visually high-quality fields. However, their strong reliance on local information often undermines global consistency and leads to undesirable singularities.

Most of the above methods prioritize cross field smoothness at the expense of accurate alignment with principal curvature directions. Ideally, a high-quality cross field should strike a balance between smoothness and faithful alignment to principal curvature directions or sharp features. To this end, NeurCross (Dong et al., 2025) jointly optimizes the cross field and a neural signed distance field (SDF), where the zero-level set of the SDF serves as a proxy for the input surface. NeurCross (Dong et al., 2025) outperforms existing methods in terms of robustness to surface noise and geometric fluctuations, and alignment with curvature directions and sharp feature curves. However, its optimization process is computationally intensive, limiting its applicability in real-time or interactive scenarios. Moreover, all of these methods require per-shape optimization and thus not generalizable to new shapes. Our method, in contrast, is data-driven and therefore generalizable. It can generate cross fields for new shapes without the need for per-shape optimization.

As a pioneering effort in utilizing deep learning for generalized generation, Dielen et al. (2021) introduces a fully automated, learning-based approach for predicting direction fields. By combining the information from a global network encoding the global semantics, a local network encoding the local geometry information, and a set of local reference frames indicating the local triangle position and rotation, it can infer a frame field in a feed-forward manner. However, this method relies on a global network (i.e., PointNet (Qi et al., 2017)) to encode the global domain knowledge of a single category (i.e., human-like body priors of quad meshes). Therefore it remains open as how to extend this method to shapes of different categories and even unseen categories. This method also assumes shapes are aligned in a canonical space, thus even small non-rigid changes, such as head rotations in human models, may disrupt the predictions.

The more recent work Point2Quad (Li et al., 2025) proposes a learning-based approach to extract quad meshes from point clouds by generating quad candidates via $k$-NN grouping and filtering them using an MLP-based classifier. While promising, this candidate-driven approach requires post-processing heuristics and may produce non-watertight or non-manifold meshes. Furthermore, this method tends to produce extra undesired singularities, as shown by our test. In contrast, our method employs a sparse, locality-aware encoder that captures intrinsic geometric features without relying on global semantics. This design enables robust generalization across diverse shape categories and resilience to non-rigid deformations or pose variations, without requiring canonical alignment.

CrossGen adopts an autoencoder network architecture that takes a point-cloud surface as input and outputs the SDF of the input shape and a cross field on it. In order to ensure generalization across diverse shapes, we propose to use a shallow encoder based on a convolutional neural network (CNN) that focuses on local shape information without the need for learning global shape semantics. We then adopt a deep CNN decoder that takes into consideration of global geometry context for smooth and globally consistent generation of both SDFs and cross fields. We will shortly explain how to achieve these capabilities of learning local or global information using different ranges of the receptive field of a CNN.

Our design of using a local encoder and a global decoder is crucial for network generalization. On the one hand, shapes across different categories often appear globally different but share local similarities. For example, different local parts such as the chairs and the table may share similar local geometry, as illustrated in Fig. 4. Using a local geometry encoding mechanism helps to capture these local similar patterns, improving generalization across these diverse categories as demonstrated in (Mittal et al., 2022; Rombach et al., 2022). On the other hand, geometry decoding necessitates the integration of global geometric context to ensure smoothness and consistency in predictions, thereby enabling the learning of a more generalized representation.

We adopt point clouds as the input surface format, which conveniently accommodates raw point-cloud surface as we as other surface representations, since any other surface representation can be converted to a point-cloud representation with a simple uniform sampling process. The resulting input to the encoder $\mathcal{E}$ is a 3D point set. Let the input point set be denoted by $\mathcal{P}=\{\boldsymbol{p}\mid\boldsymbol{p}\in\mathbb{R}^{3}\}$, where each point $\boldsymbol{p}$ is assumed to be associated with its corresponding surface unit normal vector $\boldsymbol{n}_{\boldsymbol{p}}\in\mathbb{R}^{3}$ as an input feature. These surface normal vectors can be extracted from the original continuous surface if provided as input, or estimated using Xu et al. (2023) for a raw point-cloud surface. These points are initially quantized into the vertices of a $256^{3}$ high-resolution cubic grid to ensure that the geometric details are well captured. This quantized data is subsequently encoded into 16-dimensional latent embeddings by a linear projection layer and fed into the encoder $\mathcal{E}$, which uses a sparse convolutional neural network (CNN) architecture (Choy et al., 2019) – a crucial choice for efficiently processing high-resolution 3D data while significantly reducing computational overhead.

The encoder consists of a sequence of convolutional layers and residual blocks that progressively downsample the input representation. As data propagates through the network, with the successive spatial resolutions of the feature maps being $256^{3}$, $128^{3}$, $64^{3}$, $32^{3}$, and $16^{3}$, and corresponding feature dimensions being 16, 32, 64, 128, and 128. Each downsampling step uses a single convolutional layer to ensure a small receptive field and encourage the encoding of local geometric structures rather than global semantic features. At the network bottleneck, i.e. latent space, the 3D shape is compactly represented as a set of latent patch descriptors $\mathcal{F}=\{\boldsymbol{f}\mid\boldsymbol{f}\in\mathbb{R}^{m}\}$, where $m$ ($m=128$ by default) denotes the feature dimensionality, as shown in Fig. 3 (b).

The decoder $\mathcal{D}$, which also utilizes the sparse CNN architecture (Choy et al., 2019), comprises a sequence of convolutional upsampling layers and residual blocks, progressively increasing the spatial resolution of the feature maps to $16^{3}$, $32^{3}$, and $64^{3}$, with the corresponding feature dimensions decreasing from 128 to 64 and then to 32. This process yields a high-resolution feature grid, as shown in Fig. 3 (c). At each resolution level, multiple convolutional layers are employed to expand the receptive field, enabling the propagation of geometric information to neighboring regions and enhancing feature aggregation for accurate SDF and cross field decoding.

The receptive field (RF) of a CNN describes how much context of the input a network can “see” when making predictions at a given location. It defines the geometric context available for encoding the input point cloud surface and predicting the output, i.e. SDFs or cross fields. As shown in the inset for 2D illustration, smaller receptive fields focus on local details, while larger ones capture broader shape context. As discussed in Section 3.1, although shapes from different categories may vary globally, they often share local geometric similarities. To leverage this, we employ a small receptive field in the encoder to focus on local geometry (see Fig. 4). Meanwhile, we adopt a large receptive field in the decoder to aggregate broader context, which promotes smoothness and global coherence in the predicted cross fields.

Subsequent to the construction of our high-resolution volumetric feature representation (see Fig. 3 (c)), we employ trilinear interpolation to extract two 32-dimensional feature vectors: one at the input points $\mathcal{P}=\{\boldsymbol{p}\mid\boldsymbol{p}\in\mathbb{R}^{3}\}$ for cross field prediction, and another at query points $\mathcal{Q}=\{\boldsymbol{q}\mid\boldsymbol{q}\in\mathbb{R}^{3}\}$ for SDF prediction. The query set $\mathcal{Q}$ is sampled from a thin shell surrounding the zero-level set of the SDF, composed of points whose ground truth SDF magnitudes fall below a prescribed threshold $\epsilon$ (we use $\epsilon=0.02$ by default). Note that $\mathcal{P}$ constitutes a proper subset of $\mathcal{Q}$.

These interpolated features are fed into two distinct MLP decoders (see Fig. 5). One MLP decoder, $\mathcal{M}_{\text{cf}}(\boldsymbol{p})\in\mathbb{R}^{3}$, maps the feature vector at point $\boldsymbol{p}$ to one cross field direction, while another, $\mathcal{M}_{\text{sdf}}(\boldsymbol{q})\in\mathbb{R}$, maps the feature vector at point $\boldsymbol{q}$ to a SDF value. In essence, $\mathcal{M}_{\text{cf}}$ decodes the interpolated feature vector at input points $\mathcal{P}$ into directional cross field vectors, while $\mathcal{M}_{\text{sdf}}$ interprets features in the thin shell $\mathcal{Q}$ into SDF values.

In our pipeline, both the encoder $\mathcal{E}$ and decoder $\mathcal{D}$ adopt the sparse CNN architecture (Choy et al., 2019) for good computational and memory efficiency. In the encoder $\mathcal{E}$, empty voxels are directly removed during the downsampling process, keeping only the occupied regions for efficient feature extraction. During upsampling by the decoder $\mathcal{D}$, newly generated fine-grained sub-voxels, denoted as $\mathcal{V}$, are retained and marked as occupied only if they intersect with the thin shell region surrounding the zero-level set of the SDF; the rest are discarded.

To supervise voxel occupancy prediction at each resolution level of the output of the decoder $\mathcal{D}$, we introduce an occupancy loss $\mathcal{L}_{\text{o}}$, defined as the discrepancy between the predicted occupancy values $\mathcal{D}_{\text{o}}(\boldsymbol{v})$ and the ground truth occupancy labels $\mathcal{G}_{\text{o}}(\boldsymbol{v})$.

where BCE(·) is the binary cross entropy, that is:

Given a surface point $\boldsymbol{p}$, the cross field branch $\mathcal{M}_{\text{cf}}$ predicts one direction vector of the cross field at $\boldsymbol{p}$, denoted by $\mathcal{M}_{\text{cf}}(\boldsymbol{p})$. This predicted vector $\mathcal{M}_{\text{cf}}(\boldsymbol{p})$ needs to be constrained to lie within the tangent plane at $\boldsymbol{p}$. Hence, we project $\mathcal{M}\text{cf}(\boldsymbol{p})$ onto the tangent plane defined by $\boldsymbol{p}$ and its corresponding GT unit normal vector $\boldsymbol{n}_{\boldsymbol{p}}$.

As illustrated in the inset figure, we consider a local region centered at $\boldsymbol{p}$. Using the unit normal $\boldsymbol{n}_{\boldsymbol{p}}$, we project the predicted vector onto the tangent plane, resulting in $\bar{\boldsymbol{\alpha}}_{\boldsymbol{p}}$, a direction vector that lies within the tangent plane at $\boldsymbol{p}$. That is

We then normalize vector $\bar{\boldsymbol{\alpha}}_{\boldsymbol{p}}$ to obtain the unit vector $\boldsymbol{\alpha}_{\boldsymbol{p}}$, which represents one cross field direction at point $\boldsymbol{p}$ predicted by our network. The second direction $\boldsymbol{\beta}_{\boldsymbol{p}}$ is computed as $\boldsymbol{\beta}_{\boldsymbol{p}}=\boldsymbol{\alpha}_{\boldsymbol{p}}\times\boldsymbol{n}_{\boldsymbol{p}}$. Thus, the cross field at point $\boldsymbol{p}$ predicted by our CrossGen is given by the pair $(\boldsymbol{\alpha}_{\boldsymbol{p}},\boldsymbol{\beta}_{\boldsymbol{p}})$, both of which are unit vectors lying in the tangent plane.

During training, to learn the cross field $(\boldsymbol{\alpha}_{\boldsymbol{p}},\boldsymbol{\beta}_{\boldsymbol{p}})$, we provide supervision by comparing it against the ground truth cross field $(\boldsymbol{\mu}_{\boldsymbol{p}},\boldsymbol{\nu}_{\boldsymbol{p}})$. However, the exact correspondence between the two pairs is ambiguous due to their rotational symmetry. Following Dong et al. (2025), it suffices to require that one vector (i.e. $\boldsymbol{\alpha}_{\boldsymbol{p}}$) from  $(\boldsymbol{\alpha}_{\boldsymbol{p}},\boldsymbol{\beta}_{\boldsymbol{p}})$ be aligned, being parallel or perpendicular, to both vectors in $(\boldsymbol{\mu}_{\boldsymbol{p}},\boldsymbol{\nu}_{\boldsymbol{p}})$. It can be proved that this requirement is fulfilled if and only if $\left\|\boldsymbol{\alpha}_{\boldsymbol{p}}\cdot\boldsymbol{\mu}_{\boldsymbol{p}}\right\|+\left\|\boldsymbol{\alpha}_{\boldsymbol{p}}\cdot\boldsymbol{\nu}_{\boldsymbol{p}}\right\|$ attains its minimum value of 1 (Dong et al., 2025). Hence, the cross field loss term can be written as:

where $\left\|\cdot\right\|$ denotes the absolute value.

The SDF loss at point $\boldsymbol{q}\in\mathcal{Q}$, measuring the discrepancy between the predicted value $\mathcal{M}_{\text{sdf}}(\boldsymbol{q})$ and the ground truth SDF $\mathcal{G}_{\text{sdf}}(\boldsymbol{q})$, is defined as:

To prevent high variance and stabilize the latent space $\mathcal{F}=\{\boldsymbol{f}\mid\boldsymbol{f}\in\mathbb{R}^{128}\}$, we incorporate a KL divergence regularization term $D_{\text{KL}}$ (Kingma and Welling, 2013), following (Mo et al., 2019; Rombach et al., 2022). This constrains the latent space distribution $\mathcal{N}(\mathbb{E}(f),\sigma^{2}(f))$ toward a standard normal distribution $\mathcal{N}(0,1)$. Both empirical evidence and established theoretical results (Van Den Oord et al., 2017; Yan et al., 2022; Mittal et al., 2022; Kingma and Welling, 2013) demonstrate that this distributional constraint ensures a topologically coherent and smooth latent space (Mo et al., 2019; Rombach et al., 2022), substantially reducing information entropy during continuous shape parametrization transformations. Hence, we define the latent space regularization as follows:

where $\mathbb{E}(\cdot)$ denotes the mean and $\sigma^{2}(\cdot)$ the variance.

Finally, the overall training loss $\mathcal{L}$ is defined as the sum of the occupancy loss, cross field loss, SDF loss, and the latent space regularization term:

where $\lambda_{\text{o}}=1,\lambda_{\text{cf}}=1,\lambda_{\text{sdf}}=1,\lambda_{\text{kl}}=1e^{-6}$ denote the corresponding weights of different loss terms to balance and stabilize the training process.

We now discuss how to use the cross field predicted by CrossGen to produce a quad mesh of the given shape. Since the input to CrossGen is a discrete point-cloud surface but existing quad mesh extraction methods require a mesh surface to operate on, we use the SDF predicted by CrossGen to provide such a continuous surface for quad meshing. Specially, we obtain a triangle mesh surface of the zero-level set of the predicted SDF using the Marching Cubes method (Lorensen and Cline, 1987). Then we compute the center points of the triangle faces and query their corresponding features from the high-resolution grid (Fig. 3 (c)). These features are then passed through the cross field branch to predict the cross fields. Finally, the predicted cross field and reconstructed surface mesh are used together to extract a field-aligned quad mesh. If the input shape is provided as a triangle mesh, we directly perform quad mesh extraction using the predicted cross field, without needing to reconstruct the surface through the SDF branch.

For quad mesh extraction, we implement a two-step pipeline similar to Dong et al. (2025); Bommes et al. (2009); Dielen et al. (2021). We first employ the global seamless parameterization algorithm from the libigl (Jacobson et al., 2017), which establishes parametric alignment with the predicted cross field. Then we utilize the libQEx (Ebke et al., 2013) to extract the quadrilateral tessellation from the parameterized representation.

With our unified geometry representation, 3D shapes are encoded into a sparse latent space that captures both geometric structure and cross field information. This latent space provides a natural foundation for generative modeling (Zheng et al., 2023). By incorporating a diffusion model within this latent, CrossGen can be extended to synthesize novel shapes and compute their cross fields in an end-to-end manner, providing an efficient way of quad meshing of the novel shapes. We provide further details and evaluations of this generative capability of CrossGen in Sec. 4.3.

Tab. 1 presents a quantitative comparison between our method and the baseline approaches. On the test data, our method and NeurCross (Dong et al., 2025) achieve the lowest angular error (AE) compared to the principal curvature directions, outperforming all other baselines. Benefiting from the direct inference design, CrossGen achieves the fastest average runtime, outperforming NeurCross (Dong et al., 2025) by approximately 5382 times on the full test data.

Note that only NeurCross (Dong et al., 2025) and our method are GPU-accelerated; all other baselines run on the CPU. To further evaluate performance under high-resolution inputs, we tested 50 randomly selected shapes from the test set, each with over 100,000 faces. As shown in Tab. 1, our method maintains a consistent runtime regardless of input resolution, demonstrating resolution-invariant efficiency. In contrast, all CPU-based methods show significantly increased runtime with higher resolution, while NeurCross (Dong et al., 2025), despite running on the GPU, is over 11,550 times slower than CrossGen and becomes increasingly constrained by computational overhead at higher resolutions. Fig. 7 presents a visual comparison of the cross fields generated by various methods.

To evaluate the effectiveness of our method in downstream applications, we apply it to quadrilateral meshing tasks and compare the resulting mesh quality with optimization-based approaches in Tab. 2. Except for IM (Jakob et al., 2015) and QuadriFlow (Huang et al., 2018), all methods employ the same quad mesh extraction technique, libQEx (Ebke et al., 2013). Note that our method assumes a point-cloud surface as input, whereas the existing quad mesh extraction methods requires a triangle mesh as the base surface for parameterization and quad extraction. Since all the baseline methods operate on ground-truth triangle meshes, to evaluate our method comprehensively, we consider two settings in Tab. 2: (1) We test our model using the same ground-truth mesh as used the baseline methods as the base surface for querying the cross field and quad meshing, denoted as CrossGen^∗. (2) Starting from point cloud input, we use the SDF branch to reconstruct a surface via Marching Cubes (Lorensen and Cline, 1987), which is then used as the base surface for quad meshing, denoted as CrossGen.

Tab. 2 shows the quantitative results comparing with baseline methods. Our method ranks second only to NeurCross across multiple evaluation metrics, outperforming all other baselines. We note that since NeurCross is used as the expert model to generate the GT data for training our CrossGen network, its performance is expected to be an upper bound for CrossGen’s performance. Besides, while both our method and NeurCross produce a higher number of singularities compared to MIQ (Bommes et al., 2009), our method achieves lower Jacobian Ratio (JR) values, indicating that MIQ (Bommes et al., 2009) tends to generate more distorted quadrilaterals. Fig. 8 presents a visual comparison, where our method produces high-quality and structurally consistent quadrilateral meshes, with results that are overall better or comparable to those of all the baseline methods. In addition, the setting CrossGen, which reconstructs the surface from point cloud inputs via the SDF branch, achieves results comparable to CrossGen^∗, which uses the GT mesh as input. A visual comparison of the two settings is shown in Fig. 9. These results highlight the effectiveness of our SDF branch in producing high-quality surface geometry suitable for downstream quad meshing tasks.

We use existing methods to generate quad meshes guided by cross fields produced by CrossGen. There three widely adopted open-source extractors: the IM method (Jakob et al., 2015), libQEx (Ebke et al., 2013), and QuadWild (Pietroni et al., 2021). The IM extractor, specifically designed for IM (Jakob et al., 2015), leverages local parameterization to accelerate the extraction process. While it offers high efficiency, this speed often comes at the expense of mesh quality, typically resulting in increased singularities and non-quad face (e.g, triangle faces as shown in Fig. 8). In comparison, libQEx (Ebke et al., 2013) and QuadWild (Pietroni et al., 2021) tend to generate higher-quality quad meshes, though they are slower than IM. As noted in NeurCross (Dong et al., 2025), libQEx (Ebke et al., 2013) is particularly suited for quad meshing of free-form shapes, while QuadWild (Pietroni et al., 2021) is specifically designed to preserve sharp features and thus well-suited for CAD models and surfaces with open boundaries. Hence, we will test the performance of CrossGen in combination with both libQEx and QuadWild in the quad meshing task.

Fig. 10 shows quad meshes generated using libQEx (Ebke et al., 2013) and QuadWild (Pietroni et al., 2021), respectively, each driven by cross fields predicted by different baseline methods, as well as CrossGen. With each mesh extraction method fixed, the mesh quality is solely determined by the quality of the cross field provided. Fig. 10 shows that CrossGen consistently produces quad meshes of better quality than other baseline methods, indicating the superior quality of the cross field predicted by CrossGen.

Although CrossGen delivers extremely fast computation of cross fields, we have not accelerated the step of quad mesh extraction. Specifically, on our test dataset, libQEx (Ebke et al., 2013) and QuadWild (Pietroni et al., 2021) require an average of 40.81 seconds and 15.17 seconds, respectively, to extract a quad mesh from a given cross fields. Since the inference time for cross field prediction in our method is negligible, the total runtime from the input point cloud to the final quad mesh ranges from 15 to 41 seconds, depending on whether QuadWild (Pietroni et al., 2021) or libQEx (Ebke et al., 2013) is used to extract the quad mesh.

Point2Quad (Li et al., 2025) is a learning-based method that generates quad meshes directly from point clouds, primarily targeting CAD-like geometries. In their paper, only results on CAD shapes are presented, and no pretrained models are publicly available. Therefore, for comparison, we refer to the qualitative results provided in their official repository. As shown in Fig. 11, while Point2Quad can generate plausible quads on simple CAD shapes, it struggles to preserve global field smoothness, resulting in increased singularities in the generated quad meshes. In contrast, our method produces field-aligned quad meshes with improved regularity.

A key strength of CrossGen lies in its robustness to diverse point cloud inputs, enabled by the flexibility of using point clouds. Two common scenarios are incomplete and sparsely sampled data. In real-world settings, 3D scans frequently suffer from missing regions or low-resolution sampling. Unlike traditional methods that rely on complete surface meshes, CrossGen remains effective even when substantial portions of the input geometry are absent. By leveraging a locality-aware latent space, our model can infer global structure and cross fields from limited data. As shown in Fig. 12, CrossGen successfully reconstructs coherent surfaces and high-quality quad meshes even when inputs contain missing regions (b) or are reduced to as few as 10K points (c), demonstrating strong resilience and practicality in challenging data conditions.

For point cloud inputs (Fig. 13 (a)), a triangle mesh surface is required to produce a quad mesh. One option is to use Poisson reconstruction (Kazhdan and Hoppe, 2013) to generate the surface (Fig. 13 (b)), but this approach can struggle to produce accurate results especially when the point cloud contains significant noise. In contrast, our method learns both SDF and cross field representations, enabling us to directly infer a high-quality SDF output from point cloud data via the SDF branch, even for noisy point clouds. We then extract the geometry surface using the Marching Cubes algorithm (Lorensen and Cline, 1987) (Fig. 13 (c)), sample points on the surface, and query the decoder’s feature volume to generate the corresponding cross field (Fig. 13 (d)) and extract the final quad mesh (Fig. 13 (e)). In Fig. 14, we further evaluate the robustness of our model under varying levels of Gaussian noise. Despite increasing noise, our method consistently produces smooth surfaces and coherent quad meshes, demonstrating strong resilience to input perturbations.

Another important feature of CrossGen is its robustness to random rotations. Unlike most existing methods that rely on shapes in a canonical pose, our method can process shapes with random pose inputs. By leveraging the learned local latent space representation, CrossGen can handle arbitrary orientations, making it more flexible and applicable in dynamic scenarios where the pose of the input shapes may vary without a requirement of a predefined orientation, as shown in Fig. 15.

One more key strength of CrossGen is its ability to handle out-of-domain geometries and new shape categories. In our experiments, we tested our method on shapes from previously unseen categories in the training stage. Despite not being trained on these specific shapes, CrossGen successfully predicts high-quality cross fields, demonstrating its ability to generalize across a wide range of geometries and surface types, as shown in Fig. 16. This ability is crucial for real-world applications where new, previously unseen shapes may need to be processed without requiring retraining or fine-tuning on each new dataset.

Given a set of 3D points sampled from open-boundary surfaces, we first encode them into a high-resolution feature grid, then query the corresponding cross fields via the cross field branch, and finally extract the quad mesh using QuadWild (Pietroni et al., 2021). Fig. 17 presents quad mesh results generated by our method on the shapes with open boundaries. Although our training dataset does not explicitly include surfaces with open boundaries, we find that our model generalizes well to such surfaces. We attribute this capability to the use of a sparse and local encoder in our model’s encoding process. By focusing on local surface features, the encoder inherently emphasizes learning local geometry, enabling greater flexibility and generalization.