Original: PC2WF: 3D W IREFRAME R ECONSTRUCTION FROM R AW P OINT C LOUDS
Revised: PC2WF: 3D W IREFRAME R ECONSTRUCTION FROM R AW P OINT C LOUDS

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: We introduce PC2WF, the ﬁrst end-to-end trainable deep network architecture to convert a 3D point cloud into a wireframe model.
Revised: We introduce PC2WF, the ﬁrst end-to-end trainable deep network architecture to convert a 3D point cloud into a wireframe model.

Original: The network takes as input an unordered set of 3D points sampled from the surface of some object, and outputs a wireframe of that object, i.e., a sparse set of corner points linked by line segments.
Revised: The network takes as input an unordered set of 3D points sampled from the surface of some object, and outputs a wireframe of that object, i.e., a sparse set of corner points linked by line segments.

Original: Recovering the wireframe is a challenging task, where the numbers of both vertices and edges are different for every instance, and a-priori unknown.
Revised: Recovering the wireframe is a challenging task, where the numbers of both vertices and edges are different for every instance, and a-priori unknown.

Original: Our architecture gradually builds up the model:
Revised: Our architecture gradually builds up the model:

Original: It starts by encoding the points into feature vectors.
Revised: It starts by encoding the points into feature vectors.

Original: Based on those features, it identiﬁes a pool of candidate vertices, then prunes those candidates to a ﬁnal set of corner vertices and reﬁnes their locations.
Revised: Based on those features, it identiﬁes a pool of candidate vertices, then prunes those candidates to a ﬁnal set of corner vertices and reﬁnes their locations.

Original: Next, the corners are linked with an exhaustive set of candidate edges, which is again pruned to obtain the ﬁnal wireframe.
Revised: Next, the corners are linked with an exhaustive set of candidate edges, which is again pruned to obtain the ﬁnal wireframe.

Original: All steps are trainable, and errors can be backpropagated through the entire sequence.
Revised: All steps are trainable, and errors can be backpropagated through the entire sequence.

Original: We validate the proposed model on a publicly available synthetic dataset, for which the ground truth wireframes are accessible, as well as on a new real-world dataset.
Revised: We validate the proposed model on a publicly available synthetic dataset, for which the ground truth wireframes are accessible, as well as on a new real-world dataset.

Original: Our model produces wireframe abstractions of good quality and outperforms several baselines.
Revised: Our model produces wireframe abstractions of good quality and outperforms several baselines.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Many practical 3D sensing systems, like stereo cameras or laser scanners, produce unstructured 3D point clouds.
Revised: Many practical 3D sensing systems, like stereo cameras or laser scanners, produce unstructured 3D point clouds.

Original: That choice of output format is really just a "smallest common denominator", the least committal representation that can be reliably generated with low-level signal processing.
Revised: That choice of output format is really just a "smallest common denominator", the least committal representation that can be reliably generated with low-level signal processing.

Original: Most users would prefer a more efﬁcient and more intuitive representation that describes the scanned object’s geometry as a compact collection of geometric primitives, together with their topological relations.
Revised: Most users would prefer a more efﬁcient and more intuitive representation that describes the scanned object’s geometry as a compact collection of geometric primitives, together with their topological relations.

Original: Speciﬁcally, many man-made objects are (approximately) polyhedral and can be described by corners, straight edges and/or planar surfaces.
Revised: Speciﬁcally, many man-made objects are (approximately) polyhedral and can be described by corners, straight edges and/or planar surfaces.

Original: Roughly speaking there are two ways to abstract a point cloud into a polyhedral model: either ﬁnd the planar surfaces and intersect them to ﬁnd the edges and corners, e.g., Schnabel et al.
Revised: Roughly speaking there are two ways to abstract a point cloud into a polyhedral model: either ﬁnd the planar surfaces and intersect them to ﬁnd the edges and corners, e.g., Schnabel et al.

Original: ; Fang et al.
Revised: ; Fang et al.

Original: ; Coudron et al.
Revised: ; Coudron et al.

Original: (2018); or directly ﬁnd the salient corner and/or edges, e.g., Jung et al.
Revised: (2018); or directly ﬁnd the salient corner and/or edges, e.g., Jung et al.

Original: ; Hackel et al. (2016).
Revised: ; Hackel et al. (2016).

Original: A wireframe is a graph representation of an object’s shape, where vertices correspond to corner points (with high Gaussian curvature) that are linked by edges (with high principal curvature).
Revised: A wireframe is a graph representation of an object’s shape, where vertices correspond to corner points (with high Gaussian curvature) that are linked by edges (with high principal curvature).

Original: Wireframes are a good match for polyhedral structures like mechanical parts, furniture or building interiors.
Revised: Wireframes are a good match for polyhedral structures like mechanical parts, furniture or building interiors.

Original: In particular, since wireframes focus on the edge structure, they are best suited for piece-wise smooth objects with few pronounced crease edges (whereas they are less suitable for smooth objects without deﬁned edges or for very rough ones with edges everywhere).
Revised: In particular, since wireframes focus on the edge structure, they are best suited for piece-wise smooth objects with few pronounced crease edges (whereas they are less suitable for smooth objects without deﬁned edges or for very rough ones with edges everywhere).

Original: We emphasise that wireframes are not only a "compression technique" to save storage.
Revised: We emphasise that wireframes are not only a "compression technique" to save storage.

Original: Their biggest advantage in many applications is that they are easy to manipulate and edit, automatically or interactively in CAD software, because they make the salient contours and their connectivity explicit.
Revised: Their biggest advantage in many applications is that they are easy to manipulate and edit, automatically or interactively in CAD software, because they make the salient contours and their connectivity explicit.

Original: Reconstructed wireframes can drive and help to create 3D CAD models for manufacturing parts, metrology, quality inspection, as well as visualisation, animation, and rendering.
Revised: Reconstructed wireframes can drive and help to create 3D CAD models for manufacturing parts, metrology, quality inspection, as well as visualisation, animation, and rendering.

Original: Inferring the wireframe from a noisy point cloud is a challenging task.
Revised: Inferring the wireframe from a noisy point cloud is a challenging task.

Original: We can think of the process as a sequence of steps: ﬁnd the corners, localise them accurately (as they are not contained in the point cloud), and link them with the appropriate edges.
Revised: We can think of the process as a sequence of steps: ﬁnd the corners, localise them accurately (as they are not contained in the point cloud), and link them with the appropriate edges.

Original: However, these steps are intricately correlated.
Revised: However, these steps are intricately correlated.

Original: For example, corner detection should "know" about the subsequent edge detection: curvature is affected by noise (as any user of an interest point detector can testify), so to qualify as a corner a 3D location should also be the plausible meeting point of multiple, non-collinear edges.
Revised: For example, corner detection should "know" about the subsequent edge detection: curvature is affected by noise (as any user of an interest point detector can testify), so to qualify as a corner a 3D location should also be the plausible meeting point of multiple, non-collinear edges.

Original: Here we introduce PC2WF, an end-to-end trainable architecture for point cloud to wireframe conversion.
Revised: Here we introduce PC2WF, an end-to-end trainable architecture for point cloud to wireframe conversion.

Original: PC2WF is composed of a sequence of feed-forward blocks, see Fig.
Revised: PC2WF is composed of a sequence of feed-forward blocks, see Fig.

Original: 1 for the individual steps of the pipeline.
Revised: 1 for the individual steps of the pipeline.

