Deep Vectorization of Technical Drawings

Deep Vectorization of Technical Drawings

Vage Egiazarian    Oleg Voynov    Alexey Artemov Skolkovo Institute of Science and Technology, 3 Nobel Street, Skolkovo 143026, Russian Federation    Denis Volkhonskiy Skolkovo Institute of Science and Technology, 3 Nobel Street, Skolkovo 143026, Russian Federation    Aleksandr Safin Skolkovo Institute of Science and Technology, 3 Nobel Street, Skolkovo 143026, Russian Federation    Maria Taktasheva Skolkovo Institute of Science and Technology, 3 Nobel Street, Skolkovo 143026, Russian Federation    Denis Zorin New York University, 70 Washington Square South, New York NY 10012, USA
{vage.egiazarian, oleg.voinov, a.artemov, denis.volkhonskiy, aleksandr.safin, maria.taktasheva },, Skolkovo Institute of Science and Technology, 3 Nobel Street, Skolkovo 143026, Russian Federation
   Evgeny Burnaev Skolkovo Institute of Science and Technology, 3 Nobel Street, Skolkovo 143026, Russian Federation

We present a new method for vectorization of technical line drawings, such as floor plans, architectural drawings, and 2D CAD images. Our method includes (1) a deep learning-based cleaning stage to eliminate the background and imperfections in the image and fill in missing parts, (2) a transformer-based network to estimate vector primitives, and (3) optimization procedure to obtain the final primitive configurations. We train the networks on synthetic data, renderings of vector line drawings, and manually vectorized scans of line drawings. Our method quantitatively and qualitatively outperforms a number of existing techniques on a collection of representative technical drawings.

transformer network, vectorization, floor plans, technical drawings

Figure 1: An overview of our vectorization method. We clean the input image using a deep CNN splitting the input image into patches, we predict primitive placement with a deep CNN; we further refine the predictions using an optimization method, merging them together into the final vectorization.

1 Introduction

Vector representations are often used for technical images, such as architectural and construction plans and engineering drawings. Compared to raster images, vector representations have a number of advantages. They are scale-independent, much more compact, and, most importantly, support easy primitive-level editing. These representations also provide a basis for higher-level semantic structure in drawings (e.g., with sets of primitives hierarchically grouped into semantic objects).

However, in many cases, technical drawings are available only in raster form. Examples include older drawings done by hand, or for which only the hard copy is available, and the sources were lost, or images in online collections. When the vector representation of a drawing document is unavailable, it is often constructed, typically by hand, from scans or photos. Conversion of a raster image to a vector representation is usually referred to as vectorization.

While different applications have distinct requirements for vectorized drawings, common goals for vectorization are:

  • approximate the semantically or perceptually important parts of the input image well;

  • remove, to the extent possible, the artifacts or extraneous data (such as missing parts of line segments and noise) in the images;

  • minimize the number of used primitives, producing a compact and easily editable representation.

We note that the first and last requirements are often conflicting. E.g., in the extreme case, for a clean line drawing, 100% fidelity can be achieved by ”vectorizing” every pixel with a separate line.

In this paper, our goal is to develop a set of algorithms for geometrically precise and compact reconstruction of vector representations of technical drawings in a fully automatic way and performing significantly better, according to a number of metrics, than existing state-of-the-art algorithms. Distinctive features of the types of drawings we target include the prevalence of simple shapes (line segments, circular arcs, etc.) and relative lack of irregularities (such as interruptions and multiple lines approximating a single line) other than imaging flaws.

Our vectorization pipeline includes components addressing vectorization goals listed above. The central element of the pipeline is a deep-learning accelerated optimization method matching geometric primitives to the raster image. This component addresses the key goal of finding a compact representation of a part of the rasterized image (a patch) with few vector graphics primitives. It is preceded by a learning-based image cleaning stage, removing background and noise as well as performing infill of missing parts of the image. It is followed by a postprocessing stage, aimed at further reducing the number of primitives by merging primitives discovered in adjacent patches.

Our paper includes the following contributions:

  1. We develop a novel vectorization method. It is based on a learnable deep vectorization model and a new primitive optimization approach. We use the model to obtain an initial vector approximation of the image, and the optimization produces the final result.

  2. Based on the proposed vectorization method, we demonstrate a complete vectorization system, including a preprocessing learning-based cleaning step and a postprocessing step aiming to minimize the number of primitives.

  3. We conduct an ablation study of our approach and compare it to several state-of-the-art methods.

2 Related work


There is a large number of methods for image and line drawing vectorization. However, these methods solve somewhat different, often imprecisely defined versions of the problem and target different types of inputs and outputs. Some methods assume clean inputs and aim to faithfully reproduce all geometry in the input, while others aim, e.g., to eliminate multiple close lines in sketches. Our method is focused on producing an accurate representation of input images with mathematical primitives.

One of the widely-used methods for image vectorization is a Potrace [31]. It requires a clean, black-and-white input and extracts boundary curves of dark regions, solving a problem different from ours (e.g., a single line or curve segment is always represented by polygon typically with many sides). Recent works [24] and [18] use Potrace as a stage in their algorithms.

Methods based on curve network topology extraction and cleanup include [4, 10, 3, 25, 14]. We compare to [1] and [10] which we found to be the best-performing methods in this class.

A recent sketch vectorization method [1] uses a polyvector field (crossfield) to guide the orientation of primitives. The method applies a sophisticated set of tuneable heuristics for curve network construction and topology cleanup, which are difficult to tune to produce clean vectorizations of technical drawings with a low number of primitives.

Neural network-based vectorization.

Neural networks were applied in the context of vectorization in a variety of ways.

[21] is a method relying on neural networks for generating vectorized semantically annotated floor plans from raster images. At vectorization level, this method works by detecting a limited set of axis-aligned junctions and postprocessing to merge them, which is an approach specific to a subset of floor plans (e.g., does not handle diagonal or curved walls).

In [9], machine learning is used to extract a higher-level representation from a raster line drawing, specifically a program generating this drawing. The paper does not aim to capture the geometry of primitives faithfully and is restricted to a class of relatively simple diagrams.

An interesting recent direction is the generation of sketches using neural networks that learn a latent model representation for sketch images [12, 37, 15]. In principle, this approach can be used to approximate input raster images, but the geometric fidelity, in this case, is not adequate for most applications.

The algorithm of [11] has similarities to our method: it uses a neural network-based initialization for a more precise geometry fit for Bezier curve segments. Only simple input data (MNIST characters) are considered for line drawing reconstruction. The method was also applied to reconstructing 3D surfaces of revolution from images.

In [36] algorithms for generating collections of color strokes approximating an input photo are described. While this is a task related to line drawing vectorization, it is more forgiving in terms of geometric accuracy and representation compactness.

We note that many works on vectorization focus on sketches. Although the line between different types of line drawings is blurry, we found that methods focusing exclusively on sketches often produce less desirable results for technical line drawings (e.g., [10] and [8]).

Vectorization datasets.

Building a large-scale real-world vectorization dataset is costly and time-consuming [20, 33]. One may start from raster dataset and create a vector ground-truth by tracing the lines manually. In this case, both location and the style may be difficult to match to the original drawing. Another way is to start from the vector image and obtain a raster image by rendering the vector. The latter approach does not necessarily produce realistic raster images, as degradation suffered by real-world documents are known to be challenging to model [17].

As a result, existing vectorization-related datasets either lack vector-graphics annotation (e.g., CVC-FP [6], Rent3D [22], SydneyHouse [5], and Raster-to-Vector [21] all provide semantic segmentation masks for raster images but not the vector ground truth) or are synthetic (e.g., SESYD [7], ROBIN [32], and FPLAN-POLY [29]).

Image cleaning.

The initial image cleaning is a crucial stage in our algorithm. Both [33] and related work [30], describe a GAN to convert hand-drawn raster images of sketches to clean raster line drawings. This method can be used as a preprocessing stage for vectorization analogous to our cleaning stage. We compare to this method in Section 4. Similar to our method, these approaches rely on training on synthetic data. The method of [20] uses a neural network to extract structural lines (e.g., curves separating image regions) in manga cartoon images.

Other related work.