Original: First a "backbone" block extracts a latent feature encoding for each point.
Revised: First a "backbone" block extracts a latent feature encoding for each point.

Original: The next block identiﬁes local neighbourhoods ("patches") that contain corners and regresses their 3D locations.
Revised: The next block identiﬁes local neighbourhoods ("patches") that contain corners and regresses their 3D locations.

Original: The ﬁnal block links the corners with an overcomplete set of plausible candidate edges, collects edge features by pooling point features along each edge, and uses those to prune the candidate set to a ﬁnal set of wireframe edges.
Revised: The ﬁnal block links the corners with an overcomplete set of plausible candidate edges, collects edge features by pooling point features along each edge, and uses those to prune the candidate set to a ﬁnal set of wireframe edges.

Original: All stages of the architecture that have trainable parameters support back-propagation, such that the model can be learned end-to-end.
Revised: All stages of the architecture that have trainable parameters support back-propagation, such that the model can be learned end-to-end.

Original: We validate PC2WF with models from the publicly available ABC dataset of CAD models, and with a new furniture dataset collected from the web.
Revised: We validate PC2WF with models from the publicly available ABC dataset of CAD models, and with a new furniture dataset collected from the web.

Original: The experiments highlight the beneﬁt of explicit, integrated wireframe prediction: on the one hand, the detected corners are more complete and more accurate than with a generic corner detector; on the other hand, the reconstructed edges are more complete and more accurate than those found with existing (point-wise) edge detection methods.
Revised: The experiments highlight the beneﬁt of explicit, integrated wireframe prediction: on the one hand, the detected corners are more complete and more accurate than with a generic corner detector; on the other hand, the reconstructed edges are more complete and more accurate than those found with existing (point-wise) edge detection methods.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Relatively little work exists on the direct reconstruction of 3D wireframes.
Revised: Relatively little work exists on the direct reconstruction of 3D wireframes.

Original: We review related work for the subtasks of corner and edge detection, as well as works that reconstruct wireframes in 2D or polyhedral surface models and geometric primitives in 3D.
Revised: We review related work for the subtasks of corner and edge detection, as well as works that reconstruct wireframes in 2D or polyhedral surface models and geometric primitives in 3D.

Original: Corner Detection.
Revised: Corner Detection.

Original: Corner points play a fundamental role in both 2D and 3D computer vision.
Revised: Corner points play a fundamental role in both 2D and 3D computer vision.

Original: A 3D corner is the intersection point of ≥ 3 (locally) non-collinear surfaces.
Revised: A 3D corner is the intersection point of ≥ 3 (locally) non-collinear surfaces.

Original: Corners have a well-deﬁned location and a local neighbourhood with non-trivial shape (e.g., for matching).
Revised: Corners have a well-deﬁned location and a local neighbourhood with non-trivial shape (e.g., for matching).

Original: Collectively the set of corners often is sufﬁcient to tightly constrain the scale and shape of an object.
Revised: Collectively the set of corners often is sufﬁcient to tightly constrain the scale and shape of an object.

Original: Typical local methods for corner detection are based on the 2 nd -moment matrix of the points (resp.
Revised: Typical local methods for corner detection are based on the 2 nd -moment matrix of the points (resp.

Original: normals) in a local neighbourhood (Głomb, 2009; Sipiran & Bustos, 2010; 2011), a straight-forward generalisation of the 2D Harris operator ﬁrst proposed for 2D images (Harris et al., 1988).
Revised: normals) in a local neighbourhood (Głomb, 2009; Sipiran & Bustos, 2010; 2011), a straight-forward generalisation of the 2D Harris operator ﬁrst proposed for 2D images (Harris et al., 1988).

Original: Also other 2D corner detectors like Susan (Smith & Brady, 1997) have been generalised to 3D (Walter et al., 2009).
Revised: Also other 2D corner detectors like Susan (Smith & Brady, 1997) have been generalised to 3D (Walter et al., 2009).

Original: Point-level Edge Point Detection.
Revised: Point-level Edge Point Detection.

Original: A large body of work is dedicated to the detection of 3D points that lie on or near edges.
Revised: A large body of work is dedicated to the detection of 3D points that lie on or near edges.

Original: The main edge feature is high local curvature (Yang & Zang, 2014).
Revised: The main edge feature is high local curvature (Yang & Zang, 2014).

Original: Related features, such as symmetry (Ahmed et al., 2018), change of normals (Demarsin et al., 2007), and eigenvalues (Bazazian et al., 2015; Xia & Wang, 2017) can also be used for edge detection.
Revised: Related features, such as symmetry (Ahmed et al., 2018), change of normals (Demarsin et al., 2007), and eigenvalues (Bazazian et al., 2015; Xia & Wang, 2017) can also be used for edge detection.

Original: Hackel et al.
Revised: Hackel et al.

Original: (2016; 2017) use a combination of several features as input for a binary edge-point classiﬁer.
Revised: (2016; 2017) use a combination of several features as input for a binary edge-point classiﬁer.

Original: After linking the points into an adjacency graph, graph ﬁltering can be used to preserve only edge points (Chen et al., 2017).
Revised: After linking the points into an adjacency graph, graph ﬁltering can be used to preserve only edge points (Chen et al., 2017).

Original: EC-Net (Yu et al., 2018) is the ﬁrst method we know of that detects edge points in 3D point clouds with deep learning.
Revised: EC-Net (Yu et al., 2018) is the ﬁrst method we know of that detects edge points in 3D point clouds with deep learning.

Original: Learning Structured Models.
Revised: Learning Structured Models.

Original: Many methods have been proposed to abstract point clouds into more structured 3D models, e.g., triangle meshes (Lin et al., 2004; Remondino, 2003; Lin et al., 2004), polygonal surfaces (Fang et al., 2018; Coudron et al., 2018), simple parametric surfaces (Schnabel et al., 2007; 2008; Li et al., 2019).
Revised: Many methods have been proposed to abstract point clouds into more structured 3D models, e.g., triangle meshes (Lin et al., 2004; Remondino, 2003; Lin et al., 2004), polygonal surfaces (Fang et al., 2018; Coudron et al., 2018), simple parametric surfaces (Schnabel et al., 2007; 2008; Li et al., 2019).

Original: From the user perspective, the ultimate goal would be to reverseengineer a CAD model (Gonzalez-Aguilera et al., 2012;
Revised: From the user perspective, the ultimate goal would be to reverseengineer a CAD model (Gonzalez-Aguilera et al., 2012;

Original: Li et al., 2017b; Durupt et al., 2008).
Revised: Li et al., 2017b; Durupt et al., 2008).

Original: Several works have investigated wireframe parsing in 2D images (Huang et al., 2018;
Revised: Several works have investigated wireframe parsing in 2D images (Huang et al., 2018;

Original: Huang &
Revised: Huang &

Original: Gao, 2019).
Revised: Gao, 2019).

Original: LCNN (Zhou et al., 2019a) is an end-to-end trainable system that directly outputs a vectorised wireframe.
Revised: LCNN (Zhou et al., 2019a) is an end-to-end trainable system that directly outputs a vectorised wireframe.

Original: The current state-of-the-art appears to be the improved LCNN of Xue et al.
Revised: The current state-of-the-art appears to be the improved LCNN of Xue et al.

Original: (2020), which uses a holistic "attraction ﬁeld map" to characterise line segments.
Revised: (2020), which uses a holistic "attraction ﬁeld map" to characterise line segments.