Methods solving other vectorization problems include, e.g., [35] and [16], which approximates an image with adaptively refined constant color regions with piecewise-linear boundaries. [23] extracts a vector representation of road networks from aerial photographs; [2] also solves a similar problem and is shown to be applicable to several types of images. These methods use strong build-in priors on the topology of the curve networks.

3 Our vectorization framework

We first outline the entire framework and then discuss each aspect in detail.

Our framework (see Fig. 1) takes a raster technical drawing cleared of text as an input. It produces a collection of graphical primitives, namely line segments and quadratic Beźier curves defined by the control points and width. Our overall processing pipeline consists of the following steps:

  1. We clean the input image from noise, adjust the contrast and fill in missing parts;

  2. We split the cleaned image into patches. For each patch we estimate initial primitive placement;

  3. Refine the predictions;

  4. Merge refined predictions from all patches and snap close endpoints of different primitives.

3.1 Preprocessing of input raster images

The goal of the cleaning stage is to produce a raster image that has a more clearly visible line structure compared to the input unprocessed raw data, eliminate noise, and remove gaps in lines, when these are imaging artifacts. All background/non-ink areas should get set to white.

Raster-cleaning task can be viewed as a semantic image segmentation in that the pixels of the input image are assigned one of several classes (in our case, background, i.e. whitespace, and foreground, i.e. ink). Inspired by [20] we used fully-convolutional network U-net [28]. It is considered to be the state-of-the-art in segmentation tasks, as it provide a way to take into account the image structure at multiple resolutions. Our raster-cleaning model is implemented as a U-net with skip-connections trained in an image-to-image mode. We train our raster cleaning models using a mixed dataset consisting of synthesized and real-world images described in Section 4.1.

3.2 Estimation of primitives with neural network

To vectorize a clean raster technical drawing, we split it into square fixed-size patches. For each patch we independently estimate the primitives with a feed-forward CNN. The division into small patches increases efficiency, as the patches are processed in parallel. It also increases the robustness of the trained model, as it learns on simple structures.

We encode each patch with a ResNet-based [13] feature extractor . Then we decode it tensors representing feature embeddings of the primitives using a sequence of Transformer blocks [34]


Each row of a feature embedding represents one of the estimated primitives with a set of hidden parameters. The use of Transformer architecture allows to vary the number of primitives to be found in the patch. The maximal number of primitives is set by choosing the size of the initial embedding , the values of which are initialized with positional encoding, as described in [34]. While the exact number of primitives in a patch is not known a priori, more than 97% of patches in our data contain no more than 10 primitives. Therefore, we fix the maximal number of primitives and filter out the excess predictions with an additional stage. Specifically, we pass the last feature embedding to a fully-connected block. It extracts the coordinates of the control points and the width of the primitives , and the confidence values that indicate that the primitive should be discarded if the value is lower than 0.5.

Loss function.

To train the primitive extraction network we utilize a multi-task loss function. It is composed of binary cross-entropy of the confidence and a weighted sum of and deviations of the parameters


where the target confidence vector is all ones, with zeros in the end indicating placeholder primitives, all target parameters of which are set to zero. This function is not invariant w.r.t. to permutations of the primitives and their control points. Thus we sort the endpoints in each target primitive and the target primitives by their parameters lexicographically.

3.3 Refinement of estimations with optimization

To refine the estimated primitives and align them to the raster image, we design a functional that depends on the primitive parameters and raster image and optimize it w.r.t. the primitive parameters


We use physical intuition of attracting charges spread over the area of the primitives and placed in the filled pixels of the raster image. To prevent alignment of different primitives to the same region, we model repulsion of the primitives.

We define the optimized functional as the sum of three terms per primitive


where are the position parameters of the primitives, and are the size parameters, and .

We define the position of a line segment by the coordinates of its midpoint and inclination angle, and the size by its length and width. For a curve arc, we define the midpoint at the intersection of the curve and the bisector of the angle between the segments connecting the middle control point and the endpoints. We use the lengths of these segments, and the inclination angles of the segments connecting the “midpoint” with the endpoints.

Charge interactions.

We base different parts of our functional on the energy of interaction of unit point charges , , defined as a sum of close- and far-range potentials