Original: Zou et al.
Revised: Zou et al.

Original: (2018) estimate the 3D layout of an indoor scene from a single perspective or panoramic image with an encoder-decoder architecture, while Zhou et al.
Revised: (2018) estimate the 3D layout of an indoor scene from a single perspective or panoramic image with an encoder-decoder architecture, while Zhou et al.

Original: (2019b) obtain a compact 3D wireframe representation from a single image by exploiting global structural regularities.
Revised: (2019b) obtain a compact 3D wireframe representation from a single image by exploiting global structural regularities.

Original: Jung et al.
Revised: Jung et al.

Original: (2016) reconstruct 3D wireframes of building interiors under a Manhattan-world assumption.
Revised: (2016) reconstruct 3D wireframes of building interiors under a Manhattan-world assumption.

Original: Edges are detected heuristically by projecting the points onto 2D occupancy grids, then reﬁned via least-squares ﬁtting under parallelism/orthogonality constraints.
Revised: Edges are detected heuristically by projecting the points onto 2D occupancy grids, then reﬁned via least-squares ﬁtting under parallelism/orthogonality constraints.

Original: Wireframe extraction in 2D images is simpliﬁed by the regular pixel grid.
Revised: Wireframe extraction in 2D images is simpliﬁed by the regular pixel grid.

Original: For irregular 3D points the task is more challenging and there has been less work.
Revised: For irregular 3D points the task is more challenging and there has been less work.

Original: Another related direction of research is 3D shape decomposition into sets of simple, parameterised primitives (Tulsiani et al., 2017;
Revised: Another related direction of research is 3D shape decomposition into sets of simple, parameterised primitives (Tulsiani et al., 2017;

Original: Li et al., 2017a;
Revised: Li et al., 2017a;

Original: Zou et al., 2017; Sharma et al., 2018;
Revised: Zou et al., 2017; Sharma et al., 2018;

Original: Du et al., 2018).
Revised: Du et al., 2018).

Original: Most approaches use a coarse volumetric occupancy grid as input for the 3D data, whichworks well for shape primitive ﬁtting but only allows for rather inaccurate localisation of edges and
Revised: Most approaches use a coarse volumetric occupancy grid as input for the 3D data, which

Original: [Table]
Revised: [Table]

Original: /JxISaD0NfNsZEDPWq95C/M/rxmZ46yVcRrFhkqaLhrHAJsSL//GAK0aNmFpCqOL2VkzHRBFqbEq5LX6Q+yF5TU/Paalks3NXk1onrauq61Tdx+tK7S5LsQBncA6X4MIN1OAeGtAEChLe4B0+0Cf6Qt9onrZuoGzmFHJAP79kWKZB</latexit> 
Revised: /JxISaD0NfNsZEDPWq95C/M/rxmZ46yVcRrFhkqaLhrHAJsSL//GAK0aNmFpCqOL2VkzHRBFqbEq5LX6Q+yF5TU/Paalks3NXk1onrauq61Tdx+tK7S5LsQBncA6X4MIN1OAeGtAEChLe4B0+0Cf6Qt9onrZuoGzmFHJAP79kWKZB</latexit> wireframe

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original:  vertices.
Revised: samples [Figure] works well for shape primitive ﬁtting but only allows for rather inaccurate localisation of edges and vertices.

Original: Li et al.
Revised: Li et al.

Original: (2019) propose a method for ﬁtting 3D primitives directly to raw point clouds.
Revised: (2019) propose a method for ﬁtting 3D primitives directly to raw point clouds.

Original: A limiting factor of their approach is that only a ﬁxed maximum number of primitive instances can be detected.
Revised: A limiting factor of their approach is that only a ﬁxed maximum number of primitive instances can be detected.

Original: This upper bound is hard-coded in the architecture and prevents the network from ﬁtting more complex structures.
Revised: This upper bound is hard-coded in the architecture and prevents the network from ﬁtting more complex structures.

Original: Nan & Wonka (2017) propose Polyﬁt to extract polygonal surfaces from a point cloud.
Revised: Nan & Wonka (2017) propose Polyﬁt to extract polygonal surfaces from a point cloud.

Original: Polyﬁt ﬁrst selects an exhaustive set of candidate surfaces from the raw point cloud using
Revised: Polyﬁt ﬁrst selects an exhaustive set of candidate surfaces from the raw point cloud using

Original: RANSAC, and then reﬁnes the surfaces.
Revised: RANSAC, and then reﬁnes the surfaces.

Original: Similarly to our PC2WF, Polyﬁt works best with objects made of straight edges and planar surfaces.
Revised: Similarly to our PC2WF, Polyﬁt works best with objects made of straight edges and planar surfaces.

Revised: The concurrent work Wang et al.

Revised: (2020) proposed a deep neural network that is trained to identify a collection of parametric edges.

Original: In summary, most 3D methods are either hand-crafted for restricted, schematic settings, or only learn to label individual "edge points".
Revised: In summary, most 3D methods are either hand-crafted for restricted, schematic settings, or only learn to label individual "edge points".

Original: Here we aim for an end-to-end learnable model that directly maps a 3D point cloud to a vectorised wireframe.
Revised: Here we aim for an end-to-end learnable model that directly maps a 3D point cloud to a vectorised wireframe.

Original:  M ETHOD
Revised:  M ETHOD

Original: Our full architecture is depicted in Fig.
Revised: Our full architecture is depicted in Fig.

Original: In the following we describe each block and, where necessary, discuss training and inference procedures.
Revised: In the following we describe each block and, where necessary, discuss training and inference procedures.

Original: We denote a point cloud of N 3D points with
Revised: We denote a point cloud of N 3D points with

Original: P = { p i } Ni =1 where p i ∈ R 3 represents the 3D coordinates of point i .
Revised: P = { p i } Ni =1 where p i ∈ R 3 represents the 3D coordinates of point i .

Original: The 3D wireframe model of the point cloud
Revised: The 3D wireframe model of the point cloud

Original: P is denoted by W =
Revised: P is denoted by W =

Original: ( V , E )
Revised: ( V , E )

Original: and it is deﬁned, analogously to an undirected graph, by a set of vertices
Revised: and it is deﬁned, analogously to an undirected graph, by a set of vertices

Original: V which are connected by a set of edges E
Revised: V which are connected by a set of edges E

Original: ⊆ V × V .
Revised: ⊆ V × V .

Original: As the vertices represent points in the 3D space we can think of them as being described by 3D coordinates v i
Revised: As the vertices represent points in the 3D space we can think of them as being described by 3D coordinates v i

Original: [Equation]
Revised: [Equation]

Original: Overall Pipeline.
Revised: Overall Pipeline.

Original: Our feed-forward pipeline consists of four blocks: (1) a convolutional backbone that extracts per-point features; (2) a vertex detector that examines patches of the point cloud and decides which ones contain vertices; (3) a vertex localiser that outputs the location of the vertex within a patch; (4) an edge detector that instantiates candidate edges and prunes them to a wireframe.
Revised: Our feed-forward pipeline consists of four blocks: (1) a convolutional backbone that extracts per-point features; (2) a vertex detector that examines patches of the point cloud and decides which ones contain vertices; (3) a vertex localiser that outputs the location of the vertex within a patch; (4) an edge detector that instantiates candidate edges and prunes them to a wireframe.

Original: Backbone.
Revised: Backbone.