parameters of which we choose experimentally , , . The energy of interaction of the uniform positively charged area of the primitive and a grid of point charges at the pixel centers is then defined by the following equation, that we integrate analytically for lines


We approximate it for curves as the sum of integrals over the segments of the polyline flattening this curve.

In our functional we use several different charge grids, encoded as vectors of length . representing the raster image, representing the rendering of the primitive based on current values of parameters of the primitive and representing the rendering of all the primitives in the patch, with charge magnitudes set to intensities of the pixels. and are updated at each iteration.

Energy terms.

In our description of energy terms, we use to denote the componentwise product of vectors, and denotes the vector of ones of an appropriate size.

The first term is responsible for growing the primitive to cover filled pixels and shrinking it if unfilled pixels are covered, with the position of the primitive fixed:


The weighting enforces coverage of a continuous raster region following the form and orientation of the primitive. Specifically, we set to 1 inside the largest region aligned with the primitive with only shaded pixels of the raster. For example, for a line segment, this region is a rectangle centered at the center of the segment and aligned with the segment.

The second term is responsible for alignment of fixed size primitives


The weighting here adjusts this term with respect to the first one, and subtraction of the rendering of the primitive from the total rendering of the patch ensures that transversal overlaps are not penalized.

The last term is responsible for collapse of overlapping collinear primitives; for this term, we use :


where is the direction of the primitive at its closest point to the pixel, is the sum of directions of all the other primitives weighted w.r.t. their “presence”, and is chosen experimentally.

As our functional is based on charge interactions, we can use well-known approximations used in physics to solve many-body interactions (mean field theory). This translates into the observation that one can obtain an approximation of the solution by viewing interactions of each primitive with the rest as interactions with a static set of charges, i.e., viewing each energy term as depending only on the parameters of the primitive . This enables very efficient gradient computation for our functional, as one needs to differentiate each terms with respect to a small number of parameters only.

We optimize the functional (6) by Adam, using a gradient computed in the following way. For faster convergence, every few iterations we join lined up primitives by stretching one and collapsing the rest, and move collapsed primitives into uncovered raster pixels.

3.4 Merging estimations from all patches

To produce the final vectorization, we merge the refined estimations from all patches with straightforward heuristic algorithms. For lines, we build a graph with the primitives from the whole image as nodes and link two nodes if the respective primitives are close and collinear enough, but not if they are almost parallel. After that, we replace each group of primitives, forming a connected component of the graph, with a single primitive which is a least-squares fit to the endpoints of the original primitives. Finally, we snap the endpoints of intersecting primitives by cutting down the “dangling” ends shorter than a few percent of the total length of the primitive. For quadratic Bezier curves, for each pair of close primitives we estimate a replacement quadratic Bezier curve via least-squares and leave this curve instead of the former pair if the fit is close enough. We repeat this operation for the whole image until no more pairs allow a close fit.

4 Experimental evaluation

4.1 Datasets

To train our networks and evaluate them on a wide variety of images, we have developed four distinct datasets: {enumerate*}[label=(0)]

synthetic raster cleaning datasets;

real-world raster for cleaning fine-tuning and evaluation;

real-world vector datasets containing floor-plans (PFP);

real-world vector dataset containing mechanical drawings: rendering of ABC models.

Figure 2: Examples of vector synthetic local patches that we use for training our deep vectorization model.

Synthetic datasets.

We create a synthetic dataset for the cleaning step. We take into account the restriction that the visual content of synthetic data is similar to the real-world images.

To create the synthetic line drawing, we use graphical primitives (straight lines, curved lines, and circular arcs) and objects (parallelepipeds, circles, and triangles). We use 40 realistic photographed and scanned paper backgrounds, randomly selected from images available online. Our synthetic dataset consists of images at a resolution of .

In addition for cleaning we create synthetic data , by mimicing real data patch distribution, to train vectorization network (see Figure 2).

Figure 3: Our real cleaning dataset: (a) displays an example of a original line drawing; (b) a cleaned version of the drawing (note in lines gaps that are subject to infilling), and (c) a target version with infilled lines.

Degraded line drawings(DLD).