Original: PC2WF ﬁrst extracts a feature vector per 3D point that encodes its geometric context.
Revised: PC2WF ﬁrst extracts a feature vector per 3D point that encodes its geometric context.

Original: Our pipeline is compatible with any (hand-coded or learned) function that outputs a ﬁxed-size descriptor vector per point.
Revised: Our pipeline is compatible with any (hand-coded or learned) function that outputs a ﬁxed-size descriptor vector per point.

Original: We use Fully Convolutional Geometric Features (FCGF, Choy et al., 2019b), which are compact and capture broad spatial context.
Revised: We use Fully Convolutional Geometric Features (FCGF, Choy et al., 2019b), which are compact and capture broad spatial context.

Original: The backbone operates on sparse tensors (Choy et al., 2019a) and efﬁciently computes 32-dimensional features in a single, 3D fully-convolutional pass.
Revised: The backbone operates on sparse tensors (Choy et al., 2019a) and efﬁciently computes 32-dimensional features in a single, 3D fully-convolutional pass.

Original: Vertex Detector.
Revised: Vertex Detector.

Original: This block performs binary classiﬁcation of local patches (neighbourhoods in the point cloud) into those (few) that contain a corner and those that do not.
Revised: This block performs binary classiﬁcation of local patches (neighbourhoods in the point cloud) into those (few) that contain a corner and those that do not.

Original: Only patches detected to contain a corner are passed on to the subsequent block.
Revised: Only patches detected to contain a corner are passed on to the subsequent block.

Original: While one could argue that detecting the presence of a vertex and inferring its 3D coordinates are two facets of the same problem, we found it advantageous to separate them.
Revised: While one could argue that detecting the presence of a vertex and inferring its 3D coordinates are two facets of the same problem, we found it advantageous to separate them.

Original: Detecting ﬁrst whether a patch is likely to contain a corner, then constructing its 3D coordinates reduces the computational cost, as we discard patches without corners early.
Revised: Detecting ﬁrst whether a patch is likely to contain a corner, then constructing its 3D coordinates reduces the computational cost, as we discard patches without corners early.

Original: Empirically it also reduces false positives and increases localisation accuracy.
Revised: Empirically it also reduces false positives and increases localisation accuracy.

Original: Our patch generation is similar to EC-Net (Yu et al., 2018).
Revised: Our patch generation is similar to EC-Net (Yu et al., 2018).

Original: A patch contains a ﬁxed number M of points, chosen by picking a patch centroid and ﬁnding the closest ( M − 1) points in terms of geodesic distance on the underlying surface.
Revised: A patch contains a ﬁxed number M of points, chosen by picking a patch centroid and ﬁnding the closest ( M − 1) points in terms of geodesic distance on the underlying surface.

Original: The geodesic distance avoids "shortcuts" in regions with thin structures or high curvature.
Revised: The geodesic distance avoids "shortcuts" in regions with thin structures or high curvature.

Original: To approximate the geodesic distance, the entire point cloud is linked into a k -nearest neighbour graph, with edge weights proportional to Euclidean distance.
Revised: To approximate the geodesic distance, the entire point cloud is linked into a k -nearest neighbour graph, with edge weights proportional to Euclidean distance.

Original: Point-to-point distances are then found as shortest paths on that graph.
Revised: Point-to-point distances are then found as shortest paths on that graph.

Original: During training we randomly draw positive samples that contain a corner and negative ones that do not.
Revised: During training we randomly draw positive samples that contain a corner and negative ones that do not.

Original: To increase the diversity of positive samples, the same corner can be included in multiple patches with different centroids.
Revised: To increase the diversity of positive samples, the same corner can be included in multiple patches with different centroids.

Original: For the negative samples, we ensure to draw not only patches on ﬂat surfaces, but also several patches near edges, by doing this negative samples with strong curvature are well represented.
Revised: For the negative samples, we ensure to draw not only patches on ﬂat surfaces, but also several patches near edges, by doing this negative samples with strong curvature are well represented.

Original: For inference, patch seeds are drawn using farthest point sampling.
Revised: For inference, patch seeds are drawn using farthest point sampling.

Original: The vertex detector takes as input the (indexed) features of the M points in the patch, max-pooled per dimension to achieve permutation invariance, and outputs a scalar vertex/no_vertex probability.
Revised: The vertex detector takes as input the (indexed) features of the M points in the patch, max-pooled per dimension to achieve permutation invariance, and outputs a scalar vertex/no_vertex probability.

Original: Its loss function L pat is binary cross-entropy.
Revised: Its loss function L pat is binary cross-entropy.

Original: Vertex Localiser.
Revised: Vertex Localiser.

Original: The vertex detector passes on a set of P patches predicted to contain a corner.
Revised: The vertex detector passes on a set of P patches predicted to contain a corner.

Original: The M points p i of such a patch form the input for the localisation block.
Revised: The M points p i of such a patch form the input for the localisation block.

Original: The backbone features f i ∈ R C and the 3D coordinates p i ∈ R 3 of all M points are concatenated and fed into a multi-layer perceptron with fully connected layers, ReLU activations and batch normalisation.
Revised: The backbone features f i ∈ R C and the 3D coordinates p i ∈ R 3 of all M points are concatenated and fed into a multi-layer perceptron with fully connected layers, ReLU activations and batch normalisation.

Original: The MLP outputs a vector of M scalar weights w i , where (cid:80) i
Revised: The MLP outputs a vector of M scalar weights w i , where (cid:80) i

Original: w i
Revised: w i

Original: = 1 , such that the predicted vertex location is the weighted mean of the input points, v = (cid:80) w i p i .
Revised: = 1 , such that the predicted vertex location is the weighted mean of the input points, v = (cid:80) w i p i .

Original: The prediction v j is supervised by a regression loss
Revised: The prediction v j is supervised by a regression loss

Original: L vert = 1 P (cid:80) P i (cid:107) v i − v GT i (cid:107) 22 , summed over all P corner patches.
Revised: L vert = 1 P (cid:80) Pi (cid:107) v i − v GTi (cid:107) 22 , summed over all P corner patches.

Original: Predicting weights w i rather than directly the coordinates ˜ x safeguards against extrapolation errors on unusual patches.
Revised: Predicting weights w i rather than directly the coordinates ˜ x safeguards against extrapolation errors on unusual patches.

Original: We note that the localiser not only improves the corner point accuracy but also improves efﬁciency, by making it possible to use farthest point sampling rather than testing every input point.
Revised: We note that the localiser not only improves the corner point accuracy but also improves efﬁciency, by making it possible to use farthest point sampling rather than testing every input point.

Original: Edge Detector.
Revised: Edge Detector.

Original: The edge detection block serves to determine which pairs of (predicted) vertices are connected by an edge.
Revised: The edge detection block serves to determine which pairs of (predicted) vertices are connected by an edge.

Original: Candidate edges e ij are found by linking two vertices v i and v j , see below.
Revised: Candidate edges e ij are found by linking two vertices v i and v j , see below.

Original: To obtain a descriptor for an edge, we sample the N s equally spaced query locations Q = { q k } s − 1 k =0 along the line segment between the two vertices, including the endpoints: q 0 = ˜ v i , q s − 1 = ˜ v j .
Revised: To obtain a descriptor for an edge, we sample the N s equally spaced query locations Q = { q k } s − 1 k =0 along the line segment between the two vertices, including the endpoints: q 0 = ˜ v i , q s − 1 = ˜ v j .

Original: For each q k we ﬁnd the nearest 3D input point p NN ( k ) (by Euclidean distance) and retrieve its backbone encoding f NN ( k ) .
Revised: For each q k we ﬁnd the nearest 3D input point p NN ( k ) (by Euclidean distance) and retrieve its backbone encoding f NN ( k ) .

Original: This yields an ( N s × C ) edge descriptor, which is max-pooled along its ﬁrst dimension, inspired by the ROI pooling in Faster-RCNN (Ren et al., 2015) and LOI pooling in LCNN (Zhou et al., 2019a).
Revised: This yields an ( N s × C ) edge descriptor, which is max-pooled along its ﬁrst dimension, inspired by the ROI pooling in Faster-RCNN (Ren et al., 2015) and LOI pooling in LCNN (Zhou et al., 2019a).

Original: The resulting ( 1 stride N s × C ) descriptor is ﬂattened and fed through an MLP with two fully connected layers, which returns a scalar edge/no_edge score.
Revised: The resulting ( 1 stride N s × C ) descriptor is ﬂattened and fed through an MLP with two fully connected layers, which returns a scalar edge/no_edge score.

Original: During training we select a number of vertex pairs from both the ground truth vertex list { v i } Gi =

Revised: During training we select a number of vertex pairs from both the ground truth vertex list { v i } Gi =

Original: and the predicted vertex list { ˜ v i } Ki =1 , and draw positive and negative sets of edge samples, E + , E − .
Revised: and the predicted vertex list { ˜ v i } Ki =1 , and draw positive and negative sets of edge samples, E + , E − .

Original: We empirically found that evaluating all vertex pairs contained in
Revised: We empirically found that evaluating all vertex pairs contained in

Original: E + , E − during training leads to a large imbalance between positive and negative samples.
Revised: E + , E − during training leads to a large imbalance between positive and negative samples.

Original: Similar to Zhou et al.
Revised: Similar to Zhou et al.

Original: (2019a)
Revised: (2019a)

Original: , we thus draw input edges for the edge detector from the following sets:
Revised: , we thus draw input edges for the edge detector from the following sets:

Original: (a) Positive edges between ground truth vertices: This set comprises all true edges in the ground truth wireframe E gt+ =
Revised: (a) Positive edges between ground truth vertices: This set comprises all true edges in the ground truth wireframe E gt+ =

Original: E (b) Negative edges between ground truth vertices: Two situations are relevant: "spurious edges", i e., connections between two ground truth vertices that do not share an edge (but lie on the same surface, such that there are nearby points to collect features).
Revised: E (b) Negative edges between ground truth vertices: Two situations are relevant: "spurious edges", i.e., connections between two ground truth vertices that do not share an edge (but lie on the same surface, such that there are nearby points to collect features).

Original: And "inaccurate edges" where one of the endpoints is not a ground truth vertex, but not far from one (to cover difﬁcult cases not far from a correct edge).
Revised: And "inaccurate edges" where one of the endpoints is not a ground truth vertex, but not far from one (to cover difﬁcult cases not far from a correct edge).

Original: Formally:
Revised: Formally:

Original: [Equation]
Revised: [Equation]

Revised: c) edges between predicted vertices: Connections between two "correct" predicted vertices that have both been veriﬁed to coincide with a ground truth wireframe vertex up to a small threshold (cid:15) + .

Revised: Formally:

Original: [Equation]
Revised: [Equation]

Revised: (d) Negative edges between predicted vertices: These are (i) "wrong links" as in E gt- , between "correctly" predicted vertices; and (ii) "hard negatives" where exactly one of the two vertices is close to a ground truth wireframe vertex, to cover "near misses".

Original: [Equation]
Revised: [Equation]

Original: Fig.
Revised: Fig.

Original: 2 visually depicts the different edge sets.
Revised: 2 visually depicts the different edge sets.

Original: To train the edge detector we randomly sample positive examples from E + = E gt+ ∪ E pred+ and negative examples from E − =
Revised: To train the edge detector we randomly sample positive examples from E + = E gt+ ∪ E pred+ and negative examples from E − =

Original: E gt- ∪ E pred- .
Revised: E gt- ∪ E pred- .

Original: As loss function
Revised: As loss function

Original: L edge we use the balanced binary cross entropy.
Revised: L edge we use the balanced binary cross entropy.

Original: During inference, we go through the fully connected graph of edge candidates connecting any two (predicted) vertices.
Revised: During inference, we go through the fully connected graph of edge candidates connecting any two (predicted) vertices.

Original: Candidates with a too high average distance to the input points (i.e., not lying on any object surface) are discarded.
Revised: Candidates with a too high average distance to the input points (i.e., not lying on any object surface) are discarded.

Original: All others are fed into the edge detector for veriﬁcation.
Revised: All others are fed into the edge detector for veriﬁcation.

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Equation] [Figure] [Equation] [Figure]

Original: /ef0YvCs7YUEUAw1IPsiLuQ6hniWiu0xQAnyqCCaCqV11MsICE1C5FaY4fuGGZJKvXtBySWVnLia1TDrnDdNomPcX9eb1PMUyOkLH6BSZ6BI10R1qoTYi6Bm9oFf0pr1rn9qX9p2XlrR5zwEqQPv5BarwrpQ=</latexit>
Revised: [Equation] [Figure] [Equation] [Figure]

Revised: [Equation]