We collected photographed or scanned floor plan images. The resolutions of the images, on average, is pixels. We manually remove text and clean the images using the Photoshop software. We obtain their versions (a) without background, (b) the same having improved lines (where we have inpainted gaps and sharpened edges). We provide sample images from the created dataset demonstrating these versions in Figure 3.

PFP floor plan vector dataset.

To obtain a vector dataset for training the model, we downloaded 1554 PDF documents containing real-world architectural floor plans from a commercial website [27]. We transformed them into a scalable vector-graphics format, perform extensive augmentations in terms of both configurations (rotations, translations, and random crops) and parameterizations (line widths) of primitives. We use 1364 floor plan images for training and leave 150 images for validation. As PFP dataset mostly contains configurations of straight lines of varying complexity. We use it to demonstrate the performance of our method with lines only.

ABC mechanical parts vector dataset.

We use parametric CAD models from the ABC dataset [19]. They have been designed to model mechanical parts with sharp edges and well defined surfaces. To create a vector image, we use the boundary representation of the CAD model, perform an arbitrary 3D rotation, and render it with a parallel projection using the open-source software Open Cascade [26].

We split both vector datasets into patches and create training targets required by the neural network, as described in Section 3.2.

4.2 Evaluation setup

For image cleaning, we use synthetic training data along with real images from the DLD dataset. We randomly split real cleaned images to train/val/test as 51/15/15 images correspondingly. We use the train and validation set during training and test set for evaluating models.

Due to the dominance of the number of lines on floorplan-based datasets we use lines on it and quadratic curves on ABC dataset to show our pipeline performance on both lines and curves.

On both PFP and ABC we randomly divided our datasets into train-val-test by original big images to prevent similar patch appearance in those sets. As test we used 40 images from PFP and 50 images in ABC, with resolutions of the images pixels.

4.3 Quality measures

Vectorization performance is naturally characterized using Intersection-over-Union (IoU) measure. It reflects deviations in two raster shapes and via . IoU can be used with both raster and vector drawings (the latter requires computing where Render is a rendering operator).

Almost all methods do not take into account the primitives width for constructing a vector representation. Thus we put the primitives width equal to the average width for fair method comparison by IoU. In case, when there isn’t ground truth vector, we set the width as the sum of all nonzero pixels divided by the length of the predicted primitives.

IoU does not capture deviations in graphical primitives that have similar shapes but are slightly offset from each other, see Figure 4. We additionally compute the difference in skeleton structures of the two vector images and using Hausdorff distance, defined by


and mean minimal deviation, defined by


where denotes the Euclidean distance between a pair of points on skeletons. In practice, we densely sample the skeletons of the two vector images and approximate these metrics on a pair of point clouds.