Original: <latexit sha1_base64="faxmAkO5DQUz226dqcWaX9LHnnE=">AAACOnicbVDLSsNAFJ3UV62vVne6CRbBjSURQZdFEVxWsA9oYplMJu3QyYOZG2kJAb/GrX6AP+LWnbj1A5w0XZjWAwOHc+6de+9xIs4kGMaHVlpZXVvfKG9WtrZ3dveqtf2ODGNBaJuEPBQ9B0vKWUDbwIDTXiQo9h1Ou874JvO7T1RIFgYPMI2o7eNhwDxGMChpUD20fAwjgnlymz4mFtAJJOoD9yxNB9W60TBm0JeJOSd1NEdrUNPKlhuS2KcBEI6l7JtGBHaCBTDCaVqxYkkjTMZ4SPuKBtin0k5mR6T6iVJc3QuFegHoM/VvR4J9Kae+oyqzleWil4n/ef0YvCs7YUEUAw1IPsiLuQ6hniWiu0xQAnyqCCaCqV11MsICE1C5FaY4fuGGZJKvXtBySWVnLia1TDrnDdNomPcX9eb1PMUyOkLH6BSZ6BI10R1qoTYi6Bm9oFf0pr1rn9qX9p2XlrR5zwEqQPv5BarwrpQ=</latexit> <latexit sha1_base64="faxmAkO5DQUz226dqcWaX9LHnnE=">AAACOnicbVDLSsNAFJ3UV62vVne6CRbBjSURQZdFEVxWsA9oYplMJu3QyYOZG2kJAb/GrX6AP+LWnbj1A5w0XZjWAwOHc+6de+9xIs4kGMaHVlpZXVvfKG9WtrZ3dveqtf2ODGNBaJuEPBQ9B0vKWUDbwIDTXiQo9h1Ou874JvO7T1RIFgYPMI2o7eNhwDxGMChpUD20fAwjgnlymz4mFtAJJOoD9yxNB9W60TBm0JeJOSd1NEdrUNPKlhuS2KcBEI6l7JtGBHaCBTDCaVqxYkkjTMZ4SPuKBtin0k5mR6T6iVJc3QuFegHoM/VvR4J9Kae+oyqzleWil4n/ef0YvCs7YUEUAw1IPsiLuQ6hniWiu0xQAnyqCCaCqV11MsICE1C5FaY4fuGGZJKvXtBySWVnLia1TDrnDdNomPcX9eb1PMUyOkLH6BSZ6BI10R1qoTYi6Bm9oFf0pr1rn9qX9p2XlrR5zwEqQPv5BarwrpQ=</latexit> <latexit sha1_base64="faxmAkO5DQUz226dqcWaX9LHnnE=">AAACOnicbVDLSsNAFJ3UV62vVne6CRbBjSURQZdFEVxWsA9oYplMJu3QyYOZG2kJAb/GrX6AP+LWnbj1A5w0XZjWAwOHc+6de+9xIs4kGMaHVlpZXVvfKG9WtrZ3dveqtf2ODGNBaJuEPBQ9B0vKWUDbwIDTXiQo9h1Ou874JvO7T1RIFgYPMI2o7eNhwDxGMChpUD20fAwjgnlymz4mFtAJJOoD9yxNB9W60TBm0JeJOSd1NEdrUNPKlhuS2KcBEI6l7JtGBHaCBTDCaVqxYkkjTMZ4SPuKBtin0k5mR6T6iVJc3QuFegHoM/VvR4J9Kae+oyqzleWil4n/ef0YvCs7YUEUAw1IPsiLuQ6hniWiu0xQAnyqCCaCqV11MsICE1C5FaY4fuGGZJKvXtBySWVnLia1TDrnDdNomPcX9eb1PMUyOkLH6BSZ6BI10R1qoTYi6Bm9oFf0pr1rn9qX9p2XlrR5zwEqQPv5BarwrpQ=</latexit>
Revised: [Figure] [Equation] [Table] /GrX6AP+LWnbj1A5w0XZjWAwOHc+6de+9xIs4kGMaHVlpZXVvfKG9WtrZ3dveqtf2ODGNBaJuEPBQ9B0vKWUDbwIDTXiQo9h1Ou874JvO7T1RIFgYPMI2o7eNhwDxGMChpUD20fAwjgnlymz4mFtAJJOoD9yxNB9W60TBm0JeJOSd1NEdrUNPKlhuS2KcBEI6l7JtGBHaCBTDCaVqxYkkjTMZ4SPuKBtin0k5mR6T6iVJc3QuFegHoM/VvR4J9Kae+oyqzleWil4n/ef0YvCs7YUEUAw1IPsiLuQ6hniWiu0xQAnyqCCaCqV11MsICE1C5FaY4fuGGZJKvXtBySWVnLia1TDrnDdNomPcX9eb1PMUyOkLH6BSZ6BI10R1qoTYi6Bm9oFf0pr1rn9qX9p2XlrR5zwEqQPv5BarwrpQ=</latexit>

Original: End-to-end training.
Revised: End-to-end training.

Original: When training the complete network, we minimise the joint loss function with balancing weights α and β : L =
Revised: When training the complete network, we minimise the joint loss function with balancing weights α and β : L =

Original: L pat + α L vert + β L edge .
Revised: L pat + α L vert + β L edge .

Original: Non-Maximum Suppression (NMS) is a standard post-processing step for detection tasks, to suppress redundant, overlapping predictions.
Revised: Non-Maximum Suppression (NMS) is a standard post-processing step for detection tasks, to suppress redundant, overlapping predictions.

Original: We use it (i) to prevent duplicate predictions of vertices that are very close to each other, and (ii) to prune redundant edges.
Revised: We use it (i) to prevent duplicate predictions of vertices that are very close to each other, and (ii) to prune redundant edges.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We could not ﬁnd any publicly available dataset of point clouds with polyhedral wireframe annotations.
Revised: We could not ﬁnd any publicly available dataset of point clouds with polyhedral wireframe annotations.

Original: Thus, we collect our own synthetic datasets: a subset from ABC (Koch et al., 2019) and a Furniture dataset .
Revised: Thus, we collect our own synthetic datasets: a subset from ABC (Koch et al., 2019) and a Furniture dataset .

Original: ABC is a collection of one million high-quality CAD models of mechanical parts with explicitly parametrized curves, surfaces and various geometric features, from which ground truth wireframes can be generated.
Revised: ABC is a collection of one million high-quality CAD models of mechanical parts with explicitly parameterised curves, surfaces and various geometric features, from which ground truth wireframes can be generated.

Original: We select a subset of models with straight edges.
Revised: We select a subset of models with straight edges.

Original: It consists of 3, samples, which we randomly split into 2,000 for training, 500 for validation, and 500 for testing.
Revised: It consists of 3, samples, which we randomly split into 2,000 for training, 500 for validation, and 500 for testing.

Original: For the furniture dataset we have collected 250 models from Google 3DWarehouse for the categories bed, table, chair/sofa, stairs, monitor and render ground truth wireframes.
Revised: For the furniture dataset we have collected 250 models from Google 3DWarehouse for the categories bed, table, chair/sofa, stairs, monitor and render ground truth wireframes.

Original: Examples are shown in the supplementary material.
Revised: Examples are shown in the supplementary material.

Original: To generate point clouds, we use the virtual scanner of Wang et al.
Revised: To generate point clouds, we use the virtual scanner of Wang et al.

Original: We place 14 virtual cameras on the face centers of the truncated bounding cubes of each object, uniformly shoot 16,000 parallel rays towards the object from each direction, and compute their intersections with htesurfaces.
Revised: We place 14 virtual cameras on the face centres of the truncated bounding cubes of each object, uniformly shoot 16,000 parallel rays towards the object from each direction, and compute their intersections with the surfaces.