Lastly, we quantify complexity of the vector drawing by the number of primitives constituting the vector image (denoted #P).

Figure 4: Vectorization defects diagnosed by our quality measures: (a) ground-truth (desired) vector image, (b) skeleton structure deviations, captured by (12)–(13) (pale green primitives denote ground-truth), (c) shape deviations, captured by IoU, (d) overparameterization.

4.4 Comparative studies

In this section, we assess quantitatively and qualitatively the quality of the proposed vectorization approach alongside the existing approaches.


We compare against Fidelity vs Simplicity (FvS) [10], Complete Hand-Drawn Sketch Vectorization Framework (CHD) [8], and Vectorization of Line Drawings via PolyVector Fields (PVF) [1] methods on vectorization tasks, and against Mastering Sketching [33] on cleaning tasks.

Clean line drawings.

The goal of this experiment is to characterize the maximum achievable geometric precision using a set of clean raster images with precisely known vector ground-truth (renderings of precisely known vector drawings).

We display values of numerical performance measures across methods on PFP and ABC datasets in Table 1.

There is always a trade-off between the number of primitives and the precision. Thus the comparison of some methods with different number of output primitives is not to fair. Our method outperforms all quality metrics on PFP dataset, but loses in primitive count to FVS. On ABC dataset PVF method has IoU equal to . In our case, we obtained IoU equal to . However, after post processing IoU decreased since it is very sensitive to small movements of the objects. Also PVF resulted in primitives which is much bigger then our .

IoU,% , px , px #P IoU,% , px , px #P IoU,% #P
FvS [10] 31 381 2.8 696 65 38 1.7 63
CHD [8] 22 214 2.1 1214 60 9 1 109 47 329
PVF [1] 60 204 1.5 38k 89 17 0.7 7818
Our 86/88 25 0.2 1331 77/77 19 0.6 97 79/82 452
Table 1: Quantitative comparison on our datasets. In IOU metric on our model the left one with average width, and right one with predicted.

We provide side-by-side images of vectorization results using various methods, along with close-ups, highlighting difference in vectorization across methods on PFP in Figure 5 .

[10]29% / 415px4.2px / 615CHD [8]21% / 215px1.9px / 1192 PVF [1]64% / 140px0.9px / 35k Our method89%/ 28px0.2px/ 1286 Ground truth,#P 1634

Figure 5: Qualitative comparison on PFP images, and values of metrics IoU / / / #P with best in bold. Endpoints of the primitives are shown in orange.

Degraded line drawings.

We would like to establish the effect of noise on the vectorization performance. For this purpose we characterize the typical anticipated level of geometric deviations using a representative set of real-world raster images (without vector ground-truth). We use the real images with low PSNR values in the dataset, according to their cleaned versions.

We display values of numerical performance measures across methods and datasets in the right part of the Table 1. Only CHD can work with noise images; we compare with this method.

We provide side-by-side images of vectorization results using various methods, along with close-ups, highlighting differences in vectorizations across methods in Figure 6.

Input image

CHD [8], 52% / 349

Our method, 78% / 368

Figure 6: Qualitative comparison on real noisy image, and values of metrics IoU / #P with best in bold. Primitives are shown in blue with endpoints in orange on top of the cleaned raster image.

One may conclude that cleaning prior to the vectorization step is necessary, when dealing with real-world drawings, to ensure geometric fidelity of the predictions.

Cleaning results.

We separately evaluate our cleaning procedure, comparing it with a recent cleaning method MS [33]. We display values of numerical performance measures in Table 2 and an example of cleaning results along with close-up fragments in Figure 7. We note that our cleaning procedure keeps straight and repeated lines commonly found in technical drawing while MS outputs wavy strokes and tends to join repeated straights, thus harming the structure of the drawing.

Figure 7: Cleaning results: (a) input photo of a floorplan, (b) a cleaning result by MS [33]; (c) a cleaned version produced by our model. Note the tendency of MS to unite closely neighbouring straights in closeups.
MS [33] 49 15.7
Our 92 25.5
Table 2: Comparison of our cleaning method with Mastering Sketching (MS). Comparison is performed on noisy images.

4.5 Ablation studies

In this section, we evaluate our proposed vectorization approach to understand the impact of each of our components. We perform forward feature selection technique on our pipeline modules. To this end, we compare vectorization results obtained using our system with the (a) full model without refinement and post-processing steps, (b) full model without post-processing, (c) full model. We show Ablation study results on the ABC test set in Table 3.

IoU,% , px , px #P
NN 65 52 1.4 309
NN + Refinement 91 19 0.3 240
NN + Refinement + Postpr 77 19 0.6 97
Table 3: Ablation study on ABC dataset. We compare the results of our method with and without refinement and post-processing

As you can see adding Refinement improve all metrics. So always using this module is justified. On the other hand adding postprocess decrease other metrics due to the trade-off between number of primitives and precision.

5 Conclusion

In this paper, we have described a system for vectorization of technical line drawings. Two critical steps in our pipeline (initial cleaning, and the initial placements of primitives) are using neural networks trained on a combination of synthetic and real data. A neural network can place the primitives approximately in the right location most of the time. However, its geometric accuracy is generally inadequate. Thus we add an optimization stage to the pipeline, adjusting primitive parameters to improve the fit. The evaluation shows that our algorithm, in general, performs significantly better compared to a number of recent vectorization algorithms.

Our algorithm can be easily extended in a number of ways. For example, integration with OCR systems will allow to separate and enhance the text annotations. One can also hope that training the method end-to-end, including the smooth part of the optimization stage, will improve the overall system performance.

6 Acknowledgement

The authors thank CDISE MSc. students Milena Gazdieva and Natalia Soboleva for their valuable contributions in preparing real-world raster and vector datasets, as well as Maria Kolos and Alexey Bokhovkin for contributing parts of shared codebase used throughout this project. The authors acknowledge the usage of the Skoltech CDISE HPC cluster Zhores for obtaining the results presented in this paper.


  • [1] M. Bessmeltsev and J. Solomon (2019) Vectorization of line drawings via polyvector fields. ACM Transactions on Graphics (TOG) 38 (1), pp. 9. Cited by: §2, §2, Figure 5, §4.4, Table 1.
  • [2] D. Chai, W. Forstner and F. Lafarge (2013) Recovering line-networks in images by junction-point processes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1894–1901. Cited by: §2.
  • [3] J. Chen, M. Du, X. Qin and Y. Miao (2018) An improved topology extraction approach for vectorization of sketchy line drawings. The Visual Computer 34 (12), pp. 1633–1644. Cited by: §2.
  • [4] J. Chen, Q. Lei, Y. Miao and Q. Peng (2015) Vectorization of line drawing image based on junction analysis. Science China Information Sciences 58 (7), pp. 1–14. Cited by: §2.
  • [5] H. Chu, S. Wang, R. Urtasun and S. Fidler (2016) Housecraft: building houses from rental ads and street views. In European Conference on Computer Vision, pp. 500–516. Cited by: §2.
  • [6] L. de las Heras, O. R. Terrades, S. Robles and G. Sánchez (2015) CVC-fp and sgt: a new database for structural floor plan analysis and its groundtruthing tool. International Journal on Document Analysis and Recognition (IJDAR) 18 (1), pp. 15–30. Cited by: §2.
  • [7] M. Delalandre, E. Valveny, T. Pridmore and D. Karatzas (2010) Generation of synthetic documents for performance evaluation of symbol recognition & spotting systems. International Journal on Document Analysis and Recognition (IJDAR) 13 (3), pp. 187–207. Cited by: §2.
  • [8] L. Donati, S. Cesano and A. Prati (2019) A complete hand-drawn sketch vectorization framework. Multimedia Tools and Applications 78 (14), pp. 19083–19113. Cited by: §2, Figure 5, Figure 6, §4.4, Table 1.
  • [9] K. Ellis, D. Ritchie, A. Solar-Lezama and J. Tenenbaum (2018) Learning to infer graphics programs from hand-drawn images. In Advances in neural information processing systems, pp. 6059–6068. Cited by: §2.
  • [10] J. Favreau, F. Lafarge and A. Bousseau (2016) Fidelity vs. simplicity: a global approach to line drawing vectorization. ACM Transactions on Graphics (TOG) 35 (4), pp. 120. Cited by: §2, §2, Figure 5, §4.4, Table 1.
  • [11] J. Gao, C. Tang, V. Ganapathi-Subramanian, J. Huang, H. Su and L. J. Guibas (2019) DeepSpline: data-driven reconstruction of parametric curves and surfaces. arXiv preprint arXiv:1901.03781. Cited by: §2.
  • [12] D. Ha and D. Eck (2018) A neural representation of sketch drawings. Cited by: §2.
  • [13] K. He, X. Zhang, S. Ren and J. Sun (2016) Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778. Cited by: §3.2.
  • [14] X. Hilaire and K. Tombre (2006) Robust and accurate vectorization of line drawings. IEEE Transactions on Pattern Analysis & Machine Intelligence (6), pp. 890–904. Cited by: §2.
  • [15] K. Kaiyrbekov and M. Sezgin (2019) Stroke-based sketched symbol reconstruction and segmentation. arXiv preprint arXiv:1901.03427. Cited by: §2.
  • [16] R. Kansal and S. Kumar (2015) A vectorization framework for constant and linear gradient filled regions. The Visual Computer 31 (5), pp. 717–732. Cited by: §2.
  • [17] T. Kanungo, R. M. Haralick, H. S. Baird, W. Stuezle and D. Madigan (2000) A statistical, nonparametric methodology for document degradation model validation. IEEE Transactions on Pattern Analysis and Machine Intelligence 22 (11), pp. 1209–1223. Cited by: §2.
  • [18] B. Kim, O. Wang, A. C. Öztireli and M. Gross (2018) Semantic segmentation for line drawing vectorization using neural networks. In Computer Graphics Forum, Vol. 37, pp. 329–338. Cited by: §2.
  • [19] S. Koch, A. Matveev, Z. Jiang, F. Williams, A. Artemov, E. Burnaev, M. Alexa, D. Zorin and D. Panozzo (2019) ABC: a big cad model dataset for geometric deep learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9601–9611. Cited by: §4.1.
  • [20] C. Li, X. Liu and T. Wong (2017) Deep extraction of manga structural lines. ACM Transactions on Graphics (TOG) 36 (4), pp. 117. Cited by: §2, §2, §3.1.
  • [21] C. Liu, J. Wu, P. Kohli and Y. Furukawa (2017) Raster-to-vector: revisiting floorplan transformation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2195–2203. Cited by: §2, §2.
  • [22] C. Liu, A. G. Schwing, K. Kundu, R. Urtasun and S. Fidler (2015) Rent3d: floor-plan priors for monocular layout estimation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3413–3421. Cited by: §2.
  • [23] G. Máttyus, W. Luo and R. Urtasun (2017) Deeproadmapper: extracting road topology from aerial images. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3438–3446. Cited by: §2.
  • [24] V. Munusamy Kabilan, B. Morris and A. Nguyen (2018) VectorDefense: vectorization as a defense to adversarial examples. arXiv preprint arXiv:1804.08529. Cited by: §2.
  • [25] G. Noris, A. Hornung, R. W. Sumner, M. Simmons and M. Gross (2013) Topology-driven vectorization of clean line drawings. ACM Transactions on Graphics (TOG) 32 (1), pp. 4. Cited by: §2.
  • [26] Open CASCADE Technology OCCT. Note: \url 2020-03-05 Cited by: §4.1.
  • [27] PrecisionFloorplan. Note: \urlhttp://precisionfloorplan.comAccessed: 2020-03-05 Cited by: §4.1.
  • [28] O. Ronneberger, P. Fischer and T. Brox (2015) U-net: convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention, pp. 234–241. Cited by: §3.1.
  • [29] M. Rusiñol, A. Borràs and J. Lladós (2010) Relational indexing of vectorial primitives for symbol spotting in line-drawing images. Pattern Recognition Letters 31 (3), pp. 188–201. Cited by: §2.
  • [30] K. Sasaki, S. Iizuka, E. Simo-Serra and H. Ishikawa (2018) Learning to restore deteriorated line drawing. The Visual Computer 34 (6-8), pp. 1077–1085. Cited by: §2.
  • [31] P. Selinger (2003) Potrace: a polygon-based tracing algorithm. Potrace (online), (2009-07-01). Cited by: §2.
  • [32] D. Sharma, N. Gupta, C. Chattopadhyay and S. Mehta (2017) DANIEL: a deep architecture for automatic analysis and retrieval of building floor plans. In 2017 14th IAPR International Conference on Document Analysis and Recognition (ICDAR), Vol. 1, pp. 420–425. Cited by: §2.
  • [33] E. Simo-Serra, S. Iizuka and H. Ishikawa (2018) Mastering sketching: adversarial augmentation for structured prediction. ACM Transactions on Graphics (TOG) 37 (1), pp. 11. Cited by: §2, §2, Figure 7, §4.4, §4.4, Table 2.
  • [34] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser and I. Polosukhin (2017) Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008. Cited by: §3.2, §3.2.
  • [35] J. Zhao, J. Feng and B. Zhou (2013) Image vectorization using blue-noise sampling. In Imaging and Printing in a Web 2.0 World IV, Vol. 8664, pp. 86640H. Cited by: §2.
  • [36] N. Zheng, Y. Jiang and D. Huang STROKENET: aneural painting environment. Cited by: §2.
  • [37] T. Zhou, C. Fang, Z. Wang, J. Yang, B. Kim, Z. Chen, J. Brandt and D. Terzopoulos (2018) Learning to doodle with stroke demonstrations and deep q-networks.. In BMVC, pp. 13. Cited by: §2.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description