Original: Finally, we jitter all points by adding Gaussian noise N (0 , 0 . 01) , truncated to [ − 0 .
Revised: Finally, we jitter all points by adding Gaussian noise N (0 , 0 . 01) , truncated to [ − 0 .

Original: The number N of points varies between ≈ 100 k − 200 k for different virtually scanned point clouds between.
Revised: The number N of points varies between ≈ 100 k − 200 k for different virtually scanned point clouds.

Original: For details, see the supplementary material.
Revised: For details, see the supplementary material.

Original: 4. E VALUATION M EASURES
Revised: 4. E VALUATION M EASURES

Original: We ﬁrst separately evaluate the vertex detection and edge detection performance of our architecture, then assess the reconstructed wireframes in terms of structural average precision and of a newly designed wireframe edit distance.
Revised: We ﬁrst separately evaluate the vertex detection and edge detection performance of our architecture, then assess the reconstructed wireframes in terms of structural average precision and of a newly designed wireframe edit distance.

Original: Mean Average precision mAP v for vertices.
Revised: Mean Average precision mAP v for vertices.

Original: To generate high quality wireframes, the predicted vertex positions must be accurate.
Revised: To generate high quality wireframes, the predicted vertex positions must be accurate.

Original: This metric evaluates the geometric quality of vertices, regardless of edge links.
Revised: This metric evaluates the geometric quality of vertices, regardless of edge links.

Original: A predicted vertex is considered a true positive if the distance to the nearest ground truth vertex is below a threshold η v .
Revised: A predicted vertex is considered a true positive if the distance to the nearest ground truth vertex is below a threshold η v .

Original: For a given η v we generate precision-recall curves by varyingthe detection threshold.
Revised: For a given η v we generate precision-recall curves by varying

Original: Average precision (AP v ) is deﬁned as the area under this curve, mAP v is averaged over different thresholds η v .
Revised: [Figure]

Original: Point-wise precision and recall for edges.
Revised: Point-wise precision and recall for edges.

Original: We do not have a baseline that directly extracts 3D wireframe edges.
Revised: We do not have a baseline that directly extracts 3D wireframe edges.

Original: Rather, existing methods label individual input points as "lying on an edge", and produce corresponding precision-recall curves (Hackel et al., 2016; Yu et al., 2018).
Revised: Rather, existing methods label individual input points as "lying on an edge", and produce corresponding precision-recall curves (Hackel et al., 2016; Yu et al., 2018).

Original: To use this[Figure] metric, we label a 3D point as "edge point" if its distance to the nearest wireframe edge is below the average point-to-point distance.
Revised: To use this metric, we label a 3D point as "edge point" if its distance to the nearest wireframe edge is below the average point-to-point distance.

Original: As for AP v , we can now check whether a predicted "edge point" is correct up to η e , and compute AP e and mean average precision (mAP e ) over different η e .
Revised: As for AP v , we can now check whether a predicted "edge point" is correct up to η e , and compute AP e and mean average precision (mAP e ) over different η e .

Original: Structural average precision for wireframes.
Revised: Structural average precision for wireframes.

Original: The above two evaluation metrics looks at vertices and edges separately, in terms of geometry.
Revised: The above two evaluation metrics looks at vertices and edges separately, in terms of geometry.

Original: In order to comprehensively evaluate the generated wireframe, we also need to take into account the connectivity.
Revised: In order to comprehensively evaluate the generated wireframe, we also need to take into account the connectivity.

Original: The structural average precision (sAP, Zhou et al., 2019a) metric, inspired by mean average precision, can be used to assess the overall prediction.
Revised: The structural average precision (sAP, Zhou et al., 2019a) metric, inspired by mean average precision, can be used to assess the overall prediction.

Original: This metric checks if the two end points (˜ v i , ˜ v j ) of a detected edge both match the end points ( v k , v l ) of a ground truth edge up to a threshold η w , i.e., min v k ∈V (cid:107) ˜ v
Revised: This metric checks if the two end points (˜ v i , ˜ v j ) of a detected edge both match the end points ( v k , v l ) of a ground truth edge up to a threshold η w , i.e., min v k ∈V (cid:107) ˜ v

Original: i − v k (cid:107) 2 + min v l ∈V (cid:107) ˜ v j − v l (cid:107) 2 < η w , ( v k , v l ) ∈ E .
Revised: i − v k (cid:107) 2 + min v l ∈V (cid:107) ˜ v j − v l (cid:107) 2 < η w , ( v k , v l ) ∈ E .

Original: We report sAP for different η w and mean sAP (msAP
Revised: We report sAP for different η w and mean sAP (msAP).

Original: Wireframe edit distance (WED).
Revised: Wireframe edit distance (WED).

Original: In order to topologically compare wireframes, we have designed a quality measure based on edit distance.
Revised: In order to topologically compare wireframes, we have designed a quality measure based on edit distance.

Original: We consider wireframes as geometric graphs drawn in 3D space.
Revised: We consider wireframes as geometric graphs drawn in 3D space.

Original: Distance measures commonly used in computational geometry and graph theory, such as Hausdorff distance and Frechet distance, resistance distance, or geodesic distance, do not seem to apply to our situation.
Revised: Distance measures commonly used in computational geometry and graph theory, such as Hausdorff distance and Frechet distance, resistance distance, or geodesic distance, do not seem to apply to our situation.

Original: Inspired by Cheong et al.
Revised: Inspired by Cheong et al.

Original: (2009), we propose a wireframe edit distance (WED).
Revised: (2009), we propose a wireframe edit distance (WED).

Original: It is a variant of the graph edit distance (GED), which measures how many elementary graph edit operators (vertex insertion/deletion, edge insertion/deletion, etc.) are needed to transform one graph to another.
Revised: It is a variant of the graph edit distance (GED), which measures how many elementary graph edit operators (vertex insertion/deletion, edge insertion/deletion, etc.) are needed to transform one graph to another.

Original: Instead of allowing arbitrary sequences of operations, which makes computing
Revised: Instead of allowing arbitrary sequences of operations, which makes computing

Original: the
Revised: the

Original: GED NP-hard, we ﬁx their order, see Fig.
Revised: GED NP-hard, we ﬁx their order, see Fig.

Original: 3: (1) vertex matching; (2) vertex translation; (3) vertex insertion; (4) edge deletion; (5) edge insertion.
Revised: 3: (1) vertex matching; (2) vertex translation; (3) vertex insertion; (4) edge deletion; (5) edge insertion.

Original: Let the ground truth wireframe W gt =
Revised: Let the ground truth wireframe W gt =

Original: ( V gt , E gt ) and the predicted wireframe W
Revised: ( V gt , E gt ) and the predicted wireframe W

Original: o
Revised: o

Original: =
Revised: =

Original: ( V o , E o ) .
Revised: ( V o , E o ) .

Original: First, we match each vertex v oi in W o to the nearest ground truth vertex v gtu in W gt , then translate them at a cost of c v · (cid:107) v oi v gtu (cid:107) .
Revised: First, we match each vertex v oi in W o to the nearest ground truth vertex v gtu in W gt , then translate them at a cost of c v · (cid:107) v oi v gtu (cid:107) .

Original: New vertices are inserted where a ground truth vertex has no match (at no cost, as cost will accrue during edge insertion).
Revised: New vertices are inserted where a ground truth vertex has no match (at no cost, as cost will accrue during edge insertion).

Original: After all vertex operations, we perform edge deletion and insertion based on ground truth edges at a cost of c e · (cid:107) e (cid:107) , where (cid:107) e (cid:107) is the length of deleted/inserted edges.
Revised: After all vertex operations, we perform edge deletion and insertion based on ground truth edges at a cost of c e · (cid:107) e (cid:107) , where (cid:107) e (cid:107) is the length of deleted/inserted edges.

Original: The ﬁnal WED is the sum of all cost terms.
Revised: The ﬁnal WED is the sum of all cost terms.

Original: 4. R ESULTS AND C OMPARISONS
Revised: 4. R ESULTS AND C OMPARISONS

Original: Vertex detection.
Revised: Vertex detection.

Original: We validate the PC2WF vertex detection module and compare to a Harris3D baseline (with subsequent NMS to guarantee a fair comparison) on the ABC dataset, Tab. 1.
Revised: We validate the PC2WF vertex detection module and compare to a Harris3D baseline (with subsequent NMS to guarantee a fair comparison) on the ABC dataset, Tab. 1.

Original: Exemplary visual results and precision-recall curves are shown in Fig.
Revised: Exemplary visual results and precision-recall curves are shown in Fig.

Original: 4 and Fig.5.
Revised: 4 and Fig.5.

Original: Harris3D often fails to accurately localise a corner point, and on certain thin structures it returns many false positives.
Revised: Harris3D often fails to accurately localise a corner point, and on certain thin structures it returns many false positives.

Original: The patch size M used in our vertex detector has an impact on performance.
Revised: The patch size M used in our vertex detector has an impact on performance.

Original: Patch sizes between 20 and 50 achieve the best performance, where the precision stays at a high level over a large recall range.
Revised: Patch sizes between 20 and 50 achieve the best performance, where the precision stays at a high level over a large recall range.

Original: Patch size 1 leads to low precision (although still better than Harris3D), conﬁrming that per-point features, even when computed from a larger receptive ﬁeld, are affected by noise and insufﬁcient to ﬁnd corners with acceptable false positive ratio.
Revised: Patch size 1 leads to low precision (although still better than Harris3D), conﬁrming that per-point features, even when computed from a larger receptive ﬁeld, are affected by noise and insufﬁcient to ﬁnd corners with acceptable false positive ratio.

Original: We refer the interested reader to the supplementary material for a more exhaustive ablation study. 
Revised: We refer the interested reader to the supplementary material for a more exhaustive ablation study. [Table]

Original: Edge prediction.
Revised: Edge prediction.

Original: Due to the limited number of methods able to extract wireframes from 3D point clouds, we compare PC2WF to recent algorithms that detect edge points, such as FREE (Bazazian et al., 2015), ECD (Ahmed et al., 2018), FEEM (Xia & Wang, 2017), Contour Detector (Hackel et al., 2016) and EC-Net (Yu et al., 2018).We re-train the EC-Net model on our own dataset.
Revised: Due to the limited number of methods able to extract wireframes from 3D point clouds, we compare PC2WF to recent algorithms that detect edge points, such as FREE (Bazazian et al., 2015), ECD (Ahmed et al., 2018), FEEM (Xia & Wang, 2017), Contour Detector (Hackel et al., 2016) and EC-Net (Yu et al., 2018).

Original: As its loss function also requires a "surface loss", we additionally use the ground truth surfaces for training, which our model does not need.

Original: We also compare with Polyﬁt (Nan & Wonka, 2017), which is the [Table] [Table] [Table]
Revised: We also compare with Polyﬁt (Nan & Wonka, 2017), which is the only method able to reconstruct a vectorial representation similar to ours from a point cloud.

Original: [Table]

Original: only method able to reconstruct a vectorial representation similar to ours from a point cloud.

Original: Since Polyﬁt extracts planar surfaces of the object, we must convert that representation into a wireframe, which amounts to identifying the plane intersections.
Revised: Since Polyﬁt extracts planar surfaces of the object, we must convert that representation into a wireframe, which amounts to identifying the plane intersections.

Original: Precision-recall curves for all methods are shown in Fig.
Revised: Precision-recall curves for all methods are shown in Fig.

Original: Visual results are shown in Fig.
Revised: Visual results are shown in Fig.

Original: PC2WF outperforms all baselines based on hand-crafted features like FREE, ECD, FEEM and Contour Detector, as well as the deep learning method EC-Net, across all quality measures (Tab. 2).
Revised: PC2WF outperforms all baselines based on hand-crafted features like FREE, ECD, FEEM and Contour Detector, as well as the deep learning method EC-Net, across all quality measures (Tab. 2).

Original: A visual comparison between the ground truth, PC2WF, EC-Net Yu et al.
Revised: A visual comparison between the ground truth, PC2WF, EC-Net Yu et al.

Original: (2018), and
Revised: (2018), and

Original: Polyﬁt is shown in Fig.
Revised: Polyﬁt is shown in Fig.

Original: One can clearly see the advantage of predicting vector edges rather than "edge points", as they lead to a much sharper result.
Revised: One can clearly see the advantage of predicting vector edges rather than "edge points", as they lead to a much sharper result.

Original: The inevitable blur of edge points across the actual contour line, and their irregular density, make vectorisation a non-trivial problem.
Revised: The inevitable blur of edge points across the actual contour line, and their irregular density, make vectorisation a non-trivial problem.

Original: Polyﬁt and PC2WF show comparable performance for this speciﬁc point cloud.
Revised: Polyﬁt and PC2WF show comparable performance for this speciﬁc point cloud.

Original: PC2WF failed to localise some corners and missed some small edges, whereas Polyﬁt failed to reconstruct the lower part of the armchair.
Revised: PC2WF failed to localise some corners and missed some small edges, whereas Polyﬁt failed to reconstruct the lower part of the armchair.

Original: Wireframe Reconstruction.
Revised: Wireframe Reconstruction.

Original: We visualise PC2WF’s output wireframes in Fig.
Revised: We visualise PC2WF’s output wireframes in Fig.

Original: Structural precision-recall curves with various patch sizes are shown in Fig.
Revised: Structural precision-recall curves with various patch sizes are shown in Fig.

Original: For additional examples of

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: [Figure] [Table] [Table] output predictions, including cases with curved edges, please refer to the supplementary material.
Revised: For additional examples of output predictions, including cases with curved edges, please refer to the supplementary material.

Original: The results are aligned with the ones of the vertex module.
Revised: The results are aligned with the ones of the vertex module.

Original: Moderate patch sizes between 20 and 50 achieve the best performance.
Revised: Moderate patch sizes between 20 and 50 achieve the best performance.

Original: Tab. 3 shows the structural average precision with patch size 50 , which exceeds the one of Polyﬁt.
Revised: Tab. 3 shows the structural average precision with patch size 50 , which exceeds the one of Polyﬁt.

Original: The results in terms of the wireframe edit distance are shown in
Revised: The results in terms of the wireframe edit distance are shown in

Original: Tab. 4 for PC2WF and Polyﬁt.
Revised: Tab. 4 for PC2WF and Polyﬁt.

Original: The average number of predicted vertices (21.7) and ground truth vertices (20.1) per object are close, such that only few vertex insertions are needed in most cases.
Revised: The average number of predicted vertices (21.7) and ground truth vertices (20.1) per object are close, such that only few vertex insertions are needed in most cases.

Original: Although all predicted vertices need some editing, the WED v caused by those edits is small (0.2427), meaning that the predictions are accurate.
Revised: Although all predicted vertices need some editing, the WED v caused by those edits is small (0.2427), meaning that the predictions are accurate.

Original: On the contrary, the 2.6 edges that need to be edited on average increase WED e a lot more (1.4142) and dominate the WED, i.e., the inserted/deleted edges have signiﬁcant length.
Revised: On the contrary, the 2.6 edges that need to be edited on [Figure] [Figure] [Figure]

Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original:   C ONCLUSION
Revised: [Table] [Table] average increase WED e a lot more (1.4142) and dominate the WED, i.e., the inserted/deleted edges have signiﬁcant length.  C ONCLUSION

Original: We have proposed PC2WF, an end-to-end trainable deep architecture to extract a vectorised wireframe from a raw 3D point cloud.
Revised: We have proposed PC2WF, an end-to-end trainable deep architecture to extract a vectorised wireframe from a raw 3D point cloud.

Original: The method achieves very promising results for man-made, polyhedral  objects, going one step further than low-level corner or edge detectors, while at the same time outperforming them on the isolated vertex and edge detection tasks.
Revised: The method achieves very promising results for man-made, polyhedral [Figure] [Table] objects, going one step further than low-level corner or edge detectors, while at the same time outperforming them on the isolated vertex and edge detection tasks.

Original: We see our method as one further step from robust, but redundant low-level vision to compact, editable 3D geometry.
Revised: We see our method as one further step from robust [Table] but redundant low-level vision to compact, editable 3D geometry.

Original: As future work we aim to address the biggest limitation of our current method which is the inability to handle wireframes with strongly curved edges.
Revised: As future work we aim to address the biggest limitation of our current method which is the inability to handle wireframes with strongly curved edges